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;
			}
		}

[daniele_dll]

		// HACK: public int Add(System.Net.Sockets.Socket Socket)
		public int Add(string Socket)
		{
			SocketItem requestedItem = GetLastItem();

			if (requestedItem == null)
			{
				SocketItem newItem = new SocketItem(
					null,
					null,
					null,
					Socket);

				newItem.Head = newItem;
				socketLinkedList = newItem;

				numberOfElements = 1;
				return 0;
			}
			else
			{
				SocketItem newItem = new SocketItem(
					requestedItem.Head,
					requestedItem,
					null,
					Socket);

				requestedItem.Next = newItem;

				numberOfElements++;
				return numberOfElements - 1;
			}
		}

		public bool IsFixedSize
		{
			get
			{
				return false;
			}
		}

		#endregion

		#region Membri di ICollection

		public bool IsSynchronized
		{
			get
			{
				// TODO: aggiungere l'implementazione per il richiamo di SocketList.IsSynchronized
				return false;
			}
		}

		public int Count
		{
			get
			{
				return numberOfElements;
			}
		}

		public void CopyTo(Array array, int index)
		{
			// TODO: aggiungere l'implementazione di SocketList.CopyTo
		}

		public object SyncRoot
		{
			get
			{
				// TODO: aggiungere l'implementazione per il richiamo di SocketList.SyncRoot
				return null;
			}
		}

		#endregion

		#region Membri di IEnumerable

			public IEnumerator GetEnumerator()
			{
				// TODO: aggiungere l'implementazione di SocketList.GetEnumerator
				return null;
			}

		#endregion
	}
}

[daniele_dll]

Perché ho scritto tutto il codice prima ed il messaggio alla fine?

dannato forum! 13000 caratteri so troppi pochi

tornando IT ... cos'è tutta questa roba? è un'implementazione di un simili ArrayList (in realtà implementa IList e co) usando una double linked list, come da titolo, in C#

E' poco ottimizzata, anche se durante l'inserimento è appena 2 volte più lenta rispetto ad ArrayList, e manca l'enumeratore (quindi niente foreach, solo for)

E' strong type, di conseguenza si deve modificare il codice per renderlo consono al tipo col quale si vuole usare ... se cercate le varie righe che iniziano con
//HACK:

vedete dove va modificato il codice ... se notate la variabile Socket ovunque ... non ci fate caso perché l'ho scritta per gestirmi un'elenco di socket

perché l'ho postata dato che è perfettamente inutile e parecchio più lenta, oltre che non ottimizzata e probabilmente pure buggata?

perché credo che questo codice possa essere d'aiuto per qualcuno :P