ListDictionary Classe

Definizione

Spazio dei nomi:

System.Collections.Specialized

Assembly:

System.Collections.Specialized.dll

Origine:

ListDictionary.cs

Implementa l'oggetto IDictionary usando un elenco di oggetti collegato singolarmente. Consigliato per le raccolte che includono meno di 10 voci.

C#

public class ListDictionary : System.Collections.IDictionary

Ereditarietà

Object

ListDictionary

Implementazioni

ICollection IDictionary IEnumerable

Esempio

Nell'esempio di codice seguente vengono illustrati diversi metodi e proprietà di 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


*/

Commenti

Si tratta di una semplice implementazione dell'uso di IDictionary un elenco collegato singly. È più piccolo e più veloce di un Hashtable se il numero di elementi è 10 o meno. Questa operazione non deve essere usata se le prestazioni sono importanti per un numero elevato di elementi.

Gli elementi in un ListDictionary oggetto non sono in alcun ordine garantito. Il codice non deve dipendere dall'ordine corrente. viene ListDictionary implementato per il recupero con chiave rapida. L'ordine interno effettivo degli elementi dipende dall'implementazione e potrebbe cambiare nelle versioni future del prodotto.

I membri, ad esempio Item[], RemoveAdd, e Contains sono operazioni O(n), dove n è Count.

Una chiave non può essere null, ma un valore può.

L'istruzione foreach del linguaggio C# (for each in Visual Basic) restituisce un oggetto del tipo degli elementi nella raccolta. Poiché ogni elemento di ListDictionary è una coppia chiave/valore, il tipo di elemento non è il tipo della chiave o il tipo del valore. Al contrario, il tipo di elemento è DictionaryEntry. Ad esempio:

C#

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

L'istruzione foreach è un wrapper intorno all'enumeratore, che consente solo la lettura, non la scrittura nella raccolta.

Costruttori

ListDictionary()	Crea un oggetto ListDictionary vuoto mediante l'operatore di confronto predefinito.
ListDictionary(IComparer)	Crea un oggetto ListDictionary vuoto mediante l'operatore di confronto specificato.

Proprietà

Count	Ottiene il numero di coppie chiave/valore contenute in ListDictionary.
IsFixedSize	Ottiene un valore che indica se ListDictionary ha dimensioni fisse.
IsReadOnly	Ottiene un valore che indica se ListDictionary è di sola lettura.
IsSynchronized	Ottiene un valore che indica se la classe ListDictionary è sincronizzata (thread-safe).
Item[Object]	Ottiene o imposta il valore associato alla chiave specificata.
Keys	Ottiene un oggetto ICollection contenente le chiavi presenti nell'oggetto ListDictionary.
SyncRoot	Ottiene un oggetto che può essere usato per sincronizzare l'accesso a ListDictionary.
Values	Ottiene ICollection contenente i valori in ListDictionary.

Metodi

Add(Object, Object)	Aggiunge una voce con la chiave e il valore specificati nell'oggetto ListDictionary.
Clear()	Rimuove tutte le voci da ListDictionary.
Contains(Object)	Determina se l'oggetto ListDictionary contiene una chiave specifica.
CopyTo(Array, Int32)	Copia le voci dell'oggetto ListDictionary in un'istanza di Array unidimensionale in corrispondenza dell'indice specificato.
Equals(Object)	Determina se l'oggetto specificato è uguale all'oggetto corrente. (Ereditato da Object)
GetEnumerator()	Restituisce un oggetto IDictionaryEnumerator che esegue l'iterazione di ListDictionary.
GetHashCode()	Funge da funzione hash predefinita. (Ereditato da Object)
GetType()	Ottiene l'oggetto Type dell'istanza corrente. (Ereditato da Object)
MemberwiseClone()	Crea una copia superficiale dell'oggetto Object corrente. (Ereditato da Object)
Remove(Object)	Rimuove la voce con la chiave specificata da ListDictionary.
ToString()	Restituisce una stringa che rappresenta l'oggetto corrente. (Ereditato da Object)

Implementazioni dell'interfaccia esplicita

IEnumerable.GetEnumerator()

Restituisce un oggetto IEnumerator che esegue l'iterazione di ListDictionary.

Metodi di estensione

Cast<TResult>(IEnumerable)	Esegue il cast degli elementi di un oggetto IEnumerable nel tipo specificato.
OfType<TResult>(IEnumerable)	Filtra gli elementi di un oggetto IEnumerable in base a un tipo specificato.
AsParallel(IEnumerable)	Consente la parallelizzazione di una query.
AsQueryable(IEnumerable)	Converte un oggetto IEnumerable in un oggetto IQueryable.

Si applica a

Thread safety

I membri statici pubblici (Shared in Visual Basic) di questo tipo sono thread-safe. Non è invece garantita la sicurezza dei membri dell'istanza.

Questa implementazione non fornisce un wrapper sincronizzato (thread-safe) per un ListDictionaryoggetto , ma le classi derivate possono creare le proprie versioni sincronizzate dell'oggetto ListDictionary usando la SyncRoot proprietà .

L'enumerazione di una raccolta non è di per sé una procedura thread-safe. Anche se una raccolta è sincronizzata, è possibile che venga modificata da altri thread, con conseguente generazione di un'eccezione da parte dell'enumeratore. Per garantire la protezione dei thread durante l'enumerazione, è possibile bloccare la raccolta per l'intera enumerazione oppure intercettare le eccezioni determinate dalle modifiche apportate da altri thread.

Vedi anche

• IDictionary
• Hashtable
• Esecuzione di operazioni sulle stringhe indipendenti dalle impostazioni cultura