Hashtable Classe

Definição

Namespace:

System.Collections

Assembly:

System.Runtime.dll

Origem:

Hashtable.cs

Representa uma coleção de pares chave-valor organizados com base no código hash da chave.

public ref class Hashtable : ICloneable, System::Collections::IDictionary, System::Runtime::Serialization::IDeserializationCallback, System::Runtime::Serialization::ISerializable

public class Hashtable : ICloneable, System.Collections.IDictionary, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable

type Hashtable = class
    interface ICollection
    interface IEnumerable
    interface IDictionary
    interface ICloneable
    interface IDeserializationCallback
    interface ISerializable

Public Class Hashtable
Implements ICloneable, IDeserializationCallback, IDictionary, ISerializable

Herança

Object

Hashtable

Derivado

System.Configuration.SettingsAttributeDictionary

System.Configuration.SettingsContext

System.Data.PropertyCollection

System.Printing.IndexedProperties.PrintPropertyDictionary

Implementações

ICollection IDictionary IEnumerable ICloneable IDeserializationCallback ISerializable

Exemplos

O exemplo a seguir mostra como criar, inicializar e executar várias funções para um Hashtable e como imprimir suas chaves e valores.

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
#>

Comentários

Cada elemento é um par chave/valor armazenado em um DictionaryEntry objeto . Uma chave não pode ser null, mas um valor pode ser.

Importante

Não recomendamos que você use a Hashtable classe para novo desenvolvimento. Em vez disso, recomendamos que você use a classe genérica Dictionary<TKey,TValue> . Para obter mais informações, consulte Coleções não genéricas não devem ser usadas no GitHub.

Os objetos usados como chaves por um Hashtable são necessários para substituir o Object.GetHashCode método (ou a IHashCodeProvider interface) e o Object.Equals método (ou a IComparer interface). A implementação de ambos os métodos e interfaces deve lidar com a confidencialidade de maiúsculas e minúsculas da mesma maneira; caso contrário, o Hashtable pode se comportar incorretamente. Por exemplo, ao criar um Hashtable, você deve usar a CaseInsensitiveHashCodeProvider classe (ou qualquer implementação que não diferencia maiúsculas IHashCodeProvider de minúsculas) com a CaseInsensitiveComparer classe (ou qualquer implementação que não diferencia maiúsculas de minúsculas IComparer ).

Além disso, esses métodos devem produzir os mesmos resultados quando chamados com os mesmos parâmetros enquanto a chave existe no Hashtable. Uma alternativa é usar um Hashtable construtor com um IEqualityComparer parâmetro . Se a igualdade chave fosse simplesmente a igualdade de referência, a implementação herdada de Object.GetHashCode e Object.Equals seria suficiente.

Os objetos de chave devem ser imutáveis, desde que sejam usados como chaves no Hashtable.

Quando um elemento é adicionado ao Hashtable, o elemento é colocado em um bucket com base no código hash da chave. Pesquisas subsequentes da chave usam o código hash da chave para pesquisar apenas um bucket específico, reduzindo substancialmente o número de comparações de chave necessárias para localizar um elemento.

O fator de carga de um Hashtable determina a taxa máxima de elementos para buckets. Fatores de carga menores causam tempos de pesquisa médios mais rápidos ao custo do aumento do consumo de memória. O fator de carga padrão de 1.0 geralmente fornece o melhor equilíbrio entre velocidade e tamanho. Um fator de carga diferente também pode ser especificado quando o Hashtable é criado.

À medida que os elementos são adicionados a um Hashtable, o fator de carga real do Hashtable aumenta. Quando o fator de carga real atinge o fator de carga especificado, o número de buckets no Hashtable é automaticamente aumentado para o menor número primo que é maior que o dobro do número atual de Hashtable buckets.

Cada objeto de chave no Hashtable deve fornecer sua própria função de hash, que pode ser acessada chamando GetHash. No entanto, qualquer implementação de IHashCodeProvider objeto pode ser passada para um Hashtable construtor e essa função de hash é usada para todos os objetos na tabela.

A capacidade de um Hashtable é o número de elementos que o Hashtable pode conter. À medida que os elementos são adicionados a um Hashtable, a capacidade é automaticamente aumentada conforme necessário por meio da realocação.

.NET Framework somente: para objetos muito grandesHashtable, você pode aumentar a capacidade máxima para 2 bilhões de elementos em um sistema de 64 bits definindo o enabled atributo do elemento de <gcAllowVeryLargeObjects> configuração como true no ambiente de tempo de execução.

A foreach instrução da linguagem C# (For Each no Visual Basic) retorna um objeto do tipo dos elementos na coleção. Como cada elemento do Hashtable é um par chave/valor, o tipo de elemento não é o tipo da chave ou o tipo do valor. Em vez disso, o tipo de elemento é DictionaryEntry. Por exemplo:

for each(DictionaryEntry de in myHashtable)
{
    // ...
}

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

For Each de As DictionaryEntry In myHashtable
    ' ...
Next de

A foreach instrução é um wrapper em torno do enumerador, que só permite a leitura, não a gravação em, a coleção.

Como serializar e desserializar um enumerador para um Hashtable pode fazer com que os elementos sejam reordenados, não é possível continuar a enumeração sem chamar o Reset método.

Observação

Como as chaves podem ser herdadas e seu comportamento foi alterado, sua exclusividade absoluta não pode ser garantida por comparações usando o Equals método .

Construtores

Hashtable()	Inicializa uma instância nova e vazia da classe Hashtable usando a capacidade inicial, o fator de carga, o provedor de código hash e o comparador padrão.
Hashtable(IDictionary)	Inicializa uma nova instância da classe Hashtable copiando os elementos do dicionário especificado para o novo objeto Hashtable. O novo objeto Hashtable tem uma capacidade inicial igual ao número de elementos copiados e usa o fator de carga, o provedor de código hash e o comparador padrão.
Hashtable(IDictionary, IEqualityComparer)	Inicializa uma nova instância da classe Hashtable copiando os elementos do dicionário especificado para um novo objeto Hashtable. O novo objeto Hashtable tem uma capacidade inicial igual ao número de elementos copiados e usa o fator de carga padrão e o objeto IEqualityComparer especificado.
Hashtable(IDictionary, IHashCodeProvider, IComparer)	Obsoleto. Inicializa uma nova instância da classe Hashtable copiando os elementos do dicionário especificado para o novo objeto Hashtable. O novo objeto Hashtable tem uma capacidade inicial igual ao número de elementos copiados e usa o fator de carga padrão e o provedor de código hash e o comparador especificados. Esta API está obsoleta. Para obter uma alternativa, consulte Hashtable(IDictionary, IEqualityComparer).
Hashtable(IDictionary, Single)	Inicializa uma nova instância da classe Hashtable copiando os elementos do dicionário especificado para o novo objeto Hashtable. O novo objeto Hashtable tem uma capacidade inicial igual ao número de elementos copiados e usa o fator de carga especificado e o provedor de código hash e o comparador padrão.
Hashtable(IDictionary, Single, IEqualityComparer)	Inicializa uma nova instância da classe Hashtable copiando os elementos do dicionário especificado para o novo objeto Hashtable. O novo objeto Hashtable tem uma capacidade inicial igual ao número de elementos copiados e usa o fator de carga especificado e o objeto IEqualityComparer.
Hashtable(IDictionary, Single, IHashCodeProvider, IComparer)	Obsoleto. Inicializa uma nova instância da classe Hashtable copiando os elementos do dicionário especificado para o novo objeto Hashtable. O novo objeto Hashtable tem uma capacidade inicial igual ao número de elementos copiados e usa o fator de carga, o provedor de código hash e o comparador especificados.
Hashtable(IEqualityComparer)	Inicializa uma instância nova e vazia da classe Hashtable usando a capacidade inicial e o fator de carga padrão e o objeto IEqualityComparer especificado.
Hashtable(IHashCodeProvider, IComparer)	Obsoleto. Inicializa uma instância nova e vazia da classe Hashtable usando a capacidade inicial e o fator de carga padrão, bem como o provedor de código hash e o comparador especificados.
Hashtable(Int32)	Inicializa uma instância nova e vazia da classe Hashtable usando a capacidade inicial especificada e o fator de carga padrão, o provedor de código hash e o comparador.
Hashtable(Int32, IEqualityComparer)	Inicializa uma instância nova e vazia da classe Hashtable usando a capacidade inicial especificada e IEqualityComparer, bem como o fator de carga padrão.
Hashtable(Int32, IHashCodeProvider, IComparer)	Obsoleto. Inicializa uma instância nova e vazia da classe Hashtable usando a capacidade inicial especificada, o provedor de código hash, o comparador e o fator de carga padrão.
Hashtable(Int32, Single)	Inicializa uma instância nova e vazia da classe Hashtable usando a capacidade inicial e o fator de carga especificados, bem como o provedor de código hash e o comparador padrão.
Hashtable(Int32, Single, IEqualityComparer)	Inicializa uma instância nova e vazia da classe Hashtable usando a capacidade inicial especificada, o fator de carga e o objeto IEqualityComparer.
Hashtable(Int32, Single, IHashCodeProvider, IComparer)	Obsoleto. Inicializa uma instância nova e vazia da classe Hashtable usando a capacidade inicial, o fator de carga, o provedor de código hash e o comparador especificados.
Hashtable(SerializationInfo, StreamingContext)	Obsoleto. Inicializa uma nova instância vazia da classe Hashtable que pode ser serializada usando os objetos SerializationInfo e StreamingContext especificados.

Propriedades

comparer	Obsoleto. Obtém ou define o IComparer a ser usado para o Hashtable.
Count	Obtém o número de pares chave-valor contidos no Hashtable.
EqualityComparer	Obtém o IEqualityComparer a ser usado para o Hashtable.
hcp	Obsoleto. Obtém ou define o objeto que pode dispensar códigos hash.
IsFixedSize	Obtém um valor que indica se o Hashtable tem um tamanho fixo.
IsReadOnly	Obtém um valor que indica se o Hashtable é somente leitura.
IsSynchronized	Obtém um valor que indica se o acesso à Hashtable é sincronizado (thread-safe).
Item[Object]	Obtém ou define o valor associado à chave especificada.
Keys	Obtém uma ICollection que contém as chaves na Hashtable.
SyncRoot	Obtém um objeto que pode ser usado para sincronizar o acesso ao Hashtable.
Values	Obtém um ICollection que contém os valores no Hashtable.

Métodos

Add(Object, Object)	Adiciona um elemento com a chave e o valor especificados ao Hashtable.
Clear()	Remove todos os elementos do Hashtable.
Clone()	Cria uma cópia superficial do Hashtable.
Contains(Object)	Determina se a Hashtable contém uma chave específica.
ContainsKey(Object)	Determina se a Hashtable contém uma chave específica.
ContainsValue(Object)	Determinará se o Hashtable contiver um valor específico.
CopyTo(Array, Int32)	Copia os elementos Hashtable para uma instância Array unidimensional no índice especificado.
Equals(Object)	Determina se o objeto especificado é igual ao objeto atual. (Herdado de Object)
GetEnumerator()	Retorna um IDictionaryEnumerator que itera pelo Hashtable.
GetHash(Object)	Retorna o código hash da chave especificada.
GetHashCode()	Serve como a função de hash padrão. (Herdado de Object)
GetObjectData(SerializationInfo, StreamingContext)	Obsoleto. Implementa a interface ISerializable e retorna os dados necessários para serializar o Hashtable.
GetType()	Obtém o Type da instância atual. (Herdado de Object)
KeyEquals(Object, Object)	Compara um Object específico com uma chave específica no Hashtable.
MemberwiseClone()	Cria uma cópia superficial do Object atual. (Herdado de Object)
OnDeserialization(Object)	Implementa a interface ISerializable e gera o evento de desserialização quando a desserialização for concluída.
Remove(Object)	Remove o elemento com a chave especificada do Hashtable.
Synchronized(Hashtable)	Retorna um wrapper sincronizado (thread-safe) para o Hashtable.
ToString()	Retorna uma cadeia de caracteres que representa o objeto atual. (Herdado de Object)

Implantações explícitas de interface

IEnumerable.GetEnumerator()

Retorna um enumerador que itera em uma coleção.

Métodos de Extensão

Cast<TResult>(IEnumerable)	Converte os elementos de um IEnumerable para o tipo especificado.
OfType<TResult>(IEnumerable)	Filtra os elementos de um IEnumerable com base em um tipo especificado.
AsParallel(IEnumerable)	Habilita a paralelização de uma consulta.
AsQueryable(IEnumerable)	Converte um IEnumerable em um IQueryable.

Acesso thread-safe

Hashtable é thread-safe para uso por vários threads de leitor e um único thread de gravação. Ele é thread-safe para uso de vários threads quando apenas um dos threads executa operações de gravação (atualização), o que permite leituras sem bloqueio, desde que os gravadores sejam serializados para o Hashtable. Para dar suporte a vários gravadores, todas as operações no Hashtable devem ser feitas por meio do wrapper retornado pelo Synchronized(Hashtable) método , desde que não haja threads lendo o Hashtable objeto.

A enumeração por meio de uma coleção não é intrinsecamente um procedimento seguro de thread. Mesmo quando uma coleção está sincronizada, outros threads ainda podem modificar a coleção, o que faz o enumerador lançar uma exceção. Para garantir thread-safe durante a enumeração, é possível bloquear a coleção durante toda a enumeração ou verificar as exceções resultantes das alterações feitas por outros threads.

Confira também

• IDictionary
• IHashCodeProvider
• GetHashCode()
• Equals(Object)
• DictionaryEntry
• Dictionary<TKey,TValue>
• IEqualityComparer