O C# fornece um rico conjunto de tipos de coleção em System.Collections.Generic para armazenar grupos de dados. Os mais comuns são List<T> (array dinâmico), Dictionary<K,V> (mapa chave-valor) e HashSet<T> (conjunto de valores únicos). Escolher o tipo correto é importante para clareza e 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> é a coleção de propósito geral mais usada — uma lista ordenada, redimensionável e indexada. O <T> é um parâmetro de tipo genérico (List<string>, List<User>), proporcionando segurança de tipo em tempo de compilação.
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> mapeia chaves para valores com buscas rápidas em O(1) — para caches, índices e qualquer acesso baseado em chave. TryGetValue é a forma segura de buscar (evitando uma exceção quando a chave não existe).
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[])
Coleções são fundamentais para praticamente todo programa — armazenar e processar grupos de dados é constante — então compreender os tipos de coleção comuns do C# e escolher bem é conhecimento essencial do dia a dia.
Conhecer os tipos principais e seus casos de uso — List<T> para dados ordenados, indexados e redimensionáveis (a ferramenta de propósito geral), Dictionary<K,V> para busca rápida baseada em chave (caches, índices), HashSet<T> para unicidade e testes rápidos de pertencimento, e Queue/Stack para processamento FIFO/LIFO — é necessário para escrever código eficiente e claro.
A escolha afeta diretamente a performance (por exemplo, busca O(1) de um Dictionary vs varredura O(n) de uma List, ou pertencimento O(1) de um HashSet vs O(n) de uma List) e a intenção, então escolher a coleção apropriada em vez de usar List<T> para tudo é uma habilidade importante.
Essas coleções também são genéricas (<T>), fornecendo segurança de tipo em tempo de compilação.
Conhecer detalhes práticos como TryGetValue para buscas seguras em dicionários (evitando exceções em chaves ausentes) e as características de performance de cada tipo cobre as necessidades do dia a dia ao trabalhar com dados em C#.
Já que coleções aparecem em praticamente todo programa e a escolha correta afeta significativamente performance e legibilidade, dominar os tipos de coleção comuns e seus usos apropriados é conhecimento fundamental e imprescindível para o desenvolvimento eficaz em C#.