Notes
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de vous connecter ou de modifier des répertoires.
L’accès à cette page nécessite une autorisation. Vous pouvez essayer de modifier des répertoires.
Veillez à choisir soigneusement votre classe de collection. L’utilisation du type incorrect peut restreindre votre utilisation de la collection.
Importante
Évitez d'utiliser les types dans le namespace System.Collections. Les versions génériques et simultanées des collections sont recommandées en raison de leur plus grande sécurité de type et d’autres améliorations.
Tenez compte des questions suivantes :
Avez-vous besoin d’une liste séquentielle où l’élément est généralement ignoré une fois sa valeur récupérée ?
Si c’est le cas, envisagez d’utiliser la Queue classe ou la Queue<T> classe générique si vous avez besoin d’un comportement de premier entré et de premier sorti (FIFO). Envisagez d’utiliser la Stack classe ou la Stack<T> classe générique si vous avez besoin d’un comportement liFO (last-in, first-out). Pour un accès sécurisé à partir de plusieurs threads, utilisez les versions concurrentes ConcurrentQueue<T> et ConcurrentStack<T>. Pour une immuabilité, tenez compte des 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, tel que FIFO, LIFO ou aléatoire ?
La Queue classe, ainsi que les Queue<T>classes , ConcurrentQueue<T>et ImmutableQueue<T> génériques offrent tous un accès FIFO. Pour plus d’informations, consultez Quand utiliser une collection de Thread-Safe.
La Stack classe, ainsi que les Stack<T>classes , ConcurrentStack<T>et ImmutableStack<T> génériques offrent tous un accès LIFO. Pour plus d’informations, consultez Quand utiliser une collection de Thread-Safe.
La LinkedList<T> classe générique autorise l’accès séquentiel de la tête à la queue, ou de la queue à la tête.
Avez-vous besoin d’accéder à chaque élément par index ?
Les classes ArrayList et StringCollection, ainsi que la classe générique List<T>, offrent un accès à leurs éléments par l'index basé sur zéro de l'élément. Pour assurer l'immuabilité, considérez 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 l’accès à leurs éléments par 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 l’accès à leurs éléments soit par l’index de base zéro, soit par 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 l’une des collections en fonction de l’interface IList ou de l’interface IList<T> générique. Pour une option immuable, envisagez l’interface IImmutableList<T> générique.
Une clé et une valeur : utilisez l’une des collections en fonction de l’interface IDictionary ou de l’interface IDictionary<TKey,TValue> générique. Pour une option immuable, envisagez les interfaces génériques IImmutableSet<T> ou IImmutableDictionary<TKey,TValue>.
Une valeur avec clé incorporée : utilisez la KeyedCollection<TKey,TItem> classe générique.
Une clé et plusieurs valeurs : utilisez la NameValueCollection classe.
Avez-vous besoin de trier les éléments différemment de la façon dont ils ont été entrés ?
La Hashtable classe trie ses éléments en fonction de leurs codes de hachage.
La SortedList classe et les SortedList<TKey,TValue>SortedDictionary<TKey,TValue> classes génériques trient leurs éléments par la 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>. Parmi les deux types génériques, SortedDictionary<TKey,TValue> offre de meilleures performances que SortedList<TKey,TValue>, tout en SortedList<TKey,TValue> consommant moins de mémoire.
ArrayList fournit une méthode qui prend une implémentation Sort en tant que paramètre IComparer. Son équivalent générique, la List<T> classe générique, fournit une méthode qui prend une Sort implémentation de l’interface IComparer<T> générique en tant que paramètre.
Avez-vous besoin de recherches rapides et de récupération d’informations ?
- ListDictionary est plus rapide que Hashtable pour les petites collections (10 éléments ou moins). La Dictionary<TKey,TValue> classe générique fournit une recherche plus rapide que la SortedDictionary<TKey,TValue> classe générique. 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 multi-tâches, consultez Quand utiliser une collection Thread-Safe.
Avez-vous besoin de collections qui acceptent seulement des chaînes ?
StringCollection (basé sur IList) et StringDictionary (basé sur IDictionary) se trouvent dans l’espace System.Collections.Specialized de noms.
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 de type String< List> ou Dictionary<String,String>.
LINQ to Objects et PLINQ
LINQ to Objects permet aux développeurs d’utiliser des requêtes LINQ pour accéder aux objets en mémoire tant que le type d’objet implémente IEnumerable ou IEnumerable<T>. Les requêtes LINQ fournissent un modèle courant pour accéder aux données, sont généralement plus concises et lisibles que les boucles standard foreach , et fournissent des fonctionnalités 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 de requête plus rapide dans de nombreux scénarios, grâce à une utilisation plus efficace des ordinateurs multicœurs. Pour plus d’informations, consultez Parallel LINQ (PLINQ).
Voir aussi
Collaborer avec nous sur GitHub
La source de ce contenu se trouve sur GitHub, où vous pouvez également créer et examiner les problèmes et les demandes de tirage. Pour plus d’informations, consultez notre guide du contributeur.
