Hashtable Hashtable Hashtable Hashtable Class

Definizione

Rappresenta una raccolta di coppie chiave/valore organizzate in base al codice hash della chiave.Represents a collection of key/value pairs that are organized based on the hash code of the key.

public ref class Hashtable : ICloneable, System::Collections::IDictionary, System::Runtime::Serialization::IDeserializationCallback, System::Runtime::Serialization::ISerializable
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public class Hashtable : ICloneable, System.Collections.IDictionary, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable
type Hashtable = class
    interface IDictionary
    interface ISerializable
    interface IDeserializationCallback
    interface ICloneable
    interface ICollection
    interface IEnumerable
Public Class Hashtable
Implements ICloneable, IDeserializationCallback, IDictionary, ISerializable
Ereditarietà
HashtableHashtableHashtableHashtable
Derivato
Attributi
Implementazioni

Esempi

Nell'esempio seguente viene illustrato come creare, inizializzare ed eseguire varie funzioni per un Hashtable e come stampare i relativi valori e chiavi.The following example shows how to create, initialize and perform various functions to a Hashtable and how to print out its keys and values.

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
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.Each element is a key/value pair stored in a DictionaryEntry object. Non può essere una chiave null, ma può essere un valore.A key cannot be null, but a value can be.

Importante

Non è consigliabile usare il Hashtable classe per i nuovi sviluppi.We don't recommend that you use the Hashtable class for new development. È invece consigliabile usare il tipo generico Dictionary<TKey,TValue> classe.Instead, we recommend that you use the generic Dictionary<TKey,TValue> class. Per altre informazioni, vedere raccolte Non generiche non devono essere usate su GitHub.For more information, see Non-generic collections shouldn't be used on GitHub.

Gli oggetti utilizzati come chiavi da un Hashtable sono necessari per eseguire l'override la Object.GetHashCode metodo (o il IHashCodeProvider interfaccia) e il Object.Equals (metodo) (o il IComparer interfaccia).The objects used as keys by a Hashtable are required to override the Object.GetHashCode method (or the IHashCodeProvider interface) and the Object.Equals method (or the IComparer interface). L'implementazione di metodi e interfacce deve gestire distinzione maiuscole/minuscole allo stesso modo; in caso contrario, il Hashtable potrebbe comportarsi in modo non corretto.The implementation of both methods and interfaces must handle case sensitivity the same way; otherwise, the Hashtable might behave incorrectly. Ad esempio, quando si crea una Hashtable, è necessario usare il CaseInsensitiveHashCodeProvider classe (o qualsiasi tra maiuscole e minuscole IHashCodeProvider implementazione) con il CaseInsensitiveComparer classe (o qualsiasi tra maiuscole e minuscole IComparer implementazione).For example, when creating a Hashtable, you must use the CaseInsensitiveHashCodeProvider class (or any case-insensitive IHashCodeProvider implementation) with the CaseInsensitiveComparer class (or any case-insensitive IComparer implementation).

Inoltre, questi metodi devono produrre gli stessi risultati quando viene chiamato con gli stessi parametri, mentre la chiave esiste nella Hashtable.Furthermore, these methods must produce the same results when called with the same parameters while the key exists in the Hashtable. Un'alternativa consiste nell'usare un Hashtable costruttore con un IEqualityComparer parametro.An alternative is to use a Hashtable constructor with an IEqualityComparer parameter. Se l'uguaglianza delle chiavi è semplicemente l'uguaglianza di riferimento, l'implementazione ereditata di Object.GetHashCode e Object.Equals dovrebbe essere sufficiente.If key equality were simply reference equality, the inherited implementation of Object.GetHashCode and Object.Equals would suffice.

Gli oggetti principali devono essere non modificabili, purché vengono utilizzati come chiavi nel Hashtable.Key objects must be immutable as long as they are used as keys in the Hashtable.

Quando un elemento viene aggiunto al Hashtable, l'elemento viene inserito in un bucket in base al codice hash della chiave.When an element is added to the Hashtable, the element is placed into a bucket based on the hash code of the key. Le ricerche successive della chiave usano il codice hash della chiave per la ricerca in un solo determinato bucket, riducendo notevolmente il numero dei confronti chiave necessari per trovare un elemento.Subsequent lookups of the key use the hash code of the key to search in only one particular bucket, thus substantially reducing the number of key comparisons required to find an element.

