Exportar (0) Imprimir
Expandir todo

Clase genérica Dictionary

Nota: esta clase es nueva en la versión 2.0 de .NET Framework.

Representa una colección de claves y valores.

Espacio de nombres: System.Collections.Generic
Ensamblado: mscorlib (en mscorlib.dll)

[SerializableAttribute] 
[ComVisibleAttribute(false)] 
public class Dictionary<TKey,TValue> : IDictionary<TKey,TValue>, ICollection<KeyValuePair<TKey,TValue>>, 
	IEnumerable<KeyValuePair<TKey,TValue>>, IDictionary, ICollection, IEnumerable, 
	ISerializable, IDeserializationCallback
J# admite el uso de métodos y tipos genéricos, pero no admite la declaración de métodos y tipos nuevos.
JScript no admite el uso de métodos y tipos genéricos.

Parámetros de tipo

TKey

Tipo de las claves del diccionario.

TValue

Tipo de los valores del diccionario.

La clase genérica Dictionary proporciona una asignación de un conjunto de claves a un conjunto de valores. Cada elemento que se agrega al diccionario está compuesto de un valor y su clave asociada. Recuperar un valor utilizando su clave es muy rápido, cerca de O(1), porque la clase Dictionary se implementa como una tabla hash.

NotaNota

La velocidad de recuperación depende de la calidad del algoritmo hash del tipo especificado para TKey.

Mientras se utilice un objeto como clave en el diccionario Dictionary, dicho objeto no se debe modificar en modo alguno que afecte a su valor hash. Cada clave de un diccionario Dictionary debe ser única conforme al comparador de igualdad del diccionario. Una clave no puede ser referencia de objeto null (Nothing en Visual Basic), aunque un valor sí puede serlo si el tipo de valor TValue es un tipo de referencia.

Dictionary requiere una implementación de igualdad para determinar si las claves son iguales. Se puede especificar una implementación de la interfaz genérica IEqualityComparer mediante un constructor que admita un parámetro comparer, pero cuando no se especifica una implementación, se utiliza el comparador de igualdad genérico predeterminado EqualityComparer.Default. Si el tipo TKey implementa la interfaz genérica System.IEquatable, el comparador de igualdad predeterminado utiliza esa implementación.

NotaNota

Por ejemplo, puede utilizar los comparadores de cadenas sin distinción entre mayúsculas y minúsculas proporcionados por la clase StringComparer para crear diccionarios con claves de cadena sin distinción entre mayúsculas y minúsculas.

La capacidad de una colección Dictionary es el número de elementos que dicha Dictionary puede contener. En esta implementación, la capacidad inicial predeterminada para una colección Dictionary es 3; sin embargo, ese valor predeterminado quizás cambie en las versiones futuras de .NET Framework. Cuando se agregan elementos a una colección Dictionary, la capacidad aumenta automáticamente según sea necesario mediante la reasignación de la matriz interna.

Para la enumeración, cada elemento del diccionario se trata como una estructura KeyValuePair que representa un valor y su clave. El orden en que se devuelven los elementos queda sin definir.

La instrucción foreach del lenguaje C# (for each en C++, For Each en Visual Basic) requiere el tipo de cada elemento de la colección. Puesto que Dictionary es una colección de claves y valores, el tipo de elemento no es el tipo de la clave, ni el tipo del valor. En su lugar, el tipo de elemento es una estructura KeyValuePair del tipo de la clave y del tipo del valor. Por ejemplo:

foreach (KeyValuePair<int, string> kvp in myDictionary) {...}

La instrucción foreach es un contenedor del enumerador que sólo permite la lectura de la colección, pero no la escritura.

En el ejemplo de código siguiente se crea una colección Dictionary vacía de cadenas con claves de cadena y se utiliza el método Add para agregar algunos elementos. En él, se muestra que el método Add produce una excepción ArgumentException cuando se intenta agregar una clave duplicada.

