Home Library Learn Downloads Support Community
Sign in | United States - English | |
19 out of 31 rated this helpful - Rate this topic

System.Collections.Generic Namespace

.NET Framework 4

The System.Collections.Generic namespace contains interfaces and classes that define generic collections, which allow users to create strongly typed collections that provide better type safety and performance than non-generic strongly typed collections.

  Class Description
Public class Comparer<T> Provides a base class for implementations of the IComparer<T> generic interface.
Public class Dictionary<TKey, TValue> Represents a collection of keys and values.
Public class Dictionary<TKey, TValue>.KeyCollection Represents the collection of keys in a Dictionary<TKey, TValue>. This class cannot be inherited.
Public class Dictionary<TKey, TValue>.ValueCollection Represents the collection of values in a Dictionary<TKey, TValue>. This class cannot be inherited.
Public class EqualityComparer<T> Provides a base class for implementations of the IEqualityComparer<T> generic interface.
Public class HashSet<T> Represents a set of values.
Public class KeyedByTypeCollection<TItem> Provides a collection whose items are types that serve as keys.
Public class KeyNotFoundException The exception that is thrown when the key specified for accessing an element in a collection does not match any key in the collection.
Public class LinkedList<T> Represents a doubly linked list.
Public class LinkedListNode<T> Represents a node in a LinkedList<T>. This class cannot be inherited.
Public class List<T> Represents a strongly typed list of objects that can be accessed by index. Provides methods to search, sort, and manipulate lists.
Public class Queue<T> Represents a first-in, first-out collection of objects.
Public class SortedDictionary<TKey, TValue> Represents a collection of key/value pairs that are sorted on the key.
Public class SortedDictionary<TKey, TValue>.KeyCollection Represents the collection of keys in a SortedDictionary<TKey, TValue>. This class cannot be inherited.
Public class SortedDictionary<TKey, TValue>.ValueCollection Represents the collection of values in a SortedDictionary<TKey, TValue>. This class cannot be inherited
Public class SortedList<TKey, TValue> Represents a collection of key/value pairs that are sorted by key based on the associated IComparer<T> implementation.
Public class SortedSet<T> Represents a collection of objects that is maintained in sorted order.
Public class Stack<T> Represents a variable size last-in-first-out (LIFO) collection of instances of the same arbitrary type.
Public class SynchronizedCollection<T> Provides a thread-safe collection that contains objects of a type specified by the generic parameter as elements.
Public class SynchronizedKeyedCollection<K, T> Provides a thread-safe collection that contains objects of a type specified by a generic parameter and that are grouped by keys.
Public class SynchronizedReadOnlyCollection<T> Provides a thread-safe, read-only collection that contains objects of a type specified by the generic parameter as elements.
  Structure Description
Public structure Dictionary<TKey, TValue>.Enumerator Enumerates the elements of a Dictionary<TKey, TValue>.
Public structure Dictionary<TKey, TValue>.KeyCollection.Enumerator Enumerates the elements of a Dictionary<TKey, TValue>.KeyCollection.
Public structure Dictionary<TKey, TValue>.ValueCollection.Enumerator Enumerates the elements of a Dictionary<TKey, TValue>.ValueCollection.
Public structure HashSet<T>.Enumerator Enumerates the elements of a HashSet<T> object.
Public structure KeyValuePair<TKey, TValue> Defines a key/value pair that can be set or retrieved.
Public structure LinkedList<T>.Enumerator Enumerates the elements of a LinkedList<T>.
Public structure List<T>.Enumerator Enumerates the elements of a List<T>.
Public structure Queue<T>.Enumerator Enumerates the elements of a Queue<T>.
Public structure SortedDictionary<TKey, TValue>.Enumerator Enumerates the elements of a SortedDictionary<TKey, TValue>.
Public structure SortedDictionary<TKey, TValue>.KeyCollection.Enumerator Enumerates the elements of a SortedDictionary<TKey, TValue>.KeyCollection.
Public structure SortedDictionary<TKey, TValue>.ValueCollection.Enumerator Enumerates the elements of a SortedDictionary<TKey, TValue>.ValueCollection.
Public structure SortedSet<T>.Enumerator Enumerates the elements of a SortedSet<T> object.
Public structure Stack<T>.Enumerator Enumerates the elements of a Stack<T>.
  Interface Description
Public interface ICollection<T> Defines methods to manipulate generic collections.
Public interface IComparer<T> Defines a method that a type implements to compare two objects.
Public interface IDictionary<TKey, TValue> Represents a generic collection of key/value pairs.
Public interface IEnumerable<T> Exposes the enumerator, which supports a simple iteration over a collection of a specified type.
Public interface IEnumerator<T> Supports a simple iteration over a generic collection.
Public interface IEqualityComparer<T> Defines methods to support the comparison of objects for equality.
Public interface IList<T> Represents a collection of objects that can be individually accessed by index.
Public interface ISet<T> Provides the base interface for the abstraction of sets.
Did you find this helpful?
(1500 characters remaining)
Community Content Add
Annotations FAQ
Need performance consideration and comparision of feature list
Performance considerations and perhaps a comparision of feature list between different collections will help highly to make better apps. Why no C# syntax ? Need a little more explanation too.
History
@Chomilino - Here's a tree class for ya
public class Node<T>
     public List<Node<T>> Children = new List<Node<T>>();
     public T Value;
end class

Use it like this:

Node<string> root = new Node<string>() { Value = "I am the root node!" };

Node<string> child = new Node<string>() { Value = "I am a child of the root node!" }; 
root.Children.Add(child);

Node<string> sibling = new Node<string>() { Value = "I am a sibling of child!" };
root.Children.Add(sibling);

Node<string> grandchild = new Node<string>() { Value = "I am a grandchild of the root node!"};
child.Children.Add(grandchild);
History
More classes
A Tree class would be useful.
History
It would be useful a Tree class
It would be useful a Tree class
History
Yea performance indicators would be helpful for these collections
But I guess, they are more or less same as the structure name conveys (List, Hashtable etc. ) in theory. But definitely I have come across significant variations due to the implementation differences. So the performance indicators (O notation) should be made available for various operations.
History
Performance Stats
Would be nice to get performance and O notation differences here.
History