HashSet<T>

Collection of unique items, with O(1) lookup.

HashSet<int> validStoryPointValues = new HashSet<int>() { 1, 2, 3, 5, 8, 13, 21 };
bool containsEight = validStoryPointValues.Contains(8); // O(1)

HashSet.Contains uses a hash table, so that lookups are extremely fast, regardless of the number of items in the
collection.

Dictionary<TKey, TValue>

Dictionary<TKey, TValue> is a map. For a given key there can be one value in the dictionary.

using System.Collections.Generic;
var people = new Dictionary<string, int>
{
{ "John", 30 }, {"Mary", 35}, {"Jack", 40}
};


// Reading data
Console.WriteLine(people["John"]); // 30
Console.WriteLine(people["George"]); // throws KeyNotFoundException
int age;
if (people.TryGetValue("Mary", out age))
{
Console.WriteLine(age); // 35
}


// Adding and changing data
people["John"] = 40; // Overwriting values this way is ok
people.Add("John", 40); // Throws ArgumentException since "John" already exists


// Iterating through contents
foreach(KeyValuePair<string, int> person in people)
{
Console.WriteLine("Name={0}, Age={1}", person.Key, person.Value);
}
foreach(string name in people.Keys)
{
Console.WriteLine("Name={0}", name);
}
foreach(int age in people.Values)
{
Console.WriteLine("Age={0}", age);
}

SortedSet<T>

// create an empty set
var mySet = new SortedSet<int>();
// add something
// note that we add 2 before we add 1
mySet.Add(2);
mySet.Add(1);
// enumerate through the set
foreach(var item in mySet)
{
Console.WriteLine(item);
}
// output:
// 1
// 2

T[ ] (Array of T)

// create an array with 2 elements
var myArray = new [] { "one", "two" };
// enumerate through the array
foreach(var item in myArray)
{
Console.WriteLine(item);
}

List<T>

List<T> is a list of a given type. Items can be added, inserted, removed and addressed by index.
using System.Collections.Generic;
var list = new List<int>() { 1, 2, 3, 4, 5 };
list.Add(6);
Console.WriteLine(list.Count); // 6
list.RemoveAt(3);
Console.WriteLine(list.Count); // 5
Console.WriteLine(list[3]);

Stack<T>

// Initialize a stack object of integers
var stack = new Stack<int>();
// add some data
stack.Push(3);
stack.Push(5);
stack.Push(8);
// elements are stored with "first in, last out" order.
// stack from top to bottom is: 8, 5, 3
// We can use peek to see the top element of the stack.
Console.WriteLine(stack.Peek()); // prints 8
// Pop removes the top element of the stack and returns it.
Console.WriteLine(stack.Pop()); // prints 8
Console.WriteLine(stack.Pop()); // prints 5
Console.WriteLine(stack.Pop()); // prints 3

LinkedList<T>

Note that LinkedList represents the doubly linked list. So, it’s simply collection of nodes and each node contains an element of type T. Each node is linked to the preceding node and the following node.

// initialize a LinkedList of integers
LinkedList list = new LinkedList<int>();
// add some numbers to our list.
list.AddLast(3);
list.AddLast(5);
list.AddLast(8);
// the list currently is 3, 5, 8
list.AddFirst(2);
// the list now is 2, 3, 5, 8
list.RemoveFirst();
// the list is now 3, 5, 8
list.RemoveLast();
// the list is now 3, 5

Queue

// Initalize a new queue of integers
var queue = new Queue<int>();
// Add some data
queue.Enqueue(6);
queue.Enqueue(4);
queue.Enqueue(9);
// Elements in a queue are stored in "first in, first out" order.
// The queue from first to last is: 6, 4, 9
// View the next element in the queue, without removing it.
Console.WriteLine(queue.Peek()); // prints 6
// Removes the first element in the queue, and returns it.
Console.WriteLine(queue.Dequeue()); // prints 6
Console.WriteLine(queue.Dequeue()); // prints 4
Console.WriteLine(queue.Dequeue()); // prints 9