I’ve been writing C#\/.NET code for a long time, but every now and then I feel the need to give myself a refresher on the basics and it usually results in finding features that have been added which I knew nothing about. You know how you get used to using classes so look no further. Well here’s my refresher on the .NET collection classes as of .NET 4.5<\/p>\n
ArrayList<\/strong><\/p>\n The ArrayList <\/a>is a wrapper around a standard object[]. It’s weakly typed and may suffer in performance tests against a generic array type such as a List<T> due to boxing\/unboxing.<\/p>\n Unlike a standard object[] declared arrays, multidimensional arrays elements are not directly supported. Although ofcourse you can create an ArrayList or ArrayLists.<\/p>\n BitArray<\/strong><\/p>\n The BitArray<\/a> class is a specialized collection for handling an array of bits. It allows us to manipulate the bits in various ways, but lacks bit shifting (for example).<\/p>\n BlockingCollection<T><\/strong><\/p>\n The BlockingCollection<\/a> class wraps an IProducerConsumerCollection<T> to allow thread-safe adding and removing of items. It also offers bounding capabilities.<\/p>\n ConcurrentBag<T><\/strong><\/p>\n The ConcurrentBag<\/a> is a thread-safe bag. Bags are used to store objects with no concern for ordering. They support duplicates and nulls.<\/p>\n ConcurrentDictionary<TKey, TValue><\/strong><\/p>\n The ConcurrentDictionary<\/a> is a thread-safe dictionary.<\/p>\n ConcurrentQueue<T><\/strong><\/p>\n The ConcurrentQueue<\/a> is a thread-safe Queue (FIFO collection).<\/p>\n ConcurrentStack<T><\/strong><\/p>\n The ConcurrentStack<\/a> is a thread-safe Queue (LIFO collection).<\/p>\n Collection<T><\/strong><\/p>\n The Collection<\/a> class is a base class for generic collections. Whilst you can instantiate a Collection<T> directly (i.e. it’s not abstract) it’s designed more from the point of view of extensibility, i.e. deriving you own collection type from it. It only really differs from a List<T>, in that it offersvirtual methods for you to overload to customize your collection, whereas a List<T> doesn’t offer such extensibility.<\/p>\n Dictionary<TKey, TValue><\/strong><\/p>\n A key\/value generic class. Duplicates are not allowed as keys, nor are nulls. For a thread-safe implementation, look at ConcurrentDictionary<TKey, TValue>.<\/p>\n HashSet<T><\/strong><\/p>\n The HashSet<T><\/a> is a set collection and thus cannot contain duplicate elements. Elements are not held in any particular order. It is aimed a set type operations, such as IntersectWith, Overlap etc.<\/p>\n Hashtable<\/strong><\/p>\n The Hashtable<\/a> stores key\/value pairs which are organised based upon the hash code of the key. As per the Dictionary class, keys cannot be null and duplicates are not allowed. Basically it’s a weakly typed Dictionary.<\/p>\n HybridDictionary<\/strong><\/p>\n The HybridDictionary<\/a> is a weakly typed Dictionary which can switch between using the ListDictionary for when there’s only a few items stored and then switching to the Hashtable when the collection gets large.<\/p>\n ImmutableDictionary<T><\/strong><\/p>\n The ImmutableDictionary<\/a> is, simply put, an immutable Dictionary.<\/p>\n See also ImmutableInterlocked <\/a>.<\/p>\n ImmutableHashSet<T><\/strong><\/p>\n The ImmutableHashSet<\/a> is, simply put, an immutable HashSet.<\/p>\n See also ImmutableInterlocked <\/a>. <\/p>\n ImmutableList<T><\/strong><\/p>\n The ImmutableList<\/a> is, simply put, an immutable List.<\/p>\n See also ImmutableInterlocked <\/a>.<\/p>\n ImmutableQueue<T><\/strong><\/p>\n The ImmutableQueue<\/a> is, simply put, an immutable Queue.<\/p>\n See also ImmutableInterlocked <\/a>. <\/p>\n ImmutableSortedDictionary<T><\/strong><\/p>\n The ImmutableSortedDictionary<\/a> is, simply put, an immutable SortedDictionary.<\/p>\n See also ImmutableInterlocked <\/a>. <\/p>\n ImmutableSortedSet<T><\/strong><\/p>\n The ImmutableSortedSet<\/a> is, simply put, an immutable SortedSet.<\/p>\n See also ImmutableInterlocked <\/a>. <\/p>\n ImmutableStack<T><\/strong><\/p>\n The ImmutableStack<\/a> is, simply put, an immutable Stack.<\/p>\n See also ImmutableInterlocked <\/a>. <\/p>\n KeyedCollection<TKey, TItem><\/strong><\/p>\n The KeyedCollection<\/a> is an abstract class which is a hybrid between a collection based upon an IList<T> and an IDictionary<TKey, TItem>. Unlike a Dictionary, the element stored is not a key\/value pair. It’s key is embedded in it’s value.<\/p>\n LinkedList<T><\/strong><\/p>\n The LinkedList<\/a> class is really that, a doubly linked list. Obviously this means insertion and removal of items are O(1) operations. Copying of elements requires far less memory than copying of array like structures, and obviously when adding more an more items the underlying data structure itself does not need to resize as an array would need to. On the downside each element requires a next and previous reference along with the data itself plus you do not get O(1) access to elements and this in itself may be a major downside – depending upon your app. <\/p>\n List<T><\/strong><\/p>\n The List<\/a> is in essence this is a generic ArrayList but type safe and due to the use of generics is more efficient in performance terms when handling value types which require boxing\/unboxing.<\/p>\n ListDictionary<\/strong><\/p>\n This ListDictionary<\/a> is a simple IDictionary implementation. It uses a singly linked list and it’s smaller and faster than a Hashtable if the number of elements is 10 or less. <\/p>\n NameValueCollection<\/strong><\/p>\n Then NameValueCollection<\/a> is used to store name\/value pairs, however unlike say a dictionary, nulls can be used for both name and value.<\/p>\n ObservableCollection<T><\/strong><\/p>\n The ObservableCollection<\/a> provide notifications when items are added to or removed from the collection or when the collection is refreshed. Used a lot with binding due to the support for INotifyPropertyChanged and INotifyCollectionChanged.<\/p>\n OrderedDictionary<\/strong><\/p>\n The OrderedDictionary<\/a> represents key\/value data where the data may be accessed via the key or the index. <\/p>\n Queue<T><\/strong><\/p>\n A Queue<\/a> is a FIFO collection. Whereby items are added to the back of the queue (using Enqueue) and taken from the front of the Queue using (Dequeue). A queue ultimately stores it’s elements in an array.<\/p>\n ReadOnlyCollection<T><\/strong><\/p>\n The ReadOnlyCollection<\/a> class is for a generic read-only\/immutable collection. <\/p>\n ReadOnlyDictionary<TKey, TValue><\/strong><\/p>\n The ReadOnlyDictionary<\/a> is a class for generic key\/value pairs in a read-only\/immutable dictionary.<\/p>\n ReadOnlyObservableCollection<T><\/strong><\/p>\n The ReadOnlyObservableCollection<\/a> is a class for a generic read-only\/immutable observable collection. Changed may be made to the underlying observable collection but not to the ReadOnlyObservableCollection wrapper.<\/p>\n SortedDictionary<T><\/strong><\/p>\n The SortedDictionary<\/a> is a dictionary where items are sorted on the key.<\/p>\n SortedList<TKey, TValue><\/strong><\/p>\n The SortedList<\/a> is a collecion of key\/value pairs that are sorted by key. A SortedList uses less memory than a SortedDictionary, but the SortedDictionary has faster insertion and removal of items.<\/p>\n SortedSet<T><\/strong><\/p>\n The SortedSet<\/a> is a collection where items are maintained in sorted order. Duplicate items are not allowed.<\/p>\n Stack<T><\/strong><\/p>\n The Stack<\/a> is standard LIFO (last-in first-out) collection. Items are pushed onto the top of the Stack and popped off of the top of the stack.<\/p>\n StringCollection<\/strong><\/p>\n The StringCollection<\/a> is a specialization of a standard collection for handling strings.<\/p>\n StringDictionary<\/strong><\/p>\n The StringDictionary<\/a> is a specialization of a standard dictionary for handling strings.<\/p>\n SynchronizedCollection<T><\/strong><\/p>\n The SynchronizedCollection<\/a> is a thread-safe collection. It’s part of the System.ServiceModel assembly and used within WCF.<\/p>\n SynchronizedKeyedCollection<TKey, TValue><\/strong><\/p>\n