C# fornisce un ricco insieme di tipi di raccolta in System.Collections.Generic per archiviare gruppi di dati. I più comuni sono List<T> (array dinamico), Dictionary<K,V> (mappa chiave-valore) e HashSet<T> (insieme unico). Scegliere quello giusto è importante per la chiarezza e le prestazioni.
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> è la raccolta di uso generale per eccellenza — un elenco ordinato, ridimensionabile e indicizzato. <T> è un parametro di tipo generico (List<string>, List<User>), che fornisce la sicurezza dei tipi in fase di compilazione.
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> mappa chiavi a valori con ricerche veloci O(1) — per cache, indici e qualsiasi accesso basato su chiave. TryGetValue è il modo sicuro per cercare (evitando un'eccezione quando la chiave non è presente).
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[])
Le raccolte sono fondamentali in quasi ogni programma — l'archiviazione e l'elaborazione di gruppi di dati è costante — quindi comprendere i tipi di raccolta comuni di C# e scegliere bene è una conoscenza essenziale di tutti i giorni.
Conoscere i tipi principali e i loro casi d'uso — List<T> per dati ordinati, indicizzati, ridimensionabili (il workhorse di uso generale), Dictionary<K,V> per ricerca rapida basata su chiave (cache, indici), HashSet<T> per unicità e test di appartenenza rapidi, e Queue/Stack per l'elaborazione FIFO/LIFO — è necessario per scrivere codice efficiente e chiaro.
La scelta influisce direttamente sulle prestazioni (ad es. ricerca O(1) di un Dictionary vs scansione O(n) di un List, o appartenenza O(1) di HashSet vs O(n) di List) e sull'intento, quindi scegliere la raccolta appropriata piuttosto che default a List<T> per tutto è un'abilità importante.
Queste raccolte sono anche generiche (<T>), fornendo la sicurezza dei tipi in fase di compilazione.
Conoscere dettagli pratici come TryGetValue per ricerche sicure nel dizionario (evitando eccezioni su chiavi mancanti) e le caratteristiche di prestazione di ogni tipo copre le esigenze quotidiane quando si lavora con i dati in C#.
Poiché le raccolte appaiono in praticamente ogni programma e la scelta giusta influisce significativamente sulle prestazioni e la leggibilità, padroneggiare i tipi di raccolta comuni e il loro uso appropriato è una conoscenza fondamentale e imprescindibile per lo sviluppo efficace in C#.