Pillola: [C#] Double Linked List (implementata usando IList)

[daniele_dll]

using System;
using System.Collections;

namespace HostingTestPlatform.Server.Core
{
	/// <summary>
	/// Descrizione di riepilogo per SocketList.
	/// </summary>
	public class SocketList : IList
	{
		#region Double Linked List
		private class SocketItem : IDisposable
		{
			SocketItem head;
			SocketItem prev;
			SocketItem next;
			// HACK: System.Net.Sockets.Socket content;
			string content;

			bool disposed = false;

			// HACK: public SocketItem(SocketItem Head, SocketItem Prev, SocketItem Next, System.Net.Sockets.Socket Content)
			public SocketItem(SocketItem Head, SocketItem Prev, SocketItem Next, string Content)
			{
				this.head = Head;
				this.prev = Prev;
				this.next = Next;
				this.content = Content;
			}

			public bool IsDisposed
			{
				get
				{
					return disposed;
				}
			}

			public SocketItem Head
			{
				get
				{
					if (disposed == true)
					{
						throw new ObjectDisposedException("head");
					}

					return head;
				}
				set
				{
					if (disposed == true)
					{
						throw new ObjectDisposedException("head");
					}

					head = value;
				}
			}

			public SocketItem Prev
			{
				get
				{
					if (disposed == true)
					{
						throw new ObjectDisposedException("prev");
					}

					return prev;
				}
				set
				{
					if (disposed == true)
					{
						throw new ObjectDisposedException("prev");
					}

					prev = value;
				}
			}

			public SocketItem Next
			{
				get
				{
					if (disposed == true)
					{
						throw new ObjectDisposedException("next");
					}

					return next;
				}
				set
				{
					if (disposed == true)
					{
						throw new ObjectDisposedException("next");
					}

					next = value;
				}
			}

			// HACK: public System.Net.Sockets.Socket Content
			public string Content
			{
				get
				{
					if (disposed == true)
					{
						throw new ObjectDisposedException("content");
					}

					return content;
				}
				set
				{
					if (disposed == true)
					{
						throw new ObjectDisposedException("content");
					}

					content = value;
				}
			}

			~SocketItem()
			{
				Dispose(false);
			}

			protected virtual void Dispose(bool Disposing)
			{
				if (Disposing == true)
				{
					if (this.disposed == false)
					{
						this.head = null;
						this.prev = null;
						this.next = null;
						this.content = null;

						disposed = true;
					}
				}
			}

			#region Membri di IDisposable
			public void Dispose()
			{
				Dispose(true);

				GC.SuppressFinalize(this);
			}
			#endregion
		}
		#endregion

		SocketItem socketLinkedList;
		int numberOfElements;

		public SocketList()
		{
			//
			// TODO: aggiungere qui la logica del costruttore
			//
			socketLinkedList = null;
			numberOfElements = 1;
		}

		#region Internal Methods
		private void SetNewHead(SocketItem SocketItem)
		{
			if (socketLinkedList == null || socketLinkedList.IsDisposed)
			{
				return;
			}

			SocketItem currentItem = socketLinkedList.Head;
			do
			{
				currentItem.Head = SocketItem;
			}
			while ((currentItem = currentItem.Next) != null);
		}

		// HACK: private int GetIndexByContent(System.Net.Sockets.Socket content)
		private int GetIndexByContent(string content)
		{
			if (socketLinkedList == null || socketLinkedList.IsDisposed)
			{
				return -1;
			}

			SocketItem currentItem = socketLinkedList.Head;
			int currentIndex = 0;
			do
			{
				if (currentItem.Content == content)
				{
					break;
				}

				currentIndex++;
			}
			while ((currentItem = currentItem.Next) != null);

			return currentIndex;
		}

		private SocketItem GetItemByIndex(int index)
		{
			if (socketLinkedList == null || socketLinkedList.IsDisposed)
			{
				return null;
			}

			SocketItem currentItem = socketLinkedList.Head;
			int currentIndex = 0;
			do
			{
				if (currentIndex == index)
				{
					return currentItem;
				}

				currentIndex++;
			}
			while ((currentItem = currentItem.Next) != null);

			return null;
		}

		// HACK: private SocketItem GetItemByContent(System.Net.Sockets.Socket content)
		private SocketItem GetItemByContent(string content)
		{
			if (socketLinkedList == null || socketLinkedList.IsDisposed)
			{
				return null;
			}

			SocketItem currentItem = socketLinkedList.Head;
			do
			{
				if (currentItem.Content == content)
				{
					return currentItem;
				}
			}
			while ((currentItem = currentItem.Next) != null);

			return null;
		}

		private SocketItem GetLastItem()
		{
			if (socketLinkedList == null || socketLinkedList.IsDisposed)
			{
				return null;
			}

			SocketItem currentItem = socketLinkedList;
			while(true)
			{
				if (currentItem.Next != null)
				{
					currentItem = currentItem.Next;
				}
				else
				{
					break;
				}
			}

			socketLinkedList = currentItem;

			return currentItem;
		}

		private int CountItems()
		{
			if (socketLinkedList == null || socketLinkedList.IsDisposed)
			{
				return -1;
			}

			SocketItem currentItem = socketLinkedList.Head;
			int count = 0;
			do
			{
				if (currentItem.Next == null)
				{
					break;
				}

				count++;
			}
			while ((currentItem = currentItem.Next) != null);

			return count;
		}
		#endregion

		#region Membri di IList

		public bool IsReadOnly
		{
			get
			{
				return false;
			}
		}

		object IList.this[int index]
		{
			get
			{
				SocketItem requestedItem = GetItemByIndex(index);

				if (requestedItem == null)
				{
					throw new ArgumentOutOfRangeException("index");
				}

				return (object)requestedItem.Content;
			}
			set
			{
				if (value.GetType() != typeof(System.Net.Sockets.Socket))
				{
					throw new ArgumentException("Value must be a System.Net.Sockets.Socket type");
				}

				SocketItem requestedItem = GetItemByIndex(index);

				if (requestedItem == null)
				{
					throw new ArgumentOutOfRangeException("index");
				}

				// HACK: requestedItem.Content = (System.Net.Sockets.Socket)value;
				requestedItem.Content = (string)value;
			}
		}

		// HACK: public System.Net.Sockets.Socket this[int index]
		public string this[int index]
		{
			get
			{
				SocketItem requestedItem = GetItemByIndex(index);

				if (requestedItem == null)
				{
					throw new ArgumentOutOfRangeException("index");
				}

				return requestedItem.Content;
			}
			set
			{
				SocketItem requestedItem = GetItemByIndex(index);

				if (requestedItem == null)
				{
					throw new ArgumentOutOfRangeException("index");
				}

				requestedItem.Content = value;
			}
		}

		public void RemoveAt(int index)
		{
			SocketItem requestedItem = GetItemByIndex(index);

			if (requestedItem == null)
			{
				throw new ArgumentOutOfRangeException("index");
			}

			if (requestedItem.Prev == null)
			{
				if (requestedItem.Next == null)
				{
					socketLinkedList = null;
				}
				else
				{
					SetNewHead(requestedItem.Next);
					requestedItem.Next.Prev = null;
					socketLinkedList = requestedItem.Next;
				}
			}
			else
			{
				if (requestedItem.Next != null)
				{
					requestedItem.Prev.Next = requestedItem.Next;
					requestedItem.Next.Prev = requestedItem.Prev;
				}
				else
				{
					requestedItem.Prev.Next = null;
				}
			}

			requestedItem.Dispose();
			requestedItem = null;
		}

		void IList.Insert(int index, object value)
		{
			if (value.GetType() != typeof(System.Net.Sockets.Socket))
			{
				throw new ArgumentException("Value must be a System.Net.Sockets.Socket type");
			}

			SocketItem requestedItem = GetItemByIndex(index);

			if (requestedItem == null)
			{
				throw new ArgumentOutOfRangeException("index");
			}
			else
			{
				SocketItem newItem = new SocketItem(
					requestedItem.Head,
					requestedItem.Prev,
					requestedItem,
					// HACK: (System.Net.Sockets.Socket)value);
					(string)value);

				if (requestedItem.Prev == null)
				{
					newItem.Head = newItem;
					SetNewHead(newItem);
				}
				else
				{
					requestedItem.Prev.Next = newItem;
				}

				requestedItem.Prev = newItem;

				numberOfElements++;
			}
		}

		// HACK: public void Insert(int index, System.Net.Sockets.Socket Socket)
		public void Insert(int index, string Socket)
		{
			SocketItem requestedItem = GetItemByIndex(index);

			if (requestedItem == null)
			{
				throw new ArgumentOutOfRangeException("index");
			}
			else
			{
				SocketItem newItem = new SocketItem(
					requestedItem.Head,
					requestedItem.Prev,
					requestedItem,
					Socket);

				if (requestedItem.Prev == null)
				{
					newItem.Head = newItem;
					SetNewHead(newItem);
				}
				else
				{
					requestedItem.Prev.Next = newItem;
				}

				requestedItem.Prev = newItem;

				numberOfElements++;
			}
		}

		void IList.Remove(object value)
		{
			if (value.GetType() != typeof(System.Net.Sockets.Socket))
			{
				throw new ArgumentException("Value must be a System.Net.Sockets.Socket type");
			}

			// HACK: SocketItem requestedItem = GetItemByContent((System.Net.Sockets.Socket)value);
			SocketItem requestedItem = GetItemByContent((string)value);

			if (requestedItem == null)
			{
				return;
			}

			if (requestedItem.Prev == null)
			{
				if (requestedItem.Next == null)
				{
					socketLinkedList = null;
				}
				else
				{
					SetNewHead(requestedItem.Next);
					requestedItem.Next.Prev = null;
					socketLinkedList = requestedItem.Next;
				}
			}
			else
			{
				if (requestedItem.Next != null)
				{
					requestedItem.Prev.Next = requestedItem.Next;
					requestedItem.Next.Prev = requestedItem.Prev;
				}
				else
				{
					requestedItem.Prev.Next = null;
				}
			}
			requestedItem.Dispose();
			requestedItem = null;

			numberOfElements--;
		}

		// HACK: public void Remove(System.Net.Sockets.Socket Socket)
		public void Remove(string Socket)
		{
			SocketItem requestedItem = GetItemByContent(Socket);

			if (requestedItem == null)
			{
				return;
			}

			if (requestedItem.Prev == null)
			{
				if (requestedItem.Next == null)
				{
					socketLinkedList = null;
				}
				else
				{
					SetNewHead(requestedItem.Next);
					requestedItem.Next.Prev = null;
					socketLinkedList = requestedItem.Next;
				}
			}
			else
			{
				if (requestedItem.Next != null)
				{
					requestedItem.Prev.Next = requestedItem.Next;
					requestedItem.Next.Prev = requestedItem.Prev;
				}
				else
				{
					requestedItem.Prev.Next = null;
				}
			}
			requestedItem.Dispose();
			requestedItem = null;

			numberOfElements--;
		}

		bool IList.Contains(object value)
		{
			if (value.GetType() != typeof(System.Net.Sockets.Socket))
			{
				throw new ArgumentException("Value must be a System.Net.Sockets.Socket type");
			}

			// HACK: if (GetItemByContent((System.Net.Sockets.Socket)value) == null)
			if (GetItemByContent((string)value) == null)
			{
				return false;
			}
			else
			{
				return true;
			}
		}

		// HACK: public bool Contains(System.Net.Sockets.Socket Socket)
		public bool Contains(string Socket)
		{
			if (GetItemByContent(Socket) == null)
			{
				return false;
			}
			else
			{
				return true;
			}
		}

		public void Clear()
		{
			socketLinkedList = null;
			numberOfElements = 0;
		}

		int IList.IndexOf(object value)
		{
			if (value.GetType() != typeof(System.Net.Sockets.Socket))
			{
				throw new ArgumentException("Value must be a System.Net.Sockets.Socket type");
			}

			// HACK: return GetIndexByContent((System.Net.Sockets.Socket)value);
			return GetIndexByContent((string)value);
		}

		// HACK: public int IndexOf(System.Net.Sockets.Socket Socket)
		public int IndexOf(string Socket)
		{
			return GetIndexByContent(Socket);
		}

		int IList.Add(object value)
		{
			if (value.GetType() != typeof(System.Net.Sockets.Socket))
			{
				throw new ArgumentException("Value must be a System.Net.Sockets.Socket type");
			}

			SocketItem requestedItem = GetLastItem();

			if (requestedItem == null)
			{
				SocketItem newItem = new SocketItem(
					null,
					null,
					null,
					// HACK: (System.Net.Sockets.Socket)value);
					(string)value);

				newItem.Head = newItem;
				socketLinkedList = newItem;

				numberOfElements = 1;
				return 0;
			}
			else
			{
				SocketItem newItem = new SocketItem(
					requestedItem.Head,
					requestedItem,
					null,
					// HACK: (System.Net.Sockets.Socket)value);
					(string)value);

				requestedItem.Next = newItem;

				numberOfElements++;
				return numberOfElements - 1;
			}
		}