Hashtable (Clase)

Cada elemento es un par de clave y valor almacenado en un objeto DictionaryEntry. Una clave no puede ser null, pero un valor sí puede serlo.

Los objetos utilizados como claves por Hashtable son necesarios para reemplazar el método Object.GetHashCode (o la interfaz IHashCodeProvider) y el método Object.Equals (o la interfaz IComparer). La implementación de ambos métodos e interfaces debe tratar la distinción entre mayúsculas y minúsculas de la misma manera; de lo contrario, el comportamiento de Hashtable podría ser incorrecto. Por ejemplo, al crear Hashtable, debe utilizar la clase CaseInsensitiveHashCodeProvider (o una implementación de IHashCodeProvider que no haga distinción entre mayúsculas y minúsculas) con la clase CaseInsensitiveComparer (o una implementación de IComparer que no haga distinción entre mayúsculas y minúsculas).

Asimismo, estos métodos deben dar los mismos resultados cuando se llamen con los mismos parámetros mientras la clave esté incluida en Hashtable. Una alternativa es utilizar un constructor de Hashtable con un parámetro de IEqualityComparer. Si la igualdad de clave fuera simplemente una igualdad de referencia, sería suficiente la implementación heredada de Object.GetHashCode y Object.Equals.

Los objetos de claves deben permanecer inmutables mientras se utilicen como claves en Hashtable.

Cuando se agrega un elemento a Hashtable, el elemento se coloca en un sector de almacenamiento en función del código hash de la clave. Las búsquedas posteriores de la clave utilizarán su código hash para buscar en un sector de almacenamiento determinado solamente; de este modo, se reducirá considerablemente el número de comparaciones de clave necesarias para encontrar un elemento.

El factor de carga de Hashtable determina la relación máxima de elementos por sectores de almacenamiento. Factores de carga más pequeños causan tiempos de búsqueda más largos a costa de un mayor consumo de memoria. El factor de carga predeterminado de 1,0 suele proporcionar el mejor equilibrio entre velocidad y tamaño. También se puede especificar un factor de carga diferente cuando se cree Hashtable.

Conforme se agregan elementos a Hashtable, va aumentando el factor de carga real de Hashtable. Cuando el factor de carga real alcanza el factor de carga especificado, el número de depósitos de Hashtable aumenta automáticamente hasta el número primo más pequeño que sea superior al doble del número actual de depósitos de Hashtable.

Cada objeto de clave de Hashtable debe proporcionar su propia función hash, a la que se tiene acceso llamando al método GetHash. Sin embargo, se puede pasar cualquier objeto que implemente IHashCodeProvider a un constructor Hashtable y utilizar esa función hash para todos los objetos de la tabla.

La capacidad de Hashtable es el número de elementos que Hashtable puede contener. Conforme se agregan elementos a Hashtable, la capacidad aumenta automáticamente según lo requiera la reasignación.

La instrucción foreach del lenguaje C# (For Each en Visual Basic) requiere el tipo de cada elemento de la colección. Como los elementos de Hashtable son pares de clave y valor, el tipo del elemento no se corresponde con el tipo de la clave ni con el del valor. En su lugar, el tipo del elemento es DictionaryEntry. Por ejemplo:

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

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

Dado que la serialización y deserialización de un enumerador para un objeto Hashtable puede provocar la reordenación de los elementos, no es posible continuar con la enumeración sin llamar antes al método Reset.

Nota
Dado que las claves se pueden heredar y su comportamiento puede cambiar, no es posible garantizar su unicidad absoluta mediante comparaciones utilizando el método Equals.

En el ejemplo siguiente se muestra cómo se crean, inicializan y realizan diversas funciones para Hashtable y cómo se imprimen sus claves y valores.

using System;
using System.Collections;

class Example
{
    public static void Main()
    {
        // Create a new hash table.
        //
        Hashtable openWith = new Hashtable();

        // Add some elements to the hash table. 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 hash table.
        try
        {
            openWith.Add("txt", "winword.exe");
        }
        catch
        {
            Console.WriteLine("An element with Key = \"txt\" already exists.");
        }

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

        // The default Item property 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 default Item property
        // for that key adds a new key/value pair.
        openWith["doc"] = "winword.exe";

        // 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 hash table elements,
        // the elements are retrieved as KeyValuePair objects.
        Console.WriteLine();
        foreach( DictionaryEntry de in openWith )
        {
            Console.WriteLine("Key = {0}, Value = {1}", de.Key, de.Value);
        }

        // To get the values alone, use the Values property.
        ICollection valueColl = openWith.Values;

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

        // To get the keys alone, use the Keys property.
        ICollection keyColl = openWith.Keys;

        // The elements of the KeyCollection are strongly typed
        // with the type that was specified for hash table 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.
Value added for key = "ht": hypertrm.exe

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

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

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

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

.NET Framework

.NET Framework Client Profile

Windows 7, Windows Vista SP1 o posterior, Windows XP SP3, Windows XP SP2 x64 Edition, Windows Server 2008 (no se admite Server Core), Windows Server 2008 R2 (se admite Server Core con SP1 o posterior), Windows Server 2003 SP2

La clase Hashtable es segura para la ejecución de subprocesos si la utilizan varios subprocesos de lectura y un único subproceso de escritura. Es segura para la ejecución de subprocesos cuando la utilizan varios subprocesos si sólo uno de ellos realiza operaciones de escritura (actualización), lo que permite la realización de lecturas sin bloqueo siempre y cuando los sistemas de escritura estén serializados en Hashtable. Para admitir varios subprocesos de escritura, todas las operaciones en Hashtable se deben realizar a través del contenedor que devuelve el método Synchronized, siempre que no haya ningún subproceso leyendo el objeto Hashtable.

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

Referencia