C# Coleções

Uma coleção guarda vários valores juntos: a lista de compras, os preços da lojinha, a fila do banco. O .NET tem uma coleção para cada jeito de guardar. Esta página ajuda a escolher e depois lista os métodos de cada uma, com exemplo e resultado. Para aprender com calma, comece por Coleções e List<T>.

Os resultados vêm dos programas desta página (pasta ~/cs/col da Ana), rodados no dotnet 10.0.112 e no editor do guia, com a mesma saída. Todas estas coleções estão em System.Collections.Generic, que o C# já traz sem using.

Atalhos: Qual usar · Custo das operações · Criar e preencher · List · Dictionary · HashSet · Queue · Stack · Outras · Interfaces · Quando dá errado · Experimente

Qual usar

Custo das operações

"Rápido" quer dizer que leva o mesmo tempo com 10 ou com 1 milhão de itens. "Proporcional" quer dizer que, com o dobro de itens, leva o dobro do tempo, porque a coleção olha item por item.

Criar e preencher

List<T>

// list.cs — List<T>
List<string> compras = ["arroz", "feijão"];
compras.Add("café");
compras.AddRange(["leite", "ovos"]);
compras.Insert(0, "pão");
Console.WriteLine($"1  {string.Join(", ", compras)} ({compras.Count})");
Console.WriteLine($"2  {compras[0]} {compras[^1]} {compras.IndexOf("café")} {compras.IndexOf("sal")} {compras.Contains("leite")}");
compras.Remove("feijão");
compras.RemoveAt(0);
Console.WriteLine($"3  {string.Join(", ", compras)}");
Console.WriteLine($"4  {compras.Find(c => c.StartsWith('l'))} {compras.FindIndex(c => c.Length == 4)} {compras.Exists(c => c == "sal")}");
compras.Sort();
Console.WriteLine($"5  {string.Join(", ", compras)}");
compras.Reverse();
Console.WriteLine($"6  {string.Join(", ", compras)}");
int tirados = compras.RemoveAll(c => c.Contains('o'));
Console.WriteLine($"7  tirei {tirados}: {string.Join(", ", compras)}");
compras[0] = "chá";
string[] array = compras.ToArray();
compras.Clear();
Console.WriteLine($"8  {array.Length} {array[0]} {compras.Count}");
List<int> numeros = [5, 3, 8, 1];
List<int> mais = [.. numeros, 10, 20];
Console.WriteLine($"9  {string.Join(" ", mais)} | {numeros.Sum()} {numeros.Max()} {numeros.Min()}");

$ dotnet run list.cs
1  pão, arroz, feijão, café, leite, ovos (6)
2  pão ovos 3 -1 True
3  arroz, café, leite, ovos
4  leite 1 False
5  arroz, café, leite, ovos
6  ovos, leite, café, arroz
7  tirei 2: leite, café
8  2 chá 0
9  5 3 8 1 10 20 | 17 8 1

Aula: List<T>. Para ordenar por um campo (Sort((a, b) => a.Preco.CompareTo(b.Preco))), veja IComparable e IComparer.

Dictionary<TKey, TValue>

// dict.cs — Dictionary<TKey, TValue>
Dictionary<string, decimal> precos = new()
{
    ["caderno"] = 15.90m,
    ["caneta"] = 2.50m,
};
precos.Add("borracha", 1.75m);
precos["lápis"] = 1.20m;          // acrescenta
precos["caneta"] = 2.80m;         // troca o valor
Console.WriteLine($"1  {precos.Count} {precos["caneta"]:C} {precos.ContainsKey("régua")} {precos.ContainsValue(1.75m)}");
if (precos.TryGetValue("caderno", out decimal p))
{
    Console.WriteLine($"2  caderno: {p:C}");
}
Console.WriteLine($"3  {precos.GetValueOrDefault("régua")} {precos.GetValueOrDefault("régua", -1m)} {precos.TryAdd("caneta", 9m)} {precos.TryAdd("cola", 3.50m)}");
precos.Remove("borracha");
foreach (KeyValuePair<string, decimal> par in precos)
{
    Console.WriteLine($"4  {par.Key} = {par.Value:C}");
}
foreach (var (item, valor) in precos)
{
    Console.Write($"{item}:{valor} ");
}
Console.WriteLine();
Console.WriteLine($"5  {string.Join(", ", precos.Keys)} | {precos.Values.Sum():C}");
Dictionary<string, int> contagem = [];
foreach (string palavra in "a casa a rua a casa".Split(' '))
{
    contagem[palavra] = contagem.GetValueOrDefault(palavra) + 1;
}
Console.WriteLine($"6  {string.Join(" ", contagem.Select(kv => $"{kv.Key}={kv.Value}"))}");

$ dotnet run dict.cs
1  4 R$ 2,80 False True
2  caderno: R$ 15,90
3  0 -1 False True
4  caderno = R$ 15,90
4  caneta = R$ 2,80
4  lápis = R$ 1,20
4  cola = R$ 3,50
caderno:15,90 caneta:2,80 lápis:1,20 cola:3,50
5  caderno, caneta, lápis, cola | R$ 23,40
6  a=3 casa=2 rua=1

A linha 6 é o "contador" clássico: contagem[palavra] = contagem.GetValueOrDefault(palavra) + 1; soma 1, começando do 0 quando a palavra é nova.

HashSet<T>, Queue<T>, Stack<T> e as outras

// outros.cs — HashSet, Queue, Stack, PriorityQueue, SortedDictionary
HashSet<string> visitantes = ["Ana", "Bruno"];
Console.WriteLine($"1  {visitantes.Add("Carla")} {visitantes.Add("Ana")} {visitantes.Count} {visitantes.Contains("Bruno")}");
HashSet<int> a = [1, 2, 3, 4], b = [3, 4, 5];
HashSet<int> uniao = [.. a]; uniao.UnionWith(b);
HashSet<int> inter = [.. a]; inter.IntersectWith(b);
HashSet<int> dif = [.. a]; dif.ExceptWith(b);
Console.WriteLine($"2  {string.Join(",", uniao.Order())} | {string.Join(",", inter.Order())} | {string.Join(",", dif.Order())} | {a.IsSupersetOf([1, 2])}");

Queue<string> fila = new();
fila.Enqueue("Ana"); fila.Enqueue("Bruno"); fila.Enqueue("Carla");
Console.WriteLine($"3  {fila.Peek()} {fila.Dequeue()} {fila.Dequeue()} {fila.Count} {fila.TryDequeue(out string? prox)} {prox} {fila.TryDequeue(out _)}");

Stack<string> pilha = new();
pilha.Push("prato 1"); pilha.Push("prato 2"); pilha.Push("prato 3");
Console.WriteLine($"4  {pilha.Peek()} {pilha.Pop()} {pilha.Pop()} {pilha.Count} {string.Join("|", pilha)}");

PriorityQueue<string, int> atendimento = new();
atendimento.Enqueue("resfriado", 3);
atendimento.Enqueue("fratura", 1);
atendimento.Enqueue("dor de cabeça", 2);
Console.Write("5 ");
while (atendimento.TryDequeue(out string? caso, out int prioridade))
{
    Console.Write($" {caso}({prioridade})");
}
Console.WriteLine();

SortedDictionary<string, int> notas = new() { ["Carla"] = 9, ["Ana"] = 8, ["Bruno"] = 7 };
SortedSet<int> ordenados = [5, 1, 4, 1, 3];
Console.WriteLine($"6  {string.Join(" ", notas.Keys)} | {string.Join(" ", ordenados)} | {ordenados.Min} {ordenados.Max}");

int[] v = [5, 3, 8, 1];
Array.Sort(v);
Console.WriteLine($"7  {string.Join(" ", v)} {v.Length} {Array.IndexOf(v, 8)} {Array.BinarySearch(v, 5)} {v.Contains(3)}");
IReadOnlyList<int> soLeitura = v;
Console.WriteLine($"8  {soLeitura.Count} {soLeitura[0]}");
LinkedList<string> ll = new(["b", "c"]);
ll.AddFirst("a"); ll.AddLast("d");
Console.WriteLine($"9  {string.Join("", ll)} {ll.First!.Value} {ll.Last!.Value}");

$ dotnet run outros.cs
1  True False 3 True
2  1,2,3,4,5 | 3,4 | 1,2 | True
3  Ana Ana Bruno 1 True Carla False
4  prato 3 prato 3 prato 2 1 prato 1
5  fratura(1) dor de cabeça(2) resfriado(3)
6  Ana Bruno Carla | 1 3 4 5 | 1 5
7  1 3 5 8 4 3 2 True
8  4 1
9  abcd a d

HashSet<T> (linhas 1 e 2)

Os métodos …With mudam o próprio conjunto; por isso o programa copia antes ([.. a]). Para tirar repetidos de uma lista, basta new HashSet<T>(lista) ou lista.Distinct(). Aula: HashSet.

Queue<T>, a fila (linha 3)

Aula: Queue (Fila).

Stack<T>, a pilha (linha 4)

Aula: Stack (Pilha).

As outras (linhas 5 a 9)

As interfaces: o que cada coleção sabe fazer

Pedir a interface mais simples que serve deixa o método aceitar mais tipos: um Listar(IEnumerable<Produto> produtos) aceita uma List, um array e o resultado de um Where (o projeto Estoque faz isso). Aula: IEnumerable e foreach.

Quando dá errado

No editor do guia, o rastro de algumas destas exceções mostra os tipos de verdade no lugar dos genéricos (Dictionary`2.get_Item(String key) em vez de get_Item(TKey key)); a mensagem é a mesma.

Experimente

string[] vendas = ["banana", "maçã", "banana", "uva", "banana", "maçã"];
Dictionary<string, int> contagem = [];
foreach (string fruta in vendas)
{
    contagem[fruta]++;
}
foreach (var (fruta, vezes) in contagem)
{
    Console.WriteLine($"{fruta}={vezes}");
}

string[] vendas = ["banana", "maçã", "banana", "uva", "banana", "maçã"];
Dictionary<string, int> contagem = [];
foreach (string fruta in vendas)
{
    contagem[fruta] = contagem.GetValueOrDefault(fruta) + 1;
}
foreach (var (fruta, vezes) in contagem)
{
    Console.WriteLine($"{fruta}={vezes}");
}

Resumo

• Padrão: List<T>. Por chave: Dictionary<K, V>. Sem repetidos: HashSet<T>. Ordem de chegada: Queue<T>. Último primeiro: Stack<T>. Tamanho fixo: array.
• List tem Count; array e string têm Length.
• No Dictionary, ler uma chave que não existe lança exceção: use TryGetValue ou GetValueOrDefault. Add com chave repetida também lança; d[k] = v troca.
• Dequeue, Pop e Peek numa coleção vazia lançam InvalidOperationException: use as versões Try….
• Não conte com a ordem de Dictionary e HashSet; para ordem, Sorted… ou OrderBy.
• C# 12: [1, 2, 3], [] e [.. outra, 4] criam qualquer coleção.