Hashtable Clase

Definición

Representa una colección de pares de clave y valor que se organizan por código hash de la clave.Represents a collection of key/value pairs that are organized based on the hash code of the key.

public ref class Hashtable : ICloneable, System::Collections::IDictionary, System::Runtime::Serialization::IDeserializationCallback, System::Runtime::Serialization::ISerializable
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public class Hashtable : ICloneable, System.Collections.IDictionary, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable
type Hashtable = class
    interface IDictionary
    interface ISerializable
    interface IDeserializationCallback
    interface ICloneable
    interface ICollection
    interface IEnumerable
Public Class Hashtable
Implements ICloneable, IDeserializationCallback, IDictionary, ISerializable
Herencia
Hashtable
Derivado
Atributos
Implementaciones

Ejemplos

En el ejemplo siguiente se muestra cómo crear, inicializar y realizar varias funciones en un Hashtable y cómo imprimir sus claves y valores.The following example shows how to create, initialize and perform various functions to a Hashtable and how to print out its keys and values.

using namespace System;
using namespace System::Collections;

public ref class Example
{
public:
    static void Main()
    {
        // Create a new hash table.
        //
        Hashtable^ openWith = gcnew 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();
        for each( 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();
        for each( 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();
        for each( 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.");
        }
    }
};

int main()
{
    Example::Main();
}

/* 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.
 */
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.
 */
Imports System.Collections

Module Example

    Sub Main()

        ' Create a new hash table.
        '
        Dim openWith As 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.")
        End Try

        ' 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 Not openWith.ContainsKey("ht") Then
            openWith.Add("ht", "hypertrm.exe")
            Console.WriteLine("Value added for key = ""ht"": {0}", _
                openWith("ht"))
        End If

        ' When you use foreach to enumerate hash table elements,
        ' the elements are retrieved as KeyValuePair objects.
        Console.WriteLine()
        For Each de As DictionaryEntry In openWith
            Console.WriteLine("Key = {0}, Value = {1}", _
                de.Key, de.Value)
        Next de

        ' To get the values alone, use the Values property.
        Dim valueColl As ICollection = openWith.Values

        ' The elements of the ValueCollection are strongly typed
        ' with the type that was specified for hash table values.
        Console.WriteLine()
        For Each s As String In valueColl
            Console.WriteLine("Value = {0}", s)
        Next s

        ' To get the keys alone, use the Keys property.
        Dim keyColl As ICollection = openWith.Keys

        ' The elements of the KeyCollection are strongly typed
        ' with the type that was specified for hash table keys.
        Console.WriteLine()
        For Each s As String In keyColl
            Console.WriteLine("Key = {0}", s)
        Next s

        ' Use the Remove method to remove a key/value pair.
        Console.WriteLine(vbLf + "Remove(""doc"")")
        openWith.Remove("doc")

        If Not openWith.ContainsKey("doc") Then
            Console.WriteLine("Key ""doc"" is not found.")
        End If

    End Sub

End Module

' 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.
# Create new hash table using PowerShell syntax
$OpenWith = @{}

# Add one element to the hash table using the Add method
$OpenWith.Add('txt', 'notepad.exe')

# Add three eleements using PowerShell syntax three different ways
$OpenWith.dib = 'paint.exe'

$KeyBMP = 'bmp'
$OpenWith[$KeyBMP] = 'paint.exe'

$OpenWith += @{'rtf' = 'wordpad.exe'}

# Display hash table
"There are {0} in the `$OpenWith hash table as follows:" -f $OpenWith.Count
''

# Display hashtable properties
'Count of items in the hashtable  : {0}' -f $OpenWith.Count
'Is hashtable fixed size?         : {0}' -f $OpenWith.IsFixedSize
'Is hashtable read-only?          : {0}' -f $OpenWith.IsReadonly
'Is hashtabale synchronised?      : {0}' -f $OpenWith.IsSynchronized
''
'Keys in hashtable:'
$OpenWith.Keys
''
'Values in hashtable:'
$OpenWith.Values
''

<#
This script produces the following output:

There are 4 in the $OpenWith hash table as follows:

Name                           Value                                                                            
----                           -----                                                                            
txt                            notepad.exe                                                                      
dib                            paint.exe                                                                        
bmp                            paint.exe                                                                        
rtf                            wordpad.exe                                                                      

Count of items in the hashtable  : 4
Is hashtable fixed size?         : False
Is hashtable read-only?          : False
Is hashtabale synchronised?      : False

Keys in hashtable:
txt
dib
bmp
rtf

Values in hashtable:
notepad.exe
paint.exe
paint.exe
wordpad.exe
#>

Comentarios

Cada elemento es un par clave-valor almacenado en un objeto DictionaryEntry.Each element is a key/value pair stored in a DictionaryEntry object. Una clave no puede ser null, pero un valor puede ser.A key cannot be null, but a value can be.

Importante

No se recomienda usar la clase Hashtable para el nuevo desarrollo.We don't recommend that you use the Hashtable class for new development. En su lugar, se recomienda usar la clase genérica Dictionary<TKey,TValue>.Instead, we recommend that you use the generic Dictionary<TKey,TValue> class. Para obtener más información, consulte no se deben usar colecciones no genéricas en github.For more information, see Non-generic collections shouldn't be used on GitHub.

Los objetos utilizados como claves por Hashtable son necesarios para invalidar el método Object.GetHashCode (o la interfaz IHashCodeProvider) y el método Object.Equals (o la interfaz IComparer).The objects used as keys by a Hashtable are required to override the Object.GetHashCode method (or the IHashCodeProvider interface) and the Object.Equals method (or the IComparer interface). La implementación de métodos e interfaces debe controlar la distinción entre mayúsculas y minúsculas de la misma manera; de lo contrario, el Hashtable podría comportarse incorrectamente.The implementation of both methods and interfaces must handle case sensitivity the same way; otherwise, the Hashtable might behave incorrectly. Por ejemplo, al crear un Hashtable, debe usar la clase CaseInsensitiveHashCodeProvider (o cualquier implementación que no distinga entre mayúsculas y minúsculas IHashCodeProvider) con la clase CaseInsensitiveComparer (o cualquier implementación que no distinga entre mayúsculas y minúsculas IComparer).For example, when creating a Hashtable, you must use the CaseInsensitiveHashCodeProvider class (or any case-insensitive IHashCodeProvider implementation) with the CaseInsensitiveComparer class (or any case-insensitive IComparer implementation).

Además, estos métodos deben producir los mismos resultados cuando se llama con los mismos parámetros mientras la clave existe en el Hashtable.Furthermore, these methods must produce the same results when called with the same parameters while the key exists in the Hashtable. Una alternativa es usar un constructor Hashtable con un parámetro IEqualityComparer.An alternative is to use a Hashtable constructor with an IEqualityComparer parameter. Si la igualdad de clave fuera simplemente la igualdad de referencia, la implementación heredada de Object.GetHashCode y Object.Equals sería suficiente.If key equality were simply reference equality, the inherited implementation of Object.GetHashCode and Object.Equals would suffice.

Los objetos de clave deben ser inmutables siempre que se usen como claves en el Hashtable.Key objects must be immutable as long as they are used as keys in the Hashtable.

Cuando se agrega un elemento al Hashtable, el elemento se coloca en un depósito basado en el código hash de la clave.When an element is added to the Hashtable, the element is placed into a bucket based on the hash code of the key. Las búsquedas posteriores de la clave usan el código hash de la clave para buscar solo en un depósito determinado, lo que reduce considerablemente el número de comparaciones de clave necesarias para encontrar un elemento.Subsequent lookups of the key use the hash code of the key to search in only one particular bucket, thus substantially reducing the number of key comparisons required to find an element.

El factor de carga de un Hashtable determina la proporción máxima de elementos de los cubos.The load factor of a Hashtable determines the maximum ratio of elements to buckets. Los factores de carga más pequeños causan tiempos de búsqueda promedio más rápidos a costa de un aumento del consumo de memoria.Smaller load factors cause faster average lookup times at the cost of increased memory consumption. El factor de carga predeterminado de 1,0 suele proporcionar el mejor equilibrio entre velocidad y tamaño.The default load factor of 1.0 generally provides the best balance between speed and size. También se puede especificar un factor de carga diferente cuando se crea el Hashtable.A different load factor can also be specified when the Hashtable is created.

A medida que se agregan elementos a un Hashtable, aumenta el factor de carga real del Hashtable.As elements are added to a Hashtable, the actual load factor of the Hashtable increases. Cuando el factor de carga real alcanza el factor de carga especificado, el número de depósitos en el Hashtable se aumenta automáticamente al número primo más pequeño que sea mayor que el doble del número actual de cubos Hashtable.When the actual load factor reaches the specified load factor, the number of buckets in the Hashtable is automatically increased to the smallest prime number that is larger than twice the current number of Hashtable buckets.

Cada objeto clave del Hashtable debe proporcionar su propia función hash, a la que se puede tener acceso llamando a GetHash.Each key object in the Hashtable must provide its own hash function, which can be accessed by calling GetHash. Sin embargo, cualquier objeto que implemente IHashCodeProvider se puede pasar a un constructor Hashtable y esa función hash se utiliza para todos los objetos de la tabla.However, any object implementing IHashCodeProvider can be passed to a Hashtable constructor, and that hash function is used for all objects in the table.

La capacidad de un Hashtable es el número de elementos que puede contener el Hashtable.The capacity of a Hashtable is the number of elements the Hashtable can hold. A medida que se agregan elementos a un Hashtable, la capacidad aumenta automáticamente según sea necesario a través de la reasignación.As elements are added to a Hashtable, the capacity is automatically increased as required through reallocation.

Solo .NET Framework: En el caso de los objetos Hashtable muy grandes, puede aumentar la capacidad máxima a 2 mil millones elementos en un sistema de 64 bits estableciendo el atributo enabled del elemento de configuración <gcAllowVeryLargeObjects> en true en el entorno de tiempo de ejecución..NET Framework only: For very large Hashtable objects, you can increase the maximum capacity to 2 billion elements on a 64-bit system by setting the enabled attribute of the <gcAllowVeryLargeObjects> configuration element to true in the run-time environment.

La instrucción foreach del C# lenguaje (For Each en Visual Basic) devuelve un objeto del tipo de los elementos de la colección.The foreach statement of the C# language (For Each in Visual Basic) returns an object of the type of the elements in the collection. Puesto que cada elemento del Hashtable es un par clave-valor, el tipo de elemento no es el tipo de la clave o el tipo del valor.Since each element of the Hashtable is a key/value pair, the element type is not the type of the key or the type of the value. En su lugar, el tipo de elemento es DictionaryEntry.Instead, the element type is DictionaryEntry. Por ejemplo:For example:

for each(DictionaryEntry de in myHashtable)
{
    // ...
}
foreach(DictionaryEntry de in myHashtable)
{
    // ...
}
For Each de As DictionaryEntry In myHashtable
    ' ...
Next de

La instrucción foreach es un contenedor alrededor del enumerador, que solo permite la lectura, no la escritura, de la colección.The foreach statement is a wrapper around the enumerator, which only allows reading from, not writing to, the collection.

Dado que la serialización y deserialización de un enumerador para un Hashtable puede hacer que los elementos se reordenen, no es posible continuar la enumeración sin llamar al método Reset.Because serializing and deserializing an enumerator for a Hashtable can cause the elements to become reordered, it is not possible to continue enumeration without calling the Reset method.

Nota

Dado que las claves se pueden heredar y cambiar su comportamiento, no se puede garantizar su unicidad absoluta mediante comparaciones mediante el método Equals.Because keys can be inherited and their behavior changed, their absolute uniqueness cannot be guaranteed by comparisons using the Equals method.

Constructores

Hashtable()

Inicializa una nueva instancia vacía de la clase Hashtable utilizando la capacidad inicial, el factor de carga, el proveedor de código hash y el comparador predeterminados.Initializes a new, empty instance of the Hashtable class using the default initial capacity, load factor, hash code provider, and comparer.

Hashtable(IDictionary)

Inicializa una nueva instancia de la clase Hashtable copiando los elementos del diccionario especificado en el nuevo objeto Hashtable.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. El nuevo objeto Hashtable tiene una capacidad inicial igual al número de elementos copiados, y utiliza el factor de carga, el proveedor de código hash y comparador predeterminados.The new Hashtable object has an initial capacity equal to the number of elements copied, and uses the default load factor, hash code provider, and comparer.

Hashtable(IDictionary, IEqualityComparer)

Inicializa una nueva instancia de la clase Hashtable copiando los elementos del diccionario especificado en un nuevo objeto Hashtable.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to a new Hashtable object. El nuevo objeto Hashtable tiene una capacidad inicial igual al número de elementos copiados, y utiliza el factor de carga predeterminado y el objeto IEqualityComparer especificado.The new Hashtable object has an initial capacity equal to the number of elements copied, and uses the default load factor and the specified IEqualityComparer object.

Hashtable(IDictionary, IHashCodeProvider, IComparer)

Inicializa una nueva instancia de la clase Hashtable copiando los elementos del diccionario especificado en el nuevo objeto Hashtable.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. El nuevo objeto Hashtable tiene una capacidad inicial igual al número de elementos copiados, utiliza el factor de carga predeterminado, y el proveedor de código hash y comparador especificados.The new Hashtable object has an initial capacity equal to the number of elements copied, and uses the default load factor, and the specified hash code provider and comparer. Esta API está obsoleta.This API is obsolete. Para una alternativa, vea Hashtable(IDictionary, IEqualityComparer).For an alternative, see Hashtable(IDictionary, IEqualityComparer).

Hashtable(IDictionary, Single)

Inicializa una nueva instancia de la clase Hashtable copiando los elementos del diccionario especificado en el nuevo objeto Hashtable.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. El nuevo objeto Hashtable tiene una capacidad inicial igual al número de elementos copiados, utiliza el factor de carga especificado, y el proveedor de código hash y comparador predeterminados.The new Hashtable object has an initial capacity equal to the number of elements copied, and uses the specified load factor, and the default hash code provider and comparer.

Hashtable(IDictionary, Single, IEqualityComparer)

Inicializa una nueva instancia de la clase Hashtable copiando los elementos del diccionario especificado en el nuevo objeto Hashtable.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. El nuevo objeto Hashtable tiene una capacidad inicial igual al número de elementos copiados, y utiliza el factor de carga y el objeto IEqualityComparer especificados.The new Hashtable object has an initial capacity equal to the number of elements copied, and uses the specified load factor and IEqualityComparer object.

Hashtable(IDictionary, Single, IHashCodeProvider, IComparer)

Inicializa una nueva instancia de la clase Hashtable copiando los elementos del diccionario especificado en el nuevo objeto Hashtable.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. El nuevo objeto Hashtable tiene una capacidad inicial igual al número de elementos copiados, y utiliza el factor de carga, el proveedor de código hash y el comparador especificados.The new Hashtable object has an initial capacity equal to the number of elements copied, and uses the specified load factor, hash code provider, and comparer.

Hashtable(IEqualityComparer)

Inicializa una nueva instancia vacía de la clase Hashtable utilizando la capacidad inicial y el factor de carga predeterminados, y el objeto IEqualityComparer especificado.Initializes a new, empty instance of the Hashtable class using the default initial capacity and load factor, and the specified IEqualityComparer object.

Hashtable(IHashCodeProvider, IComparer)

Inicializa una nueva instancia vacía de la clase Hashtable utilizando la capacidad inicial y el factor de carga predeterminados, y el proveedor de código hash y el comparador especificados.Initializes a new, empty instance of the Hashtable class using the default initial capacity and load factor, and the specified hash code provider and comparer.

Hashtable(Int32)

Inicializa una nueva instancia vacía de la clase Hashtable utilizando la capacidad inicial especificada, y el factor de carga, el proveedor de código hash y el comparador predeterminados.Initializes a new, empty instance of the Hashtable class using the specified initial capacity, and the default load factor, hash code provider, and comparer.

Hashtable(Int32, IEqualityComparer)

Inicializa una nueva instancia vacía de la clase Hashtable utilizando la capacidad inicial y el objeto IEqualityComparer especificados, y el factor de carga predeterminado.Initializes a new, empty instance of the Hashtable class using the specified initial capacity and IEqualityComparer, and the default load factor.

Hashtable(Int32, IHashCodeProvider, IComparer)

Inicializa una nueva instancia vacía de la clase Hashtable utilizando la capacidad inicial, el proveedor de código hash y el comparador especificados, y el factor de carga predeterminado.Initializes a new, empty instance of the Hashtable class using the specified initial capacity, hash code provider, comparer, and the default load factor.

Hashtable(Int32, Single)

Inicializa una nueva instancia vacía de la clase Hashtable utilizando la capacidad inicial y el factor de carga especificados, y el proveedor de código hash y el comparador predeterminados.Initializes a new, empty instance of the Hashtable class using the specified initial capacity and load factor, and the default hash code provider and comparer.

Hashtable(Int32, Single, IEqualityComparer)

Inicializa una nueva instancia vacía de la clase Hashtable utilizando la capacidad inicial, el factor de carga y el objeto IEqualityComparer especificados.Initializes a new, empty instance of the Hashtable class using the specified initial capacity, load factor, and IEqualityComparer object.

Hashtable(Int32, Single, IHashCodeProvider, IComparer)

Inicializa una nueva instancia vacía de la clase Hashtable utilizando la capacidad inicial, el factor de carga, el proveedor de código hash y el comparador especificados.Initializes a new, empty instance of the Hashtable class using the specified initial capacity, load factor, hash code provider, and comparer.

Hashtable(SerializationInfo, StreamingContext)

Inicializa una nueva instancia vacía de la clase Hashtable que es serializable, utilizando los objetos SerializationInfo y StreamingContext especificados.Initializes a new, empty instance of the Hashtable class that is serializable using the specified SerializationInfo and StreamingContext objects.

Propiedades

comparer

Obtiene o establece el IComparer que se utilizará para Hashtable.Gets or sets the IComparer to use for the Hashtable.

Count

Obtiene el número de pares clave-valor incluidos en Hashtable.Gets the number of key/value pairs contained in the Hashtable.

EqualityComparer

Obtiene el IEqualityComparer que se va a utilizar para Hashtable.Gets the IEqualityComparer to use for the Hashtable.

hcp

Obtiene o establece el objeto que puede dispensar códigos hash.Gets or sets the object that can dispense hash codes.

IsFixedSize

Obtiene un valor que indica si la interfaz Hashtable tiene un tamaño fijo.Gets a value indicating whether the Hashtable has a fixed size.

IsReadOnly

Obtiene un valor que indica si Hashtable es de solo lectura.Gets a value indicating whether the Hashtable is read-only.

IsSynchronized

Obtiene un valor que indica si el acceso a la interfaz Hashtable está sincronizado (es seguro para subprocesos).Gets a value indicating whether access to the Hashtable is synchronized (thread safe).

Item[Object]

Obtiene o establece el valor asociado a la clave especificada.Gets or sets the value associated with the specified key.

Keys

Obtiene una interfaz ICollection que contiene las claves de Hashtable.Gets an ICollection containing the keys in the Hashtable.

SyncRoot

Obtiene un objeto que se puede usar para sincronizar el acceso a Hashtable.Gets an object that can be used to synchronize access to the Hashtable.

Values

Obtiene una interfaz ICollection que contiene los valores de la interfaz Hashtable.Gets an ICollection containing the values in the Hashtable.

Métodos

Add(Object, Object)

Agrega un elemento con la clave y el valor especificados a Hashtable.Adds an element with the specified key and value into the Hashtable.

Clear()

Quita todos los elementos de Hashtable.Removes all elements from the Hashtable.

Clone()

Crea una copia superficial de la colección Hashtable.Creates a shallow copy of the Hashtable.

Contains(Object)

Determina si Hashtable contiene una clave específica.Determines whether the Hashtable contains a specific key.

ContainsKey(Object)

Determina si Hashtable contiene una clave específica.Determines whether the Hashtable contains a specific key.

ContainsValue(Object)

Determina si Hashtable contiene un valor específico.Determines whether the Hashtable contains a specific value.

CopyTo(Array, Int32)

Copia los elementos de Hashtable a una instancia unidimensional de Array en el índice especificado.Copies the Hashtable elements to a one-dimensional Array instance at the specified index.

Equals(Object)

Determina si el objeto especificado es igual al objeto actual.Determines whether the specified object is equal to the current object.

(Heredado de Object)
GetEnumerator()

Devuelve un objeto IDictionaryEnumerator que itera a través del objeto Hashtable.Returns an IDictionaryEnumerator that iterates through the Hashtable.

GetHash(Object)

Devuelve el código hash de la clave especificada.Returns the hash code for the specified key.

GetHashCode()

Sirve como función hash predeterminada.Serves as the default hash function.

(Heredado de Object)
GetObjectData(SerializationInfo, StreamingContext)

Implementa la interfaz de ISerializable y devuelve los datos necesarios para serializar Hashtable.Implements the ISerializable interface and returns the data needed to serialize the Hashtable.

GetType()

Obtiene el Type de la instancia actual.Gets the Type of the current instance.

(Heredado de Object)
KeyEquals(Object, Object)

Compara un Object específico con una clave concreta en Hashtable.Compares a specific Object with a specific key in the Hashtable.

MemberwiseClone()

Crea una copia superficial del Object actual.Creates a shallow copy of the current Object.

(Heredado de Object)
OnDeserialization(Object)

Implementa la interfaz ISerializable y genera el evento de deserialización cuando esta ha finalizado.Implements the ISerializable interface and raises the deserialization event when the deserialization is complete.

Remove(Object)

Quita el elemento con la clave especificada de Hashtable.Removes the element with the specified key from the Hashtable.

Synchronized(Hashtable)

Devuelve un contenedor sincronizado (seguro para subprocesos) para el objeto Hashtable.Returns a synchronized (thread-safe) wrapper for the Hashtable.

ToString()

Devuelve un valor de tipo string que representa el objeto actual.Returns a string that represents the current object.

(Heredado de Object)

Implementaciones de interfaz explícitas

IEnumerable.GetEnumerator()

Devuelve un enumerador que recorre en iteración una colección.Returns an enumerator that iterates through a collection.

Métodos de extensión

Cast<TResult>(IEnumerable)

Convierte los elementos de IEnumerable en el tipo especificado.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

Filtra los elementos de IEnumerable en función de un tipo especificado.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

Habilita la paralelización de una consulta.Enables parallelization of a query.

AsQueryable(IEnumerable)

Convierte una interfaz IEnumerable en IQueryable.Converts an IEnumerable to an IQueryable.

Se aplica a

Seguridad para subprocesos

Hashtable es seguro para subprocesos para su uso por parte de varios subprocesos de lector y un único subproceso de escritura.Hashtable is thread safe for use by multiple reader threads and a single writing thread. Es seguro para subprocesos para el uso de varios subprocesos cuando solo uno de los subprocesos realiza operaciones de escritura (actualización), lo que permite lecturas sin bloqueos siempre que los escritores se serialicen en el Hashtable.It is thread safe for multi-thread use when only one of the threads perform write (update) operations, which allows for lock-free reads provided that the writers are serialized to the Hashtable. Para admitir varios escritores, todas las operaciones en el Hashtable deben realizarse a través del contenedor devuelto por el método Synchronized(Hashtable), siempre que no haya ningún subproceso que lea el objeto Hashtable.To support multiple writers all operations on the Hashtable must be done through the wrapper returned by the Synchronized(Hashtable) method, provided that there are no threads reading the Hashtable object.

La enumeración a través de una colección no es intrínsecamente un procedimiento seguro para subprocesos.Enumerating through a collection is intrinsically not a thread safe procedure. Incluso cuando una colección está sincronizada, otros subprocesos todavía pueden modificarla, lo que hace que el enumerador produzca una excepción.Even when a collection is synchronized, other threads can still modify the collection, which causes the enumerator to throw an exception. 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.To guarantee thread safety during enumeration, you can either lock the collection during the entire enumeration or catch the exceptions resulting from changes made by other threads.

Consulte también: