C# fournit un riche ensemble de types de collection dans System.Collections.Generic pour stocker des groupes de données. Les plus courants sont List<T> (tableau dynamique), Dictionary<K,V> (map clé-valeur), et HashSet<T> (ensemble unique). Le choix du bon type importe pour la clarté et la 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> est la collection généraliste par défaut — une liste ordonnée, redimensionnable, indexée. Le <T> est un paramètre de type générique (List<string>, List<User>), offrant la sécurité des types à la compilation.
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> mappe les clés aux valeurs avec des recherches rapides en O(1) — pour les caches, les index, et tout accès basé sur une clé. TryGetValue est la manière sûre de chercher (évitant une exception quand la clé est absente).
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[])
Les collections sont fondamentales dans pratiquement tout programme — stocker et traiter des groupes de données est constant — donc comprendre les types de collection courants de C# et bien choisir est une connaissance essentielle au quotidien.
Connaître les types principaux et leurs cas d'usage — List<T> pour les données ordonnées, indexées, redimensionnables (le cheval de trait généraliste), Dictionary<K,V> pour la recherche rapide basée sur une clé (caches, index), HashSet<T> pour l'unicité et les tests d'appartenance rapides, et Queue/Stack pour le traitement FIFO/LIFO — est nécessaire pour écrire du code efficace et clair.
Le choix affecte directement la performance (p. ex. une recherche O(1) de Dictionary vs le balayage O(n) d'une List, ou l'appartenance O(1) de HashSet vs O(n) de List) et l'intention, donc choisir la collection appropriée plutôt que de se contenter de List<T> pour tout est une compétence importante.
Ces collections sont également génériques (<T>), offrant la sécurité des types à la compilation.
Connaître les détails pratiques comme TryGetValue pour les recherches sûres dans un dictionnaire (évitant les exceptions sur les clés manquantes) et les caractéristiques de performance de chaque type couvre les besoins quotidiens du travail avec les données en C#.
Puisque les collections apparaissent dans pratiquement tous les programmes et que le bon choix affecte significativement la performance et la lisibilité, maîtriser les types de collection courants et leurs usages appropriés est une connaissance fondamentale, incontournable pour un développement C# efficace.