Hashtable Classe

Definição

public ref class Hashtable : System::Collections::IDictionary

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

public class Hashtable : System.Collections.IDictionary

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

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public 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

[<System.Serializable>]
type Hashtable = class
    interface IDictionary
    interface ICollection
    interface IEnumerable
    interface ISerializable
    interface IDeserializationCallback
    interface ICloneable

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Hashtable = class
    interface IDictionary
    interface ICollection
    interface IEnumerable
    interface ISerializable
    interface IDeserializationCallback
    interface ICloneable

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

Public Class Hashtable
Implements IDictionary

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

Atributos

SerializableAttribute ComVisibleAttribute

Implementações

ICollection IDictionary IEnumerable ICloneable IDeserializationCallback ISerializable

Exemplos

O exemplo seguinte mostra como criar, inicializar e executar várias funções para um Hashtable e como imprimir as suas chaves e 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.
 */

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 elements 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 hashtable 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 hashtable synchronised?      : False

Keys in hashtable:
txt
dib
bmp
rtf

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

Observações

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

Os objetos usados como chaves por a Hashtable são necessários para sobrepor 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 sensibilidade a maiúsculas minúsculas da mesma forma; caso contrário, podem Hashtable comportar-se de forma incorreta. Por exemplo, ao criar um Hashtable, deve usar a CaseInsensitiveHashCodeProvider classe (ou qualquer implementação insensível IHashCodeProvider a maiúsculas e minúsculas) com a CaseInsensitiveComparer classe (ou qualquer implementação insensível IComparer a maiúsculas e minúsculas).

Além disso, estes 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 de chave fosse simplesmente igualdade de referência, a implementação herdada de Object.GetHashCode e Object.Equals seria suficiente.

Objetos-chave devem ser imutáveis desde que sejam usados como chaves no Hashtable.

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

O fator de carga de um Hashtable determina a razão máxima de elementos para baldes. Fatores de carga mais pequenos provocam tempos médios de consulta mais rápidos, à custa de um maior consumo de memória. O fator de carga padrão da versão 1.0 geralmente proporciona o melhor equilíbrio entre velocidade e tamanho. Um fator de carga diferente também pode ser especificado quando o Hashtable é criado.

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

Cada objeto-chave em deve Hashtable fornecer a sua própria função de hash, que pode ser acedida chamando GetHash. No entanto, qualquer objeto implementado IHashCodeProvider pode ser passado para um Hashtable construtor, e essa função de hash é usada para todos os objetos da tabela.

A capacidade de a Hashtable é o número de elementos que Hashtable podem dever. À medida que elementos são adicionados a um Hashtable, a capacidade é automaticamente aumentada conforme necessário através da realocação.

.NET Framework apenas: Para objetos muito grandes Hashtable, pode aumentar a capacidade máxima para 2 mil milhões de elementos num sistema de 64 bits definindo o atributo enabled do elemento de configuração <gcAllowVeryLargeObjects> para true no ambiente de execução.

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

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

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

A foreach declaração é um wrapper em torno do enumerador, que só permite ler a partir da coleção, não escrever para.

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

Segurança de Thread

Hashtable É seguro para uso de múltiplos fios leitores e um único fio de escrita. É seguro para threads para uso multi-thread quando apenas uma das threads realiza operações de escrita (atualização), o que permite leituras sem bloqueios, desde que os escritores sejam serializados para o Hashtable. Para suportar múltiplos escritores, todas as operações sobre o Hashtable devem ser feitas através do wrapper devolvido pelo Synchronized(Hashtable) método, desde que não haja threads a ler o Hashtable objeto.

Enumerar através de uma coleção não é intrinsecamente um procedimento seguro para threads. Mesmo quando uma coleção está sincronizada, outros threads ainda podem modificar a coleção, o que faz com que o enumerador lance uma exceção. Para garantir a segurança dos threads durante a enumeração, pode bloquear a coleção durante toda a enumeração ou apanhar as exceções resultantes de alterações feitas por outros threads.

Ver também

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