ListDictionary Classe

Définition

Espace de noms:

System.Collections.Specialized

Assembly:

System.Collections.Specialized.dll

Source:

ListDictionary.cs

Implémente IDictionary à l'aide d'une liste liée unique. Recommandée pour les collections qui contiennent généralement moins de 10 éléments.

C#

public class ListDictionary : System.Collections.IDictionary

Héritage

Object

ListDictionary

Implémente

ICollection IDictionary IEnumerable

Exemples

L’exemple de code suivant illustre plusieurs propriétés et méthodes de ListDictionary.

C#

using System;
using System.Collections;
using System.Collections.Specialized;

public class SamplesListDictionary  {

   public static void Main()  {

      // Creates and initializes a new ListDictionary.
      ListDictionary myCol = new ListDictionary();
      myCol.Add( "Braeburn Apples", "1.49" );
      myCol.Add( "Fuji Apples", "1.29" );
      myCol.Add( "Gala Apples", "1.49" );
      myCol.Add( "Golden Delicious Apples", "1.29" );
      myCol.Add( "Granny Smith Apples", "0.89" );
      myCol.Add( "Red Delicious Apples", "0.99" );

      // Display the contents of the collection using foreach. This is the preferred method.
      Console.WriteLine( "Displays the elements using foreach:" );
      PrintKeysAndValues1( myCol );

      // Display the contents of the collection using the enumerator.
      Console.WriteLine( "Displays the elements using the IDictionaryEnumerator:" );
      PrintKeysAndValues2( myCol );

      // Display the contents of the collection using the Keys, Values, Count, and Item properties.
      Console.WriteLine( "Displays the elements using the Keys, Values, Count, and Item properties:" );
      PrintKeysAndValues3( myCol );

      // Copies the ListDictionary to an array with DictionaryEntry elements.
      DictionaryEntry[] myArr = new DictionaryEntry[myCol.Count];
      myCol.CopyTo( myArr, 0 );

      // Displays the values in the array.
      Console.WriteLine( "Displays the elements in the array:" );
      Console.WriteLine( "   KEY                       VALUE" );
      for ( int i = 0; i < myArr.Length; i++ )
         Console.WriteLine( "   {0,-25} {1}", myArr[i].Key, myArr[i].Value );
      Console.WriteLine();

      // Searches for a key.
      if ( myCol.Contains( "Kiwis" ) )
         Console.WriteLine( "The collection contains the key \"Kiwis\"." );
      else
         Console.WriteLine( "The collection does not contain the key \"Kiwis\"." );
      Console.WriteLine();

      // Deletes a key.
      myCol.Remove( "Plums" );
      Console.WriteLine( "The collection contains the following elements after removing \"Plums\":" );
      PrintKeysAndValues1( myCol );

      // Clears the entire collection.
      myCol.Clear();
      Console.WriteLine( "The collection contains the following elements after it is cleared:" );
      PrintKeysAndValues1( myCol );
   }

   // Uses the foreach statement which hides the complexity of the enumerator.
   // NOTE: The foreach statement is the preferred way of enumerating the contents of a collection.
   public static void PrintKeysAndValues1( IDictionary myCol )  {
      Console.WriteLine( "   KEY                       VALUE" );
      foreach ( DictionaryEntry de in myCol )
         Console.WriteLine( "   {0,-25} {1}", de.Key, de.Value );
      Console.WriteLine();
   }

   // Uses the enumerator.
   // NOTE: The foreach statement is the preferred way of enumerating the contents of a collection.
   public static void PrintKeysAndValues2( IDictionary myCol )  {
      IDictionaryEnumerator myEnumerator = myCol.GetEnumerator();
      Console.WriteLine( "   KEY                       VALUE" );
      while ( myEnumerator.MoveNext() )
         Console.WriteLine( "   {0,-25} {1}", myEnumerator.Key, myEnumerator.Value );
      Console.WriteLine();
   }

   // Uses the Keys, Values, Count, and Item properties.
   public static void PrintKeysAndValues3( ListDictionary myCol )  {
      String[] myKeys = new String[myCol.Count];
      myCol.Keys.CopyTo( myKeys, 0 );

      Console.WriteLine( "   INDEX KEY                       VALUE" );
      for ( int i = 0; i < myCol.Count; i++ )
         Console.WriteLine( "   {0,-5} {1,-25} {2}", i, myKeys[i], myCol[myKeys[i]] );
      Console.WriteLine();
   }
}

/*
This code produces output similar to the following.
Note that because a dictionary is implemented for fast keyed access the order
of the items in the dictionary are not gauranteed and, as a result, should not
be depended on.

Displays the elements using foreach:
   KEY                       VALUE
   Braeburn Apples           1.49
   Fuji Apples               1.29
   Gala Apples               1.49
   Golden Delicious Apples   1.29
   Granny Smith Apples       0.89
   Red Delicious Apples      0.99

Displays the elements using the IDictionaryEnumerator:
   KEY                       VALUE
   Braeburn Apples           1.49
   Fuji Apples               1.29
   Gala Apples               1.49
   Golden Delicious Apples   1.29
   Granny Smith Apples       0.89
   Red Delicious Apples      0.99

Displays the elements using the Keys, Values, Count, and Item properties:
   INDEX KEY                       VALUE
   0     Braeburn Apples           1.49
   1     Fuji Apples               1.29
   2     Gala Apples               1.49
   3     Golden Delicious Apples   1.29
   4     Granny Smith Apples       0.89
   5     Red Delicious Apples      0.99

Displays the elements in the array:
   KEY                       VALUE
   Braeburn Apples           1.49
   Fuji Apples               1.29
   Gala Apples               1.49
   Golden Delicious Apples   1.29
   Granny Smith Apples       0.89
   Red Delicious Apples      0.99

The collection does not contain the key "Kiwis".

The collection contains the following elements after removing "Plums":
   KEY                       VALUE
   Braeburn Apples           1.49
   Fuji Apples               1.29
   Gala Apples               1.49
   Golden Delicious Apples   1.29
   Granny Smith Apples       0.89
   Red Delicious Apples      0.99

The collection contains the following elements after it is cleared:
   KEY                       VALUE


*/