Il fattore di caricamento di un Hashtable determina il rapporto massimo di elementi per bucket.The load factor of a Hashtable determines the maximum ratio of elements to buckets. Minore carico fattori causano tempi di tempi di ricerca medi aumentando tuttavia il consumo di memoria maggiore.Smaller load factors cause faster average lookup times at the cost of increased memory consumption. In genere, il fattore di carico predefinito pari a 1,0 fornisce il miglior rapporto tra velocità e dimensioni.The default load factor of 1.0 generally provides the best balance between speed and size. Un fattore di carico diversi può anche essere specificato quando il Hashtable viene creato.A different load factor can also be specified when the Hashtable is created.

Man mano che gli elementi vengono aggiunti a un Hashtable, il fattore di carico effettivo del Hashtable aumenta.As elements are added to a Hashtable, the actual load factor of the Hashtable increases. Quando il fattore di carico effettivo raggiunge il fattore di carico, il numero di bucket nel Hashtable viene automaticamente aumentato il numero primo più piccolo maggiore di due volte il numero corrente di Hashtable bucket.When the actual load factor reaches the specified load factor, the number of buckets in the Hashtable is automatically increased to the smallest prime number that is larger than twice the current number of Hashtable buckets.

Ogni oggetto nella chiave di Hashtable deve fornire la propria funzione hash, che è possibile accedere chiamando GetHash.Each key object in the Hashtable must provide its own hash function, which can be accessed by calling GetHash. Tuttavia, qualsiasi oggetto che implementa IHashCodeProvider può essere passato a un Hashtable costruttore e funzione hash viene utilizzato per tutti gli oggetti nella tabella.However, any object implementing IHashCodeProvider can be passed to a Hashtable constructor, and that hash function is used for all objects in the table.

La capacità di un Hashtable è il numero di elementi di Hashtable può contenere.The capacity of a Hashtable is the number of elements the Hashtable can hold. Man mano che gli elementi vengono aggiunti a un Hashtable, automaticamente aumentato la capacità in base alle necessità tramite la riallocazione.As elements are added to a Hashtable, the capacity is automatically increased as required through reallocation.

Solo in .NET framework: Per grandi Hashtable oggetti, è possibile aumentare la capacità massima a 2 miliardi di elementi in un sistema a 64 bit impostando il enabled attributo del <gcAllowVeryLargeObjects> elemento di configurazione true nel ambiente di runtime..NET Framework only: For very large Hashtable objects, you can increase the maximum capacity to 2 billion elements on a 64-bit system by setting the enabled attribute of the <gcAllowVeryLargeObjects> configuration element to true in the run-time environment.

Il foreach istruzione del linguaggio C# (For Each in Visual Basic) restituisce un oggetto del tipo degli elementi nella raccolta.The foreach statement of the C# language (For Each in Visual Basic) returns an object of the type of the elements in the collection. Poiché ogni elemento del Hashtable è una coppia chiave/valore, il tipo di elemento non è il tipo della chiave o il tipo del valore.Since each element of the Hashtable is a key/value pair, the element type is not the type of the key or the type of the value. Al contrario, il tipo di elemento è DictionaryEntry.Instead, the element type is DictionaryEntry. Ad esempio:For example:

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

Il foreach istruzione è un wrapper per l'enumeratore, che consente solo di leggere da, non la scrittura, la raccolta.The foreach statement is a wrapper around the enumerator, which only allows reading from, not writing to, the collection.

Poiché la serializzazione e deserializzazione di un enumeratore per un Hashtable può causare i riordinamento degli elementi, non è possibile continuare l'enumerazione senza chiamare il Reset (metodo).Because serializing and deserializing an enumerator for a Hashtable can cause the elements to become reordered, it is not possible to continue enumeration without calling the Reset method.

Nota

Poiché le chiavi possono essere ereditate e relativo comportamento modificato, non può essere garantirne l'univocità assoluta da confronti con i Equals (metodo).Because keys can be inherited and their behavior changed, their absolute uniqueness cannot be guaranteed by comparisons using the Equals method.

Costruttori

Hashtable() Hashtable() Hashtable() 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.Initializes a new, empty instance of the Hashtable class using the default initial capacity, load factor, hash code provider, and comparer.

Hashtable(IDictionary) Hashtable(IDictionary) Hashtable(IDictionary) Hashtable(IDictionary)

Inizializza una nuova istanza della classe Hashtable copiando gli elementi dal dizionario specificato nel nuovo oggetto Hashtable.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. 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.The new Hashtable object has an initial capacity equal to the number of elements copied, and uses the default load factor, hash code provider, and comparer.

Hashtable(IDictionary, IEqualityComparer) Hashtable(IDictionary, IEqualityComparer) Hashtable(IDictionary, IEqualityComparer) Hashtable(IDictionary, IEqualityComparer)

Inizializza una nuova istanza della classe Hashtable copiando gli elementi dal dizionario specificato in un nuovo oggetto Hashtable.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to a new Hashtable object. 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.The new Hashtable object has an initial capacity equal to the number of elements copied, and uses the default load factor and the specified IEqualityComparer object.

Hashtable(IDictionary, IHashCodeProvider, IComparer) Hashtable(IDictionary, IHashCodeProvider, IComparer) Hashtable(IDictionary, IHashCodeProvider, IComparer) Hashtable(IDictionary, IHashCodeProvider, IComparer)

Inizializza una nuova istanza della classe Hashtable copiando gli elementi dal dizionario specificato nel nuovo oggetto Hashtable.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. 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.The new Hashtable object has an initial capacity equal to the number of elements copied, and uses the default load factor, and the specified hash code provider and comparer. Questo API è obsoleto.This API is obsolete. Per un'alternativa, vedere Hashtable(IDictionary, IEqualityComparer).For an alternative, see Hashtable(IDictionary, IEqualityComparer).

Hashtable(IDictionary, Single) Hashtable(IDictionary, Single) Hashtable(IDictionary, Single) Hashtable(IDictionary, Single)

Inizializza una nuova istanza della classe Hashtable copiando gli elementi dal dizionario specificato nel nuovo oggetto Hashtable.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. 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.The new Hashtable object has an initial capacity equal to the number of elements copied, and uses the specified load factor, and the default hash code provider and comparer.

Hashtable(IDictionary, Single, IEqualityComparer) Hashtable(IDictionary, Single, IEqualityComparer) Hashtable(IDictionary, Single, IEqualityComparer) Hashtable(IDictionary, Single, IEqualityComparer)

Inizializza una nuova istanza della classe Hashtable copiando gli elementi dal dizionario specificato nel nuovo oggetto Hashtable.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. 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.The new Hashtable object has an initial capacity equal to the number of elements copied, and uses the specified load factor and IEqualityComparer object.

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

Inizializza una nuova istanza della classe Hashtable copiando gli elementi dal dizionario specificato nel nuovo oggetto Hashtable.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. 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.The new Hashtable object has an initial capacity equal to the number of elements copied, and uses the specified load factor, hash code provider, and comparer.

Hashtable(IEqualityComparer) Hashtable(IEqualityComparer) Hashtable(IEqualityComparer) 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.Initializes a new, empty instance of the Hashtable class using the default initial capacity and load factor, and the specified IEqualityComparer object.

Hashtable(IHashCodeProvider, IComparer) Hashtable(IHashCodeProvider, IComparer) Hashtable(IHashCodeProvider, IComparer) Hashtable(IHashCodeProvider, IComparer)

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.Initializes a new, empty instance of the Hashtable class using the default initial capacity and load factor, and the specified hash code provider and comparer.

Hashtable(Int32) Hashtable(Int32) Hashtable(Int32) 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.Initializes a new, empty instance of the Hashtable class using the specified initial capacity, and the default load factor, hash code provider, and comparer.

Hashtable(Int32, IEqualityComparer) Hashtable(Int32, IEqualityComparer) Hashtable(Int32, IEqualityComparer) 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.Initializes a new, empty instance of the Hashtable class using the specified initial capacity and IEqualityComparer, and the default load factor.

Hashtable(Int32, IHashCodeProvider, IComparer) Hashtable(Int32, IHashCodeProvider, IComparer) Hashtable(Int32, IHashCodeProvider, IComparer) Hashtable(Int32, IHashCodeProvider, IComparer)

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.Initializes a new, empty instance of the Hashtable class using the specified initial capacity, hash code provider, comparer, and the default load factor.

Hashtable(Int32, Single) Hashtable(Int32, Single) Hashtable(Int32, Single) 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.Initializes a new, empty instance of the Hashtable class using the specified initial capacity and load factor, and the default hash code provider and comparer.

Hashtable(Int32, Single, IEqualityComparer) Hashtable(Int32, Single, IEqualityComparer) Hashtable(Int32, Single, IEqualityComparer) 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.Initializes a new, empty instance of the Hashtable class using the specified initial capacity, load factor, and IEqualityComparer object.

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

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.Initializes a new, empty instance of the Hashtable class using the specified initial capacity, load factor, hash code provider, and comparer.

Hashtable(SerializationInfo, StreamingContext) Hashtable(SerializationInfo, StreamingContext) Hashtable(SerializationInfo, StreamingContext) Hashtable(SerializationInfo, StreamingContext)

Inizializza una nuova istanza vuota della classe Hashtable che è serializzabile tramite gli oggetti SerializationInfo e StreamingContext specificati.Initializes a new, empty instance of the Hashtable class that is serializable using the specified SerializationInfo and StreamingContext objects.

Proprietà

comparer comparer comparer comparer

Ottiene o imposta l'oggetto IComparer da usare per Hashtable.Gets or sets the IComparer to use for the Hashtable.

Count Count Count Count

Ottiene il numero di coppie chiave/valore contenute in Hashtable.Gets the number of key/value pairs contained in the Hashtable.

EqualityComparer EqualityComparer EqualityComparer EqualityComparer

Ottiene l'interfaccia IEqualityComparer da usare per la classe Hashtable.Gets the IEqualityComparer to use for the Hashtable.

hcp hcp hcp hcp

Ottiene o imposta l'oggetto dal quale verranno distribuiti i codici hash.Gets or sets the object that can dispense hash codes.

IsFixedSize IsFixedSize IsFixedSize IsFixedSize

Ottiene un valore che indica se Hashtable ha dimensioni fisse.Gets a value indicating whether the Hashtable has a fixed size.

IsReadOnly IsReadOnly IsReadOnly IsReadOnly

Ottiene un valore che indica se Hashtable è di sola lettura.Gets a value indicating whether the Hashtable is read-only.

IsSynchronized IsSynchronized IsSynchronized IsSynchronized

Ottiene un valore che indica se l'accesso a Hashtable è sincronizzato (thread-safe).Gets a value indicating whether access to the Hashtable is synchronized (thread safe).

Item[Object] Item[Object] Item[Object] Item[Object]

Ottiene o imposta il valore associato alla chiave specificata.Gets or sets the value associated with the specified key.

Keys Keys Keys Keys

Ottiene un oggetto ICollection contenente le chiavi presenti nell'oggetto Hashtable.Gets an ICollection containing the keys in the Hashtable.

SyncRoot SyncRoot SyncRoot SyncRoot

Ottiene un oggetto che può essere usato per sincronizzare l'accesso a Hashtable.Gets an object that can be used to synchronize access to the Hashtable.

Values Values Values Values

Ottiene ICollection contenente i valori in Hashtable.Gets an ICollection containing the values in the Hashtable.

Metodi

Add(Object, Object) Add(Object, Object) Add(Object, Object) Add(Object, Object)

Aggiunge un elemento con la chiave e il valore specificati al metodo Hashtable.Adds an element with the specified key and value into the Hashtable.

Clear() Clear() Clear() Clear()

Rimuove tutti gli elementi da Hashtable.Removes all elements from the Hashtable.

Clone() Clone() Clone() Clone()

Crea una copia superficiale di Hashtable.Creates a shallow copy of the Hashtable.

Contains(Object) Contains(Object) Contains(Object) Contains(Object)

Determina se l'oggetto Hashtable contiene una chiave specifica.Determines whether the Hashtable contains a specific key.

ContainsKey(Object) ContainsKey(Object) ContainsKey(Object) ContainsKey(Object)

Determina se l'oggetto Hashtable contiene una chiave specifica.Determines whether the Hashtable contains a specific key.

ContainsValue(Object) ContainsValue(Object) ContainsValue(Object) ContainsValue(Object)

Stabilisce se Hashtable contiene un valore specifico.Determines whether the Hashtable contains a specific value.

CopyTo(Array, Int32) CopyTo(Array, Int32) CopyTo(Array, Int32) CopyTo(Array, Int32)

Copia gli elementi della classe Hashtable gli elementi della classe Array unidimensionale in corrispondenza dell'indice specificato.Copies the Hashtable elements to a one-dimensional Array instance at the specified index.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Determina se l'oggetto specificato è uguale all'oggetto corrente.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetEnumerator() GetEnumerator() GetEnumerator() GetEnumerator()

Restituisce un oggetto IDictionaryEnumerator che esegue l'iterazione di Hashtable.Returns an IDictionaryEnumerator that iterates through the Hashtable.

GetHash(Object) GetHash(Object) GetHash(Object) GetHash(Object)

Restituisce il codice hash per la chiave specificata.Returns the hash code for the specified key.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Funge da funzione hash predefinita.Serves as the default hash function.

(Inherited from Object)
GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext)

Implementa l'interfaccia ISerializable restituendo i dati necessari per serializzare la Hashtable.Implements the ISerializable interface and returns the data needed to serialize the Hashtable.

GetType() GetType() GetType() GetType()

Ottiene l'oggetto Type dell'istanza corrente.Gets the Type of the current instance.

(Inherited from Object)
KeyEquals(Object, Object) KeyEquals(Object, Object) KeyEquals(Object, Object) KeyEquals(Object, Object)

Confronta un Object specifico con una chiave specifica nella Hashtable.Compares a specific Object with a specific key in the Hashtable.

MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crea una copia superficiale dell'oggetto Object corrente.Creates a shallow copy of the current Object.

(Inherited from Object)
OnDeserialization(Object) OnDeserialization(Object) OnDeserialization(Object) OnDeserialization(Object)

Implementa l'interfaccia ISerializable e genera l'evento di deserializzazione quando la deserializzazione è completa.Implements the ISerializable interface and raises the deserialization event when the deserialization is complete.

Remove(Object) Remove(Object) Remove(Object) Remove(Object)

Rimuove l'elemento con la chiave specificata da Hashtable.Removes the element with the specified key from the Hashtable.

Synchronized(Hashtable) Synchronized(Hashtable) Synchronized(Hashtable) Synchronized(Hashtable)

Restituisce un wrapper sincronizzato (thread-safe) per la classe Hashtable.Returns a synchronized (thread-safe) wrapper for the Hashtable.

ToString() ToString() ToString() ToString()

Restituisce una stringa che rappresenta l'oggetto corrente.Returns a string that represents the current object.

(Inherited from Object)

Implementazioni dell'interfaccia esplicita

IEnumerable.GetEnumerator() IEnumerable.GetEnumerator() IEnumerable.GetEnumerator() IEnumerable.GetEnumerator()

Restituisce un enumeratore che consente di eseguire l'iterazione di una raccolta.Returns an enumerator that iterates through a collection.

Extension Methods

Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable)

Esegue il cast di elementi di un IEnumerable nel tipo specificato.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable)

Filtra gli elementi di un IEnumerable basato su un tipo specificato.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable)

Consente la parallelizzazione di una query.Enables parallelization of a query.

AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable)

Converte un' IEnumerable a un IQueryable.Converts an IEnumerable to an IQueryable.

Si applica a

Thread safety

Hashtable è thread-safe per l'uso da più thread di lettura e un singolo thread di scrittura.Hashtable is thread safe for use by multiple reader threads and a single writing thread. È thread-safe per utilizzare multi-thread quando solo uno dei thread di eseguire operazioni di scrittura (aggiornamenti), che consente di letture senza blocco purché vengano serializzati i writer per il Hashtable.It is thread safe for multi-thread use when only one of the threads perform write (update) operations, which allows for lock-free reads provided that the writers are serialized to the Hashtable. Per supportare tutte le operazioni di più processi di scrittura nel Hashtable deve essere eseguita tramite il wrapper restituito dal Synchronized(Hashtable) metodo, fornito che non sono disponibili thread di lettura di Hashtable oggetto.To support multiple writers all operations on the Hashtable must be done through the wrapper returned by the Synchronized(Hashtable) method, provided that there are no threads reading the Hashtable object.

Enumerare una raccolta di per sé non è una procedura thread-safe.Enumerating through a collection is intrinsically not a thread safe procedure. Anche se una raccolta è sincronizzata, è possibile che venga modificata da altri thread, con conseguente generazione di un'eccezione da parte dell'enumeratore.Even when a collection is synchronized, other threads can still modify the collection, which causes the enumerator to throw an exception. 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.To guarantee thread safety during enumeration, you can either lock the collection during the entire enumeration or catch the exceptions resulting from changes made by other threads.

Vedi anche