Hashtable Classe

Definizione

Rappresenta una raccolta di coppie chiave/valore organizzate in base al codice hash della chiave.

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
public class Hashtable : ICloneable, System.Collections.IDictionary, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable
[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
type Hashtable = class
    interface ICollection
    interface IEnumerable
    interface IDictionary
type Hashtable = class
    interface ICollection
    interface IEnumerable
    interface IDictionary
    interface ICloneable
    interface IDeserializationCallback
    interface ISerializable
type Hashtable = class
    interface ICollection
    interface IEnumerable
    interface IDictionary
    interface ISerializable
    interface IDeserializationCallback
    interface ICloneable
[<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
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Hashtable = class
    interface IDictionary
    interface ISerializable
    interface IDeserializationCallback
    interface ICloneable
    interface ICollection
    interface IEnumerable
Public Class Hashtable
Implements IDictionary
Public Class Hashtable
Implements ICloneable, IDeserializationCallback, IDictionary, ISerializable
Ereditarietà
Hashtable
Derivato
Attributi
Implementazioni

Esempio

Nell'esempio seguente viene illustrato come creare, inizializzare ed eseguire varie funzioni per un oggetto e Hashtable come stampare le chiavi e i valori.

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

Commenti

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

Importante

Non è consigliabile usare la classe Hashtable per il nuovo sviluppo. È invece consigliabile usare la classe Dictionary<TKey,TValue> generica . Per altre informazioni, vedere Non è consigliabile usare raccolte non generiche in GitHub.

Gli oggetti utilizzati come chiavi da un oggetto sono necessari per eseguire l'override del metodo (o dell'interfaccia ) e Hashtable Object.GetHashCode del metodo IHashCodeProvider Object.Equals (o IComparer dell'interfaccia ). L'implementazione di metodi e interfacce deve gestire la distinzione tra maiuscole e minuscole nello stesso modo. In caso contrario, Hashtable il comportamento di potrebbe non essere corretto. Ad esempio, quando si crea un , è necessario usare la classe (o qualsiasi implementazione senza distinzione tra maiuscole e minuscole) con la classe (o qualsiasi implementazione senza distinzione tra maiuscole Hashtable CaseInsensitiveHashCodeProvider e IHashCodeProvider CaseInsensitiveComparer IComparer minuscole).

Inoltre, questi metodi devono produrre gli stessi risultati quando vengono chiamati con gli stessi parametri mentre la chiave esiste in Hashtable . Un'alternativa consiste nell'usare Hashtable un costruttore con un parametro IEqualityComparer . Se l'uguaglianza delle chiavi fosse semplicemente un riferimento all'uguaglianza, l'implementazione ereditata di Object.GetHashCode Object.Equals e sarebbe sufficiente.

Gli oggetti chiave devono essere non modificabili finché vengono usati come chiavi in Hashtable .

Quando un elemento viene aggiunto a Hashtable , l'elemento viene inserito in un bucket in base al codice hash della chiave. Le ricerche successive della chiave usano il codice hash della chiave per eseguire la ricerca in un solo bucket specifico, riducendo in modo sostanziale il numero di confronti di chiavi necessari per trovare un elemento.

Il fattore di carico di un Hashtable oggetto determina il rapporto massimo tra elementi e bucket. I fattori di carico più piccoli causano tempi medi di ricerca più rapidi a costo di un maggiore consumo di memoria. Il fattore di carico predefinito 1.0 offre in genere il miglior equilibrio tra velocità e dimensioni. Quando viene creato, è anche possibile specificare un fattore Hashtable di carico diverso.

Quando gli elementi vengono aggiunti a Hashtable un , aumenta il fattore di carico effettivo di Hashtable . Quando il fattore di carico effettivo raggiunge il fattore di carico specificato, il numero di bucket in viene automaticamente aumentato al numero primo più piccolo maggiore del doppio del numero corrente Hashtable Hashtable di bucket.

Ogni oggetto chiave in deve fornire la propria funzione hash, a cui Hashtable è possibile accedere chiamando GetHash . Tuttavia, qualsiasi oggetto che implementa può essere passato a un costruttore e IHashCodeProvider tale funzione hash viene usata per tutti gli oggetti nella Hashtable tabella.

La capacità di un Hashtable oggetto è il numero di elementi che Hashtable l'oggetto può contenere. Quando gli elementi vengono aggiunti a Hashtable un oggetto , la capacità viene aumentata automaticamente in base alle esigenze tramite la riallocazione.

.NET Framework solo: Per gli oggetti di dimensioni molto grandi, è possibile aumentare la capacità massima a 2 miliardi di elementi in un sistema a 64 bit impostando l'attributo dell'elemento di configurazione Hashtable enabled su nell'ambiente di <gcAllowVeryLargeObjects> true run-time.

foreachL'istruzione del linguaggio C# ( in Visual Basic) restituisce un oggetto del tipo For Each degli elementi nella raccolta. Poiché ogni elemento di è una coppia chiave/valore, il tipo di elemento non è il tipo della chiave o Hashtable il tipo del valore. Il tipo di elemento è DictionaryEntry invece . Esempio:

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

foreachL'istruzione è un wrapper per l'enumeratore, che consente solo la lettura dalla raccolta e non la scrittura nella raccolta.

Poiché la serializzazione e la deserializzazione di un enumeratore per un oggetto possono causare il riordinamento degli elementi, non è possibile continuare l'enumerazione senza chiamare Hashtable il Reset metodo .

Nota

Poiché le chiavi possono essere ereditate e il relativo comportamento può essere modificato, la loro univocità assoluta non può essere garantita dai confronti che usano il Equals metodo .

Costruttori

Hashtable()

Inizializza una nuova istanza vuota della classe Hashtable usando la capacità iniziale, il fattore di carico, il provider di codice hash e l'operatore di confronto predefiniti.

Hashtable(IDictionary)

Inizializza una nuova istanza della classe Hashtable copiando gli elementi dal dizionario specificato nel nuovo oggetto Hashtable. Il nuovo oggetto Hashtable ha una capacità iniziale uguale al numero di elementi copiati e usa il fattore di carico, il provider di codice hash e l'operatore di confronto predefiniti.

Hashtable(IDictionary, IEqualityComparer)

Inizializza una nuova istanza della classe Hashtable copiando gli elementi dal dizionario specificato in un nuovo oggetto Hashtable. Il nuovo oggetto Hashtable ha una capacità iniziale uguale al numero di elementi copiati e usa il fattore di carico predefinito e l'oggetto IEqualityComparer specificato.

Hashtable(IDictionary, IHashCodeProvider, IComparer)
Obsoleta.
Obsoleta.

Inizializza una nuova istanza della classe Hashtable copiando gli elementi dal dizionario specificato nel nuovo oggetto Hashtable. Il nuovo oggetto Hashtable ha una capacità iniziale uguale al numero di elementi copiati e usa il fattore di carico predefinito e il provider di codice hash e l'operatore di confronto specificati. Questa API è obsoleta. Per un'alternativa, vedere Hashtable(IDictionary, IEqualityComparer).

Hashtable(IDictionary, Single)

Inizializza una nuova istanza della classe Hashtable copiando gli elementi dal dizionario specificato nel nuovo oggetto Hashtable. Il nuovo oggetto Hashtable ha una capacità iniziale uguale al numero di elementi copiati e usa il fattore di carico specificato e il provider di codice hash e l'operatore di confronto predefiniti.

Hashtable(IDictionary, Single, IEqualityComparer)

Inizializza una nuova istanza della classe Hashtable copiando gli elementi dal dizionario specificato nel nuovo oggetto Hashtable. Il nuovo oggetto Hashtable ha una capacità iniziale uguale al numero di elementi copiati e usa il fattore di carico e l'oggetto IEqualityComparer specificati.

Hashtable(IDictionary, Single, IHashCodeProvider, IComparer)
Obsoleta.
Obsoleta.

Inizializza una nuova istanza della classe Hashtable copiando gli elementi dal dizionario specificato nel nuovo oggetto Hashtable. Il nuovo oggetto Hashtable ha una capacità iniziale uguale al numero di elementi copiati e usa il fattore di carico, il provider di codice hash e l'operatore di confronto specificati.

Hashtable(IEqualityComparer)

Inizializza una nuova istanza vuota della classe Hashtable usando la capacità iniziale e il fattore di carico predefiniti e l'oggetto IEqualityComparer specificato.

Hashtable(IHashCodeProvider, IComparer)
Obsoleta.
Obsoleta.

Inizializza una nuova istanza vuota della classe Hashtable usando la capacità iniziale e il fattore di carico predefiniti e il provider di codice hash e l'operatore di confronto specificati.

Hashtable(Int32)

Inizializza una nuova istanza vuota della classe Hashtable usando la capacità iniziale specificata e il fattore di carico, il provider di codice hash e l'operatore di confronto predefiniti.

Hashtable(Int32, IEqualityComparer)

Inizializza una nuova istanza vuota della classe Hashtable usando la capacità iniziale e l'interfaccia IEqualityComparer specificate e il fattore di carico predefinito.

Hashtable(Int32, IHashCodeProvider, IComparer)
Obsoleta.
Obsoleta.

Inizializza una nuova istanza vuota della classe Hashtable usando la capacità iniziale, il provider di codice hash e l'operatore di confronto specificati e il fattore di carico predefinito.

Hashtable(Int32, Single)

Inizializza una nuova istanza vuota della classe Hashtable usando la capacità iniziale e il fattore di carico specificati e il provider di codice hash e l'operatore di confronto predefiniti.

Hashtable(Int32, Single, IEqualityComparer)

Inizializza una nuova istanza vuota della classe Hashtable usando la capacità iniziale, il fattore di carico e l'oggetto IEqualityComparer specificati.

Hashtable(Int32, Single, IHashCodeProvider, IComparer)
Obsoleta.
Obsoleta.

Inizializza una nuova istanza vuota della classe Hashtable usando la capacità iniziale, il fattore di carico, il provider di codice hash e l'operatore di confronto specificati.

Hashtable(SerializationInfo, StreamingContext)

Inizializza una nuova istanza vuota della classe Hashtable che è serializzabile tramite gli oggetti SerializationInfo e StreamingContext specificati.

Proprietà

comparer
Obsoleta.
Obsoleta.

Ottiene o imposta l'oggetto IComparer da usare per Hashtable.

Count

Ottiene il numero di coppie chiave/valore contenute in Hashtable.

EqualityComparer

Ottiene l'interfaccia IEqualityComparer da usare per la classe Hashtable.

hcp
Obsoleta.
Obsoleta.

Ottiene o imposta l'oggetto dal quale verranno distribuiti i codici hash.

IsFixedSize

Ottiene un valore che indica se Hashtable ha dimensioni fisse.

IsReadOnly

Ottiene un valore che indica se Hashtable è di sola lettura.

IsSynchronized

Ottiene un valore che indica se l'accesso a Hashtable è sincronizzato (thread-safe).

Item[Object]

Ottiene o imposta il valore associato alla chiave specificata.

Keys

Ottiene un oggetto ICollection contenente le chiavi presenti nell'oggetto Hashtable.

SyncRoot

Ottiene un oggetto che può essere usato per sincronizzare l'accesso a Hashtable.

Values

Ottiene ICollection contenente i valori in Hashtable.

Metodi

Add(Object, Object)

Aggiunge un elemento con la chiave e il valore specificati al metodo Hashtable.

Clear()

Rimuove tutti gli elementi da Hashtable.

Clone()

Crea una copia superficiale di Hashtable.

Contains(Object)

Determina se l'oggetto Hashtable contiene una chiave specifica.

ContainsKey(Object)

Determina se l'oggetto Hashtable contiene una chiave specifica.

ContainsValue(Object)

Stabilisce se Hashtable contiene un valore specifico.

CopyTo(Array, Int32)

Copia gli elementi della classe Hashtable gli elementi della classe Array unidimensionale in corrispondenza dell'indice specificato.

Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.

(Ereditato da Object)
GetEnumerator()

Restituisce un oggetto IDictionaryEnumerator che esegue l'iterazione di Hashtable.

GetHash(Object)

Restituisce il codice hash per la chiave specificata.

GetHashCode()

Funge da funzione hash predefinita.

(Ereditato da Object)
GetObjectData(SerializationInfo, StreamingContext)

Implementa l'interfaccia ISerializable restituendo i dati necessari per serializzare la Hashtable.

GetType()

Ottiene l'oggetto Type dell'istanza corrente.

(Ereditato da Object)
KeyEquals(Object, Object)

Confronta un Object specifico con una chiave specifica nella Hashtable.

MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.

(Ereditato da Object)
OnDeserialization(Object)

Implementa l'interfaccia ISerializable e genera l'evento di deserializzazione quando la deserializzazione è completa.

Remove(Object)

Rimuove l'elemento con la chiave specificata da Hashtable.

Synchronized(Hashtable)

Restituisce un wrapper sincronizzato (thread-safe) per la classe Hashtable.

ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.

(Ereditato da Object)

Implementazioni dell'interfaccia esplicita

IEnumerable.GetEnumerator()

Restituisce un enumeratore che consente di eseguire l'iterazione di una raccolta.

Metodi di estensione

Cast<TResult>(IEnumerable)

Esegue il cast degli elementi di un oggetto IEnumerable nel tipo specificato.

OfType<TResult>(IEnumerable)

Filtra gli elementi di un oggetto IEnumerable in base a un tipo specificato.

AsParallel(IEnumerable)

Consente la parallelizzazione di una query.

AsQueryable(IEnumerable)

Converte un oggetto IEnumerable in un oggetto IQueryable.

Si applica a

Thread safety

Hashtable è thread-safe per l'uso da parte di più thread di lettura e di un singolo thread di scrittura. È thread-safe per l'uso multithread quando solo uno dei thread esegue operazioni di scrittura (aggiornamento), che consente operazioni di lettura senza blocco a condizione che i writer siano serializzati in Hashtable . Per supportare più writer, tutte le operazioni su devono essere eseguite tramite il wrapper restituito dal metodo , purché non siano presenti Hashtable Synchronized(Hashtable) thread che leggono l'oggetto Hashtable .

L'enumerazione tramite una raccolta non è intrinsecamente una procedura thread-safe. Anche se una raccolta è sincronizzata, è possibile che venga modificata da altri thread, con conseguente generazione di un'eccezione da parte dell'enumeratore. Per garantire la protezione dei thread durante l'enumerazione, è possibile bloccare la raccolta per l'intera enumerazione oppure intercettare le eccezioni determinate dalle modifiche apportate da altri thread.

Vedi anche