Remarques

Il s’agit d’une implémentation simple de l’utilisation IDictionary d’une liste liée unique. Il est plus petit et plus rapide qu’un Hashtable si le nombre d’éléments est inférieur ou égal à 10. Cela ne doit pas être utilisé si les performances sont importantes pour un grand nombre d’éléments.

Les éléments d’un ListDictionary ne sont pas dans un ordre garanti ; le code ne doit pas dépendre de la commande actuelle. Le ListDictionary est implémenté pour une récupération à clé rapide ; l’ordre interne réel des éléments dépend de l’implémentation et peut changer dans les versions futures du produit.

Les membres, tels que Item[], Add, Removeet Contains sont des opérations O(n), où n est Count.

Une clé ne peut pas être null, mais une valeur peut.

L’instruction foreach du langage C# (for each en Visual Basic) retourne un objet du type des éléments de la collection. Étant donné que chaque élément de est ListDictionary une paire clé/valeur, le type d’élément n’est pas le type de la clé ou le type de la valeur. Au lieu de cela, le type d’élément est DictionaryEntry. Exemple :

C#

foreach (DictionaryEntry de in myListDictionary)
{
    //...
}

L’instruction foreach est un wrapper autour de l’énumérateur, qui autorise uniquement la lecture à partir de la collection, et non l’écriture dans.

Constructeurs

ListDictionary()	Crée un ListDictionary vide à l'aide du comparateur par défaut.
ListDictionary(IComparer)	Crée un ListDictionary vide à l'aide du comparateur spécifié.

Propriétés

Count	Obtient le nombre de paires clé/valeur contenues dans ListDictionary.
IsFixedSize	Obtient une valeur indiquant si ListDictionary est de taille fixe.
IsReadOnly	Obtient une valeur indiquant si ListDictionary est en lecture seule.
IsSynchronized	Obtient une valeur indiquant si le ListDictionary est synchronisé (thread-safe).
Item[Object]	Obtient ou définit la valeur associée à la clé spécifiée.
Keys	Obtient ICollection contenant les clés de ListDictionary.
SyncRoot	Obtient un objet qui peut être utilisé pour synchroniser l’accès à ListDictionary.
Values	Obtient ICollection contenant les valeurs de ListDictionary.

Méthodes

Add(Object, Object)	Ajoute une entrée avec la clé et la valeur spécifiées dans ListDictionary.
Clear()	Supprime toutes les entrées de ListDictionary.
Contains(Object)	Détermine si ListDictionary contient une clé spécifique.
CopyTo(Array, Int32)	Copie les entrées de ListDictionary vers une instance de Array unidimensionnel, à l'index spécifié.
Equals(Object)	Détermine si l'objet spécifié est égal à l'objet actuel. (Hérité de Object)
GetEnumerator()	Retourne un IDictionaryEnumerator qui itère au sein de ListDictionary.
GetHashCode()	Fait office de fonction de hachage par défaut. (Hérité de Object)
GetType()	Obtient le Type de l'instance actuelle. (Hérité de Object)
MemberwiseClone()	Crée une copie superficielle du Object actuel. (Hérité de Object)
Remove(Object)	Supprime de ListDictionary l'entrée avec la clé spécifiée.
ToString()	Retourne une chaîne qui représente l'objet actuel. (Hérité de Object)

Implémentations d’interfaces explicites

IEnumerable.GetEnumerator()

Retourne un IEnumerator qui itère au sein de ListDictionary.

Méthodes d’extension

Cast<TResult>(IEnumerable)	Effectue un cast des éléments d'un IEnumerable vers le type spécifié.
OfType<TResult>(IEnumerable)	Filtre les éléments d'un IEnumerable en fonction du type spécifié.
AsParallel(IEnumerable)	Active la parallélisation d'une requête.
AsQueryable(IEnumerable)	Convertit un IEnumerable en IQueryable.

S’applique à

Cohérence de thread

Les membres statiques publics (Shared en Visual Basic) de ce type sont thread safe. Tous les membres de l'instance ne sont pas garantis comme étant thread-safe.

Cette implémentation ne fournit pas de wrapper synchronisé (thread safe) pour un ListDictionary, mais les classes dérivées peuvent créer leurs propres versions synchronisées du à l’aide ListDictionary de la SyncRoot propriété .

L'énumération d'une collection n'est intrinsèquement pas une procédure thread-safe. Même lorsqu'une collection est synchronisée, les autres threads peuvent toujours la modifier, ce qui entraîne la levée d'une exception par l'énumérateur. Pour garantir la sécurité des threads au cours de l’énumération, vous pouvez verrouiller la collection pendant l’ensemble de l’énumération ou bien intercepter les exceptions résultant des modifications apportées par les autres threads.

Voir aussi

• IDictionary
• Hashtable
• Exécution d'opérations de chaînes indépendantes de la culture