Esporta (0) Stampa
Espandi tutto
Questo argomento non è stato ancora valutato - Valuta questo argomento

Classe Hashtable

Aggiornamento: novembre 2007

Rappresenta un insieme di coppie chiave/valore organizzate in base al codice hash della chiave.

Spazio dei nomi:  System.Collections
Assembly:  mscorlib (in mscorlib.dll)

[SerializableAttribute]
[ComVisibleAttribute(true)]
public class Hashtable : IDictionary, ICollection, 
	IEnumerable, ISerializable, IDeserializationCallback, ICloneable
/** @attribute SerializableAttribute */ 
/** @attribute ComVisibleAttribute(true) */
public class Hashtable implements IDictionary, 
	ICollection, IEnumerable, ISerializable, IDeserializationCallback, ICloneable
public class Hashtable implements IDictionary, ICollection, IEnumerable, ISerializable, IDeserializationCallback, ICloneable

Ogni elemento è costituito da una coppia chiave/valore memorizzata in un oggetto DictionaryEntry. Una chiave, a differenza di un valore, non può essere null.

Gli oggetti utilizzati come chiavi da una classe Hashtable sono necessari per eseguire l'override del metodo Object.GetHashCode (o dell'interfaccia IHashCodeProvider) e del metodo Object.Equals (o dell'interfaccia IComparer). Nell'implementazione dei metodi e delle interfacce la distinzione tra maiuscole e minuscole deve essere gestita allo stesso modo; in caso contrario, il comportamento della classe Hashtable potrebbe risultare scorretto. Ad esempio, durante la creazione di una classe Hashtable, è necessario utilizzare la classe CaseInsensitiveHashCodeProvider (o una qualsiasi implementazione IHashCodeProvider in cui non viene fatta distinzione tra maiuscole e minuscole) con la classe CaseInsensitiveComparer (o una qualsiasi implementazione IComparer con distinzione tra maiuscole e minuscole).

Inoltre, è necessario che tali metodi producano gli stessi risultati se chiamati con gli stessi parametri mentre la chiave esiste nella Hashtable. In alternativa è possibile utilizzare un costruttore Hashtable con un parametro IEqualityComparer. Se l'uguaglianza delle chiavi è semplicemente un'uguaglianza di riferimenti, l'implementazione ereditata di Object.GetHashCode e Object.Equals dovrebbe essere sufficiente.

Gli oggetti chiave non devono essere modificati finché utilizzati come chiavi nella Hashtable.

Quando viene aggiunto un elemento alla Hashtable, viene posizionato in una certa sezione, o bucket, in base al codice hash della chiave. Nelle successive ricerche della chiave verrà utilizzato il codice hash della chiave per effettuare la ricerca solo in un determinato bucket, con una sostanziale riduzione del numero di confronti di chiavi necessari per trovare un elemento.

Il fattore di caricamento di una Hashtable determina il rapporto massimo di elementi rispetto ai bucket. Fattori di carico più piccoli determinano tempi di ricerca medi più veloci ma anche un maggior utilizzo di memoria. Il fattore di carico predefinito è 1.0, che in genere rappresenta l'equilibrio migliore tra velocità e dimensioni. È inoltre possibile specificare un diverso fattore di carico quando viene creata la Hashtable.

Quando gli elementi vengono aggiunti a una Hashtable, il fattore di carico effettivo della Hashtable aumenta. Quando il fattore di carico effettivo raggiunge il fattore di carico specificato, il numero di bucket nella classe Hashtable viene automaticamente aumentato. Il nuovo valore sarà pari al numero primo più piccolo che risulti maggiore del doppio del numero corrente di bucket della classe Hashtable.

È necessario che ogni oggetto chiave nella Hashtable fornisca la propria funzione hash, accessibile chiamando GetHash. Tuttavia, qualsiasi oggetto che implementi IHashCodeProvider può essere passato a un costruttore Hashtable; tale funzione hash viene utilizzata per tutti gli oggetti della tabella.

La capacità di una classe Hashtable è il numero di elementi che tale classe Hashtable può contenere. Con l'aggiunta di elementi a Hashtable, la capacità viene automaticamente aumentata secondo le necessità, tramite riallocazione.

vb#c#

L'istruzione foreach del linguaggio C# ( for each in Visual Basic) richiede il tipo di ogni elemento dell'insieme. Poiché ogni elemento della classe Hashtable è una coppia chiave/valore, il tipo di elemento non è il tipo della chiave né il tipo del valore. Il tipo dell'elemento è invece DictionaryEntry. Ad esempio:

foreach (DictionaryEntry de in myHashtable) {...}
vb#c#

L'istruzione foreach è un wrapper per l'enumeratore che consente solo di leggere dall'insieme, ma non di scrivere in esso.

Dal momento che la serializzazione e la deserializzazione di un enumeratore per una classe Hashtable possono comportare un riordinamento degli elementi, non è possibile continuare l'enumerazione senza chiamare il metodo Reset.

Nota:

Poiché le chiavi possono essere ereditate ed è possibile modificarne il comportamento, non è possibile garantirne l'univocità assoluta mediante confronti eseguiti utilizzando il metodo Equals.

Nell'esempio riportato di seguito viene illustrato come creare, inizializzare ed eseguire varie funzioni su un oggetto Hashtable e come stampare i relativi valori e chiavi.

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.
 */


Hashtable è thread-safe per quanto riguarda l'utilizzo da parte di più thread di lettura e di un singolo thread di scrittura. È thread-safe per l'utilizzo multi-thread quando solo uno dei thread esegue operazioni di scrittura (aggiornamento) che consentono letture senza blocchi purché i writer vengano serializzati nella classe Hashtable. Per supportare più writer, le operazioni sull'oggetto Hashtable devono venire eseguite tramite il wrapper restituito dal metodo Synchronized, purché non ci siano thread che leggono l'oggetto Hashtable.

L'enumerazione di un insieme non è di per sé una procedura thread-safe. Anche se un insieme è sincronizzato, è possibile che venga modificato da altri thread, con conseguente generazione di un'eccezione da parte dell'enumeratore. Per garantire che un insieme sia thread-safe durante l'enumerazione, è possibile bloccarlo nel corso dell'operazione oppure rilevare le eccezioni generate dalle modifiche apportate da altri thread.

Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition , Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98, Windows CE, Windows Mobile per Smartphone, Windows Mobile per Pocket PC, Xbox 360

.NET Framework e .NET Compact Framework non supportano tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema di .NET Framework.

.NET Framework

Supportato in: 3.5, 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Supportato in: 3.5, 2.0, 1.0

XNA Framework

Supportato in: 2.0, 1.0
Il documento è risultato utile?
(1500 caratteri rimanenti)
Grazie per i commenti inviati.

Aggiunte alla community

AGGIUNGI
Microsoft sta conducendo un sondaggio in linea per comprendere l'opinione degli utenti in merito al sito Web di MSDN. Se si sceglie di partecipare, quando si lascia il sito Web di MSDN verrà visualizzato il sondaggio in linea.

Si desidera partecipare?
Mostra:
© 2014 Microsoft. Tutti i diritti riservati.