Classe Hashtable

Ogni elemento è una coppia chiave-valore archiviata in un oggetto DictionaryEntry oggetto. una chiave non può essere null, ma un valore può essere.

Gli oggetti utilizzati come chiavi da un oggetto Hashtable essere necessario eseguire l'override Object.GetHashCode metodo (o IHashCodeProvider interfaccia) e Object.Equals metodo (o IComparer interfaccia). L'implementazione di entrambi i metodi e interfacce necessario gestire la distinzione tra maiuscole e minuscole nello stesso modo, in caso contrario, Hashtable funzionerà correttamente. Ad esempio quando creano un oggetto Hashtable, è necessario utilizzare CaseInsensitiveHashCodeProvider classe (o assenti senza distinzione tra maiuscole e minuscole IHashCodeProvider l'implementazione con CaseInsensitiveComparer classe (o assenti senza distinzione tra maiuscole e minuscole IComparer l'implementazione.

Inoltre, questi metodi devono fornire gli stessi risultati quando viene chiamato con gli stessi parametri durante la chiave è presente in Hashtable. In alternativa è possibile utilizzare un oggetto Hashtable costruttore con IEqualityComparer parametro. Se principale l'uguaglianza è semplicemente uguaglianza dei riferimenti, l'implementazione ereditata di Object.GetHashCode e Object.Equals basterebbe.

Gli oggetti principali devono essere immutabili finché non vengono utilizzati come tipo Hashtable.

Quando un elemento viene aggiunto a Hashtable, l'elemento viene inserito in un bucket base al codice hash della chiave. Ricerche successive di utilizzo principale il codice hash della chiave alla ricerca solo in un bucket particolare, pertanto una riduzione del numero dei confronti principali necessari per trovare un elemento.

Il fattore di carico di un oggetto Hashtable determina il rapporto massimo di elementi ai bucket. Più piccoli fattori di carico comportano tempi e l'altro più veloci di ricerca al costo di consumo di memoria aumentato. Il fattore di carico predefinito di 1,0 fornisce in genere il migliore bilanciamento tra velocità e la dimensione. Un fattore di carico diverso può anche essere specificato quando Hashtable viene creato.

Come aggiungere elementi a una Hashtable, effettivo fattore di carico di Hashtable aumenta. Quando effettivamente il fattore di carico raggiunge il fattore di carico specificato, il numero dei bucket in Hashtable viene aumentato il minore numero primo dei quali sia due volte maggiore del numero corrente Hashtable bucket.

Ogni oggetto principal in Hashtable è necessario che fornisca la propria funzione hash, che può essere eseguito chiamando GetHash. Tuttavia, qualsiasi oggetto distribuire IHashCodeProvider può essere passato a un oggetto Hashtable il costruttore e tale funzione hash viene utilizzato per tutti gli oggetti nella tabella.

La capacità di un oggetto Hashtable indica il numero di elementi Hashtable è possibile utilizzare. Come aggiungere elementi a una Hashtable, la capacità automaticamente viene aumentata come obbligatorio con riallocazione.

per molto grande Hashtable oggetti, è possibile aumentare la capacità massima di 2 miliardi di elementi in un sistema a 64 bit impostando enabled attributo " gcAllowVeryLargeObjects elemento di configurazione su true nell'ambiente di runtime.

foreach l'istruzione del linguaggio c# (For Each in Visual Basic) richiede il tipo di ogni elemento della raccolta. Per ogni elemento di Hashtable è una coppia chiave-valore, il tipo di elemento non è il tipo di chiave o il tipo del valore. invece, il tipo di elemento è DictionaryEntry. Ad esempio:

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

foreach l'istruzione è un wrapper di all'enumeratore, che consente solo la lettura, non scrittura, la raccolta.

Poiché la serializzazione e deserializzazione di un enumeratore per un oggetto Hashtable è possibile riordinare gli elementi a essere riordinati, non è possibile continuare l'enumerazione senza chiamare Reset metodo.

Nota
Poiché le chiavi possono essere ereditate e il comportamento essere modificate, la loro univocità assoluta non può essere garantita dai confronti tramite Equals metodo.

Nell'esempio seguente viene illustrato come creare, inizializzarlo e l'esecuzione di varie funzioni a un oggetto Hashtable e come stampare le chiavi e valori.

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 8, Windows Server 2012, Windows 7, Windows Vista SP2, Windows Server 2008 (ruoli di base del server non supportati), Windows Server 2008 R2 (ruoli di base del server supportati con SP1 o versione successiva, Itanium non supportato)

Hashtable è thread-safe per l'utilizzo da parte di più thread del lettore e di un singolo thread di scrittura. È thread-safe per l'utilizzo di multi-thread quando uno solo dei thread esegue scrive le operazioni (update), che consente di senza blocco legge a condizione che i writer vengono serializzati a Hashtable. Per supportare i writer e tutte le altre operazioni in Hashtable deve essere effettuata tramite il wrapper restituito da Synchronized metodo, a condizione che non esiste lettura dei thread Hashtable oggetto.

L'enumerazione in una raccolta non è di per sé thread-safe. Anche se una raccolta è sincronizzata, altri thread possono ancora modificare la raccolta, causando l'enumeratore a generare un'eccezione. Per garantire che l'enumerazione sia thread-safe, è possibile bloccare la raccolta durante l'intera enumerazione o intercettare le eccezioni derivazione dalle modifiche apportate da altri thread.

Riferimenti