What are the common collection types?

Question

IT Interview Practice · Accepted Answer

C# provides a rich set of collection types in `System.Collections.Generic` for storing groups of data. The most common are **`List`** (dynamic array), **`Dictionary`** (key-value map), and `HashSet` (unique set). Choosing the right one matters for clarity and performance. ## List — a dynamic, ordered, indexed array ```csharp var numbers = new List { 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` is the go-to general-purpose collection — an ordered, resizable, indexed list. The `` is a generic type parameter (`List`, `List`), giving compile-time type safety. ## Dictionary — key-value lookup (O(1)) ```csharp var ages = new Dictionary { ["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` 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). ## HashSet and other collections ```csharp var set = new HashSet { 1, 2, 3 }; // unique elements, O(1) Contains set.Add(2); // ignored (duplicate) var queue = new Queue(); // FIFO var stack = new Stack(); // LIFO int[] arr = { 1, 2, 3 }; // fixed-size array var ro = numbers.AsReadOnly(); // read-only wrapper ``` ## Choosing the right one ```text Ordered, indexed, resizable → List Key-value lookup (fast) → Dictionary Uniqueness / fast membership → HashSet FIFO / LIFO processing → Queue / Stack Fixed size / performance-critical → array (T[]) ``` ## Why it matters 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`** for ordered, indexed, resizable data (the general-purpose workhorse), **`Dictionary`** for fast key-based lookup (caches, indexes), `HashSet` 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` for everything is an important skill. These collections are also **generic** (``), 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.

What are the common collection types?

List<T> — a dynamic, ordered, indexed array

Dictionary<K,V> — key-value lookup (O(1))

HashSet<T> and other collections

Choosing the right one

Why it matters

Related questions