C# provides a rich set of collection types in System.Collections.Generic for storing groups of data. The most common are List<T> (dynamic array), Dictionary<K,V> (key-value map), and HashSet<T> (unique set). Choosing the right one matters for clarity and performance.
var numbers = new List<int> { 1, 2, 3 };
numbers.Add(4); // grows dynamically
numbers[0]; // index access — O(1)
numbers.Contains(3); // O(n) search
numbers.Remove(2);
numbers.Count; // size
foreach (var n in numbers) { } // iterate
List<T> is the go-to general-purpose collection — an ordered, resizable, indexed list. The <T> is a generic type parameter (List<string>, List<User>), giving compile-time type safety.
var ages = new Dictionary<string, int> { ["Ann"] = 30, ["Bob"] = 25 };
ages["Carol"] = 28; // add/set
ages["Ann"]; // get by key — O(1)
ages.ContainsKey("Ann");
ages.TryGetValue("Ann", out var age); // safe lookup (no exception if missing)
foreach (var (name, a) in ages) { } // iterate key-value pairs
Dictionary<K,V> maps keys to values with fast O(1) lookups — for caches, indexes, and any key-based access. TryGetValue is the safe way to look up (avoiding an exception when the key is missing).
var set = new HashSet<int> { 1, 2, 3 }; // unique elements, O(1) Contains
set.Add(2); // ignored (duplicate)
var queue = new Queue<int>(); // FIFO
var stack = new Stack<int>(); // LIFO
int[] arr = { 1, 2, 3 }; // fixed-size array
var ro = numbers.AsReadOnly(); // read-only wrapper
Ordered, indexed, resizable → List<T>
Key-value lookup (fast) → Dictionary<K,V>
Uniqueness / fast membership → HashSet<T>
FIFO / LIFO processing → Queue<T> / Stack<T>
Fixed size / performance-critical → array (T[])
Collections are fundamental to nearly every program — storing and processing groups of data is constant — so understanding C#'s common collection types and choosing well is essential everyday knowledge.
Knowing the main types and their use cases — List<T> for ordered, indexed, resizable data (the general-purpose workhorse), Dictionary<K,V> for fast key-based lookup (caches, indexes), HashSet<T> for uniqueness and fast membership tests, and Queue/Stack for FIFO/LIFO processing — is necessary for writing efficient, clear code.
The choice directly affects performance (e.g. a Dictionary's O(1) lookup vs scanning a List's O(n), or HashSet's O(1) membership vs List's O(n)) and intent, so picking the appropriate collection rather than defaulting to List<T> for everything is an important skill.
These collections are also generic (<T>), providing compile-time type safety.
Knowing practical details like TryGetValue for safe dictionary lookups (avoiding exceptions on missing keys) and the performance characteristics of each type covers the everyday needs of working with data in C#.
Since collections appear in virtually every program and the right choice meaningfully affects performance and readability, mastering the common collection types and their appropriate use is foundational, must-know knowledge for effective C# development.