Quels sont les types de collections en C#?

C# propose une variété de types de collections pour stocker et gérer des données, situés dans différents espaces de noms (principalement System.Collections, System.Collections.Generic, System.Collections.Concurrent, System.Collections.Immutable). Ils peuvent être classés selon plusieurs critères principaux :

1. Par type de données stockées :

   • Non typés (Untyped): Stockent des objets du type object (System.Collections). Nécessitent des conversions de types et peuvent être moins performants.
   • Typés (Generic): Stockent des objets d’un type spécifique (System.Collections.Generic). Offrent une sécurité de type et de meilleures performances.

2. Par structure de données :

   • Listes (Lists): Collections séquentielles, accès aux éléments par index.
     • ArrayList (non typé)
     • List<T> (typage)
     • LinkedList<T> (liste doublement chaînée typée)
   • Tableaux (Arrays): De taille fixe, accès par index.
     • Array (classe de base)
     • T[] (sucre syntaxique pour tableaux)
   • Dictionnaires (Dictionaries): Collections de paires clé-valeur, accès par clé.
     • Hashtable (non typé)
     • Dictionary<TKey, TValue> (typage)
     • SortedList (non typé, trié par clé)
     • SortedList<TKey, TValue> (typage, trié par clé)
     • SortedDictionary<TKey, TValue> (typage, trié par clé, utilise un arbre rouge-noir)
   • Ensembles (Sets): Collections d’éléments uniques.
     • HashSet<T> (typage, non ordonné)
     • SortedSet<T> (typage, ordonné)
   • Queues (Queues): Collections fonctionnant selon le principe de "premier arrivé, premier sorti" (FIFO).
     • Queue (non typé)
     • Queue<T> (typage)
   • Piles (Stacks): Collections fonctionnant selon le principe de "dernier arrivé, premier sorti" (LIFO).
     • Stack (non typé)
     • Stack<T> (typage)

3. Par sécurité en multithreading :

   • Non thread-safe : La plupart des collections standard (System.Collections, System.Collections.Generic). Nécessitent une synchronisation externe pour le travail multithread.
   • Thread-safe (Concurrent) : Conçues pour fonctionner en toute sécurité dans un environnement multithread sans verrouillage externe (System.Collections.Concurrent).
     • ConcurrentBag<T>
     • ConcurrentDictionary<TKey, TValue>
     • ConcurrentQueue<T>
     • ConcurrentStack<T>

4. Par mutabilité :

   • Modifiables (Mutable): La plupart des collections permettent d’ajouter, de supprimer et de modifier des éléments.
   • Immutables (Immutable): Garantissent l’immuabilité après la création (System.Collections.Immutable). Toute opération de modification retourne une nouvelle collection.
     • ImmutableArray<T>
     • ImmutableList<T>
     • ImmutableDictionary<TKey, TValue>
     • ImmutableHashSet<T>
     • ImmutableSortedSet<T>
     • ImmutableQueue<T>
     • ImmutableStack<T>

Le choix d’un type spécifique de collection dépend des exigences de la tâche : type de données, nécessité d’accès par index ou clé, exigences d’unicité des éléments, ordre de stockage, performance, sécurité en multithreading et mutabilité. Les collections typées du namespace System.Collections.Generic sont les plus couramment utilisées en C#.