ListDictionary Clase

Definición

Espacio de nombres:

System.Collections.Specialized

Ensamblado:

System.Collections.Specialized.dll

Source:

ListDictionary.cs

Implementa IDictionary utilizando una lista de vínculo única. Se recomienda para las colecciones que normalmente contienen menos de 10 elementos.

C#

public class ListDictionary : System.Collections.IDictionary

Herencia

Object

ListDictionary

Implementaciones

ICollection IDictionary IEnumerable

Ejemplos

En el ejemplo de código siguiente se muestran varias de las propiedades y métodos 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


*/

Comentarios

Se trata de una implementación sencilla de IDictionary usar una lista vinculada singly. Es menor y más rápido que si Hashtable el número de elementos es 10 o menos. Esto no se debe usar si el rendimiento es importante para un gran número de elementos.

Los elementos de un ListDictionary no están en ningún orden garantizado; el código no debe depender del orden actual. ListDictionary se implementa para la recuperación de claves rápida; el orden interno real de los elementos depende de la implementación y podría cambiar en versiones futuras del producto.

Los miembros, como Item[], Add, Removey Contains son operaciones O(n), donde n es Count.

Una clave no puede ser null, pero un valor puede.

La foreach instrucción del lenguaje C# (for each en Visual Basic) devuelve un objeto del tipo de los elementos de la colección. Dado que cada elemento de ListDictionary es un par clave-valor, el tipo de elemento no es el tipo de la clave o el tipo del valor. En su lugar, el tipo de elemento es DictionaryEntry. Por ejemplo:

C#

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

La foreach instrucción es un contenedor alrededor del enumerador, que solo permite leer, no escribir en la colección.

Constructores

ListDictionary()	Crea un ListDictionary vacío mediante el comparador predeterminado.
ListDictionary(IComparer)	Crea un ListDictionary vacío mediante el comparador especificado.

Propiedades

Count	Obtiene el número de pares clave-valor incluidos en ListDictionary.
IsFixedSize	Obtiene un valor que indica si la interfaz ListDictionary tiene un tamaño fijo.
IsReadOnly	Obtiene un valor que indica si ListDictionary es de solo lectura.
IsSynchronized	Obtiene un valor que indica si ListDictionary está sincronizado (es seguro para subprocesos).
Item[Object]	Obtiene o establece el valor asociado a la clave especificada.
Keys	Obtiene una interfaz ICollection que contiene las claves de ListDictionary.
SyncRoot	Obtiene un objeto que se puede usar para sincronizar el acceso a ListDictionary.
Values	Obtiene una interfaz ICollection que contiene los valores de la interfaz ListDictionary.

Métodos

Add(Object, Object)	Agrega una entrada con la clave y el valor especificados a ListDictionary.
Clear()	Quita todas las entradas de ListDictionary.
Contains(Object)	Determina si ListDictionary contiene una clave específica.
CopyTo(Array, Int32)	Copia las entradas de ListDictionary a una instancia de Array unidimensional en el índice especificado.
Equals(Object)	Determina si el objeto especificado es igual que el objeto actual. (Heredado de Object)
GetEnumerator()	Devuelve un objeto IDictionaryEnumerator que itera a través del objeto ListDictionary.
GetHashCode()	Sirve como la función hash predeterminada. (Heredado de Object)
GetType()	Obtiene el Type de la instancia actual. (Heredado de Object)
MemberwiseClone()	Crea una copia superficial del Object actual. (Heredado de Object)
Remove(Object)	Quita la entrada con la clave especificada de ListDictionary.
ToString()	Devuelve una cadena que representa el objeto actual. (Heredado de Object)

Implementaciones de interfaz explícitas

IEnumerable.GetEnumerator()

Devuelve un objeto IEnumerator que itera a través del objeto ListDictionary.

Métodos de extensión

Cast<TResult>(IEnumerable)	Convierte los elementos de IEnumerable en el tipo especificado.
OfType<TResult>(IEnumerable)	Filtra los elementos de IEnumerable en función de un tipo especificado.
AsParallel(IEnumerable)	Habilita la paralelización de una consulta.
AsQueryable(IEnumerable)	Convierte una interfaz IEnumerable en IQueryable.

Se aplica a

Seguridad para subprocesos

Los miembros estáticos públicos (Shared en Visual Basic) de este tipo son seguros para subprocesos. No se garantiza que los miembros de instancia sean seguros para subprocesos.

Esta implementación no proporciona un contenedor sincronizado (seguro para subprocesos) para una ListDictionaryclase , pero las clases derivadas pueden crear sus propias versiones sincronizadas de ListDictionary mediante la SyncRoot propiedad .

Enumerar una colección no es intrínsecamente un procedimiento seguro para subprocesos. Incluso cuando una colección está sincronizada, otros subprocesos todavía pueden modificarla, lo que hace que el enumerador produzca una excepción. Con el fin de garantizar la seguridad para la ejecución de subprocesos durante la enumeración, se puede bloquear la colección durante toda la enumeración o detectar las excepciones resultantes de los cambios realizados por otros subprocesos.

Consulte también

• IDictionary
• Hashtable
• Realizar operaciones de cadenas que no distinguen entre referencias culturales