Sélection d’une classe de collection

Veillez à choisir votre classe de collection avec soin. L’utilisation d’un type incorrect peut limiter votre utilisation de la collection.

Important

Éviter d’utiliser les types dans l’espace de noms System.Collections. Les versions génériques et simultanées des collections sont recommandées en raison de la sécurité supérieure des types et d'autres améliorations.

Posez-vous les questions suivantes :

• Avez-vous besoin d'une liste séquentielle où l'élément est en général abandonné une fois sa valeur récupérée ?

  • Si oui, envisagez d'utiliser la classe Queue ou bien la classe générique Queue<T> si vous avez besoin d'un comportement premier entré, premier sorti (FIFO, First-In, First-Out). Envisagez d'utiliser la classe Stack ou bien la classe générique Stack<T> si vous avez besoin d'un comportement dernier entré, premier sorti (LIFO, Last-In, First-Out). Pour un accès sécurisé à partir de plusieurs threads, utilisez les versions simultanées ConcurrentQueue<T> et ConcurrentStack<T>. Pour l’immuabilité, envisagez les versions immuables, ImmutableQueue<T> et ImmutableStack<T>.

  • Si ce n'est pas le cas, envisagez d'utiliser les autres collections.

• Avez-vous besoin d'accéder aux éléments dans un certain ordre, comme FIFO ou LIFO, ou de façon aléatoire ?

  • La classe Queue, ainsi que les classes génériques Queue<T>, ConcurrentQueue<T>et ImmutableQueue<T> offrent toutes un accès FIFO. Pour plus d’informations, consultez Quand utiliser une collection thread-safe.

  • La classe Stack, ainsi que les classes génériques Stack<T>, ConcurrentStack<T>et ImmutableStack<T> offrent toutes un accès LIFO. Pour plus d’informations, consultez Quand utiliser une collection thread-safe.

  • La classe générique LinkedList<T> autorise un accès séquentiel de haut en bas ou de bas en haut.

• Avez-vous besoin d'accéder à chaque élément selon son index ?

  • Les classes ArrayList et StringCollection, ainsi que la classe générique List<T>, offrent un accès à leurs éléments via l'index de base zéro de l'élément. Pour l’immuabilité, envisagez les versions génériques immuables, ImmutableArray<T> et ImmutableList<T>.

  • Les classes Hashtable, SortedList, ListDictionary et StringDictionary, ainsi que les classes génériques Dictionary<TKey,TValue> et SortedDictionary<TKey,TValue>, offrent un accès à leurs éléments via la clé de l'élément. En outre, il existe des versions immuables de plusieurs types correspondants : ImmutableHashSet<T>, ImmutableDictionary<TKey,TValue>, ImmutableSortedSet<T>, et ImmutableSortedDictionary<TKey,TValue>.

  • Les classes NameObjectCollectionBase et NameValueCollection, ainsi que les classes génériques KeyedCollection<TKey,TItem> et SortedList<TKey,TValue>, offrent un accès à leurs éléments via l'index de base zéro ou via la clé de l'élément.

• Chaque élément contiendra-t-il une valeur, une combinaison d'une clé et d'une valeur, ou une combinaison d'une clé et de plusieurs valeurs ?

  • Une valeur : utilisez une des collections basées sur l'interface IList ou l'interface générique IList<T>. Pour une option immuable, envisagez l’interface générique IImmutableList<T>.

  • Une clé et une valeur : utilisez une des collections basées sur l'interface IDictionary ou l'interface générique IDictionary<TKey,TValue>. Pour une option immuable, envisagez les interfaces génériques IImmutableDictionary<TKey,TValue> ou IImmutableSet<T>.

  • Une valeur avec une clé incorporée : utilisez la classe générique KeyedCollection<TKey,TItem>.

  • Une clé et plusieurs valeurs : utilisez la classe NameValueCollection.

• Avez-vous besoin de trier les éléments différemment de la façon dont ils ont été entrés ?

  • La classe Hashtable trie ses éléments selon leur code de hachage.

  • La classe SortedList et les classes génériques SortedList<TKey,TValue> et SortedDictionary<TKey,TValue> trient leurs éléments par clé. L’ordre de tri est basé sur l’implémentation de l’interface IComparer pour la classe SortedList et sur l’implémentation de l’interface générique IComparer<T> pour les classes génériques SortedList<TKey,TValue> et SortedDictionary<TKey,TValue>. Des deux types génériques, c’est SortedDictionary<TKey,TValue> qui offre de meilleures performances que SortedList<TKey,TValue>, tandis que SortedList<TKey,TValue> consomme moins de mémoire.

  • ArrayList fournit une méthode Sort qui prend une implémentation de IComparer comme paramètre. Sa contrepartie générique, la classe générique List<T>, fournit une méthode Sort qui prend une implémentation de l'interface générique IComparer<T> comme paramètre.

• Avez-vous besoin de recherches et d'une récupération rapides des informations ?

  • ListDictionary est plus rapide que Hashtable pour les petites collections (10 éléments ou moins). La classe générique Dictionary<TKey,TValue> permet une recherche plus rapide que celle de la classe générique SortedDictionary<TKey,TValue>. L'implémentation multithread est ConcurrentDictionary<TKey,TValue>. ConcurrentBag<T> fournit une insertion multithread rapide pour les données non ordonnées. Pour plus d’informations sur les deux types multithread, consultez Quand utiliser une collection thread-safe.

• Avez-vous besoin de collections qui acceptent seulement des chaînes ?

  • StringCollection (basée sur IList) et StringDictionary (basée sur IDictionary) se trouvent dans l'espace de noms System.Collections.Specialized.

  • En outre, vous pouvez utiliser toutes les classes de collection génériques dans l'espace de noms System.Collections.Generic comme des collections de chaînes fortement typées en spécifiant la classe String pour leurs arguments de types génériques. Par exemple, vous pouvez déclarer une variable comme étant de type Liste<Chaîne> ou Dictionary<String,String>.

LINQ to Objects et PLINQ

La fonctionnalité LINQ to Objects permet aux développeurs d'utiliser des requêtes LINQ pour accéder aux objets en mémoire pour autant que le type d'objet implémente IEnumerable ou IEnumerable<T>. Les requêtes LINQ fournissent un modèle commun pour accéder aux données. Elles sont généralement plus concises et plus lisibles que les boucles foreach standard et offrent des fonctions de filtrage, de classement et de regroupement. Pour plus d’informations, consultez LINQ to Objects (C#) et LINQ to Objects (Visual Basic).

PLINQ fournit une implémentation parallèle de LINQ to Objects, qui peut offrir une exécution plus rapide des requêtes dans de nombreux scénarios, via une utilisation plus efficace des ordinateurs multicœurs. Pour plus d’informations, consultez PLINQ (Parallel LINQ).

Voir aussi

• System.Collections
• System.Collections.Specialized
• System.Collections.Generic
• Collections thread-safe