Asimismo, se utiliza la propiedad Item (el indizador en C#) para recuperar los valores, mostrando cómo se produce una excepción KeyNotFoundException cuando una clave solicitada no está presente, y que es posible reemplazar el valor asociado a una clave.

En el ejemplo se muestra cómo utilizar el método TryGetValue como un medio más eficaz de recuperar los valores si un programa debe probar con frecuencia valores de clave que no están en el diccionario; igualmente se muestra cómo utilizar el método ContainsKey para comprobar si una clave existe antes de llamar al método Add.

Además, en el ejemplo se muestra cómo enumerar las claves y los valores del diccionario, y cómo enumerar sólo las claves y los valores utilizando la propiedad Keys y la propiedad Values.

Por último, en el ejemplo se muestra el método Remove.

using System;
using System.Collections.Generic;

public class Example
{
    public static void Main()
    {
        // Create a new dictionary of strings, with string keys.
        //
        Dictionary<string, string> openWith = 
            new Dictionary<string, string>();

        // Add some elements to the dictionary. There are no 
        // duplicate keys, but some of the values are duplicates.
        openWith.Add("txt", "notepad.exe");
        openWith.Add("bmp", "paint.exe");
        openWith.Add("dib", "paint.exe");
        openWith.Add("rtf", "wordpad.exe");

        // The Add method throws an exception if the new key is 
        // already in the dictionary.
        try
        {
            openWith.Add("txt", "winword.exe");
        }
        catch (ArgumentException)
        {
            Console.WriteLine("An element with Key = \"txt\" already exists.");
        }

        // The Item property is another name for the indexer, so you 
        // can omit its name when accessing elements. 
        Console.WriteLine("For key = \"rtf\", value = {0}.", 
            openWith["rtf"]);

        // The indexer can be used to change the value associated
        // with a key.
        openWith["rtf"] = "winword.exe";
        Console.WriteLine("For key = \"rtf\", value = {0}.", 
            openWith["rtf"]);

        // If a key does not exist, setting the indexer for that key
        // adds a new key/value pair.
        openWith["doc"] = "winword.exe";

        // The indexer throws an exception if the requested key is
        // not in the dictionary.
        try
        {
            Console.WriteLine("For key = \"tif\", value = {0}.", 
                openWith["tif"]);
        }
        catch (KeyNotFoundException)
        {
            Console.WriteLine("Key = \"tif\" is not found.");
        }

        // When a program often has to try keys that turn out not to
        // be in the dictionary, TryGetValue can be a more efficient 
        // way to retrieve values.
        string value = "";
        if (openWith.TryGetValue("tif", out value))
        {
            Console.WriteLine("For key = \"tif\", value = {0}.", value);
        }
        else
        {
            Console.WriteLine("Key = \"tif\" is not found.");
        }

        // ContainsKey can be used to test keys before inserting 
        // them.
        if (!openWith.ContainsKey("ht"))
        {
            openWith.Add("ht", "hypertrm.exe");
            Console.WriteLine("Value added for key = \"ht\": {0}", 
                openWith["ht"]);
        }

        // When you use foreach to enumerate dictionary elements,
        // the elements are retrieved as KeyValuePair objects.
        Console.WriteLine();
        foreach( KeyValuePair<string, string> kvp in openWith )
        {
            Console.WriteLine("Key = {0}, Value = {1}", 
                kvp.Key, kvp.Value);
        }

        // To get the values alone, use the Values property.
        Dictionary<string, string>.ValueCollection valueColl =
            openWith.Values;

        // The elements of the ValueCollection are strongly typed
        // with the type that was specified for dictionary values.
        Console.WriteLine();
        foreach( string s in valueColl )
        {
            Console.WriteLine("Value = {0}", s);
        }

        // To get the keys alone, use the Keys property.
        Dictionary<string, string>.KeyCollection keyColl =
            openWith.Keys;

        // The elements of the KeyCollection are strongly typed
        // with the type that was specified for dictionary keys.
        Console.WriteLine();
        foreach( string s in keyColl )
        {
            Console.WriteLine("Key = {0}", s);
        }

        // Use the Remove method to remove a key/value pair.
        Console.WriteLine("\nRemove(\"doc\")");
        openWith.Remove("doc");

        if (!openWith.ContainsKey("doc"))
        {
            Console.WriteLine("Key \"doc\" is not found.");
        }
    }
}

/* This code example produces the following output:

An element with Key = "txt" already exists.
For key = "rtf", value = wordpad.exe.
For key = "rtf", value = winword.exe.
Key = "tif" is not found.
Key = "tif" is not found.
Value added for key = "ht": hypertrm.exe

Key = txt, Value = notepad.exe
Key = bmp, Value = paint.exe
Key = dib, Value = paint.exe
Key = rtf, Value = winword.exe
Key = doc, Value = winword.exe
Key = ht, Value = hypertrm.exe

Value = notepad.exe
Value = paint.exe
Value = paint.exe
Value = winword.exe
Value = winword.exe
Value = hypertrm.exe

Key = txt
Key = bmp
Key = dib
Key = rtf
Key = doc
Key = ht

Remove("doc")
Key "doc" is not found.
 */

System.Object
  System.Collections.Generic.Dictionary

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

Dictionary puede admitir varios sistemas de lectura a la vez, siempre y cuando no se modifique la colección. Aun así, por su naturaleza, la enumeración mediante una colección no es un procedimiento seguro para la ejecución de subprocesos. En el caso excepcional de que haya un conflicto entre una enumeración y los accesos de escritura, se debe bloquear la colección durante toda la enumeración. Para permitir que varios subprocesos obtengan acceso de lectura y escritura a la colección, debe implementar su propia sincronización.

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium, Windows Mobile para Pocket PC, Windows Mobile para Smartphone, Windows Server 2003, Windows XP Media Center, Windows XP Professional x64, Windows XP SP2, Windows XP Starter Edition

.NET Framework no admite todas las versiones de cada plataforma. Para obtener una lista de las versiones admitidas, vea Requisitos del sistema.

.NET Framework

Compatible con: 2.0

.NET Compact Framework

Compatible con: 2.0

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft