Hashtable Hashtable Hashtable Hashtable Class

Definition

Stellt eine Auflistung von Schlüssel-Wert-Paaren dar, die auf Grundlage des Hashcodes des Schlüssels geordnet sind.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
Vererbung
HashtableHashtableHashtableHashtable
Abgeleitet
Attribute
Implementiert

Beispiele

Im folgenden Beispiel wird gezeigt, wie verschiedene Funktionen von Hashtable erstellt, initialisiert und durchgeführt werden und wie die Schlüssel und Werte gedruckt werden.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.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
#>

Hinweise

Jedes Element ist ein Schlüssel-Wert-Paar, das DictionaryEntry in einem-Objekt gespeichert ist.Each element is a key/value pair stored in a DictionaryEntry object. Ein Schlüssel kann nicht nullsein, aber ein Wert kann sein.A key cannot be null, but a value can be.

Wichtig

Es wird nicht empfohlen, die- Hashtable Klasse für die neue Entwicklung zu verwenden.We don't recommend that you use the Hashtable class for new development. Stattdessen wird die Verwendung der generischen Dictionary<TKey,TValue> -Klasse empfohlen.Instead, we recommend that you use the generic Dictionary<TKey,TValue> class. Weitere Informationen finden Sie unter nicht generische Auflistungen sollten nicht auf GitHub verwendet werden.For more information, see Non-generic collections shouldn't be used on GitHub.

Die Objekte, die von Hashtable einem als Schlüssel verwendet werden, müssen die Object.GetHashCode -Methode ( IHashCodeProvider oder die-Schnitt Object.Equals Stelle) und die IComparer -Methode (oder die-Schnittstelle) überschreiben.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). Die Implementierung von Methoden und Schnittstellen muss die Groß-/Kleinschreibung auf die gleiche Weise behandeln. Andernfalls verhält sich Hashtable das möglicherweise falsch.The implementation of both methods and interfaces must handle case sensitivity the same way; otherwise, the Hashtable might behave incorrectly. Wenn Sie z. b. Hashtableein erstellen, müssen Sie CaseInsensitiveHashCodeProvider die-Klasse ( IHashCodeProvider oder eine beliebige Implementierung ohne Berücksichtigung IComparer der CaseInsensitiveComparer Groß-/Kleinschreibung) mit der-Klasse (oder mit einer anderen Implementierung ohne Berücksichtigung der groß-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).

Außerdem müssen diese Methoden dieselben Ergebnisse erzielen, wenn Sie mit denselben Parametern aufgerufen werden, während der Schlüssel in Hashtablevorhanden ist.Furthermore, these methods must produce the same results when called with the same parameters while the key exists in the Hashtable. Eine Alternative besteht darin, einen Hashtable Konstruktor mit einem IEqualityComparer -Parameter zu verwenden.An alternative is to use a Hashtable constructor with an IEqualityComparer parameter. Wenn die Schlüssel Gleichheit einfach Verweis Gleichheit wäre, wäre die geerbte Object.Equals Implementierung von Object.GetHashCode und ausreichend.If key equality were simply reference equality, the inherited implementation of Object.GetHashCode and Object.Equals would suffice.

Schlüssel Objekte müssen unveränderlich sein, solange Sie als Schlüssel in der Hashtableverwendet werden.Key objects must be immutable as long as they are used as keys in the Hashtable.

Wenn ein Element hinzugefügt Hashtablewird, wird das Element auf Grundlage des Hashcodes des Schlüssels in einen Bucket eingefügt.When an element is added to the Hashtable, the element is placed into a bucket based on the hash code of the key. Nachfolgende Suchvorgänge des Schlüssels verwenden den Hashcode des Schlüssels, um nur in einem bestimmten Bucket zu suchen. Dadurch wird die Anzahl der Schlüssel Vergleiche, die für die Suche nach einem Element erforderlich sind, erheblich reduziert.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.

Der Ladefaktor Hashtable eines bestimmt das maximale Verhältnis von Elementen zu Bucket.The load factor of a Hashtable determines the maximum ratio of elements to buckets. Kleinere Auslastungs Faktoren verursachen schnellere durchschnittliche Suchzeiten zu den Kosten für eine höhere Arbeitsspeicher Nutzung.Smaller load factors cause faster average lookup times at the cost of increased memory consumption. Der Standard Lastfaktor 1,0 bietet im Allgemeinen das beste Gleichgewicht zwischen Geschwindigkeit und Größe.The default load factor of 1.0 generally provides the best balance between speed and size. Ein anderer Ladefaktor kann auch angegeben werden, wenn Hashtable der erstellt wird.A different load factor can also be specified when the Hashtable is created.

Beim Hinzufügen Hashtable von Elementen zu Hashtableeinem erhöht sich der tatsächliche Ladefaktor des.As elements are added to a Hashtable, the actual load factor of the Hashtable increases. Wenn der tatsächliche Lastfaktor den angegebenen Lastfaktor erreicht, Hashtable wird die Anzahl der bucketwerte in automatisch auf die kleinste Primzahl vergrößert, die größer als die doppelte Anzahl von Hashtable Buchern ist.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.

Jedes Schlüsselobjekt in der Hashtable muss eine eigene Hash Funktion bereitstellen, auf die durch Aufrufen GetHashvon zugegriffen werden kann.Each key object in the Hashtable must provide its own hash function, which can be accessed by calling GetHash. Allerdings kann jedes Objekt IHashCodeProvider , das implementiert, an Hashtable einen Konstruktor übergeben werden, und diese Hash Funktion wird für alle Objekte in der Tabelle verwendet.However, any object implementing IHashCodeProvider can be passed to a Hashtable constructor, and that hash function is used for all objects in the table.

Die Kapazität Hashtable eines ist die Anzahl der Elemente, die Hashtable in der enthalten sein können.The capacity of a Hashtable is the number of elements the Hashtable can hold. Wenn Elemente zu einem Hashtablehinzugefügt werden, wird die Kapazität bei Bedarf durch erneute Zuweisung automatisch erhöht.As elements are added to a Hashtable, the capacity is automatically increased as required through reallocation.

Nur .NET Framework: Bei sehr großen Hashtable Objekten können Sie die maximale Kapazität auf 2 Milliarden Elemente in einem 64-Bit-System erhöhen, indem Sie enabled das-Attribut <gcAllowVeryLargeObjects> des-Konfigurations true Elements in der Laufzeitumgebung auf festlegen..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.

Die foreach -Anweisung der C# -SpracheFor Each (in Visual Basic) gibt ein Objekt des Typs der Elemente in der Auflistung zurück.The foreach statement of the C# language (For Each in Visual Basic) returns an object of the type of the elements in the collection. Da jedes Element von Hashtable ein Schlüssel-Wert-Paar ist, ist der Elementtyp nicht der Typ des Schlüssels oder der Typ des Werts.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. Stattdessen ist DictionaryEntryder Elementtyp.Instead, the element type is DictionaryEntry. Beispiel:For example:

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

Bei foreach der-Anweisung handelt es sich um einen Wrapper um den Enumerator, der nur das Lesen von, das Schreiben in die Auflistung ermöglicht.The foreach statement is a wrapper around the enumerator, which only allows reading from, not writing to, the collection.

Da das Serialisieren und Deserialisieren eines Enumerators für Hashtable einen bewirken kann, dass die Elemente neu angeordnet werden, kann die Enumeration nicht fortgesetzt werden, Reset ohne die-Methode aufzurufende.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.

Hinweis

Da Schlüssel geerbt werden können und ihr Verhalten geändert wird, kann die absolute Eindeutigkeit nicht durch Vergleiche mithilfe Equals der-Methode gewährleistet werden.Because keys can be inherited and their behavior changed, their absolute uniqueness cannot be guaranteed by comparisons using the Equals method.

Konstruktoren

Hashtable() Hashtable() Hashtable() Hashtable()

Initialisiert eine neue leere Instanz der Hashtable-Klasse unter Verwendung der anfänglichen Standardkapazität, des Standardlastfaktors, Hashcode-Standardanbieters und des Standardcomparers.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)

Initialisiert eine neue Instanz der Hashtable-Klasse durch Kopieren der Elemente aus dem angegebenen Wörterbuch in das neue Hashtable-Objekt.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. Das neue Hashtable-Objekt besitzt eine Anfangskapazität, die mit der Anzahl der kopierten Elemente identisch ist, und verwendet den Standardlastfaktor, den Hashcode-Standardanbieter und den Standardcomparer.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)

Initialisiert eine neue Instanz der Hashtable-Klasse durch Kopieren der Elemente aus dem angegebenen Wörterbuch in ein neues Hashtable-Objekt.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to a new Hashtable object. Das neue Hashtable-Objekt besitzt eine Anfangskapazität, die mit der Anzahl der kopierten Elemente identisch ist, und verwendet den Standardlastfaktor sowie das angegebene IEqualityComparer-Objekt.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)

Initialisiert eine neue Instanz der Hashtable-Klasse durch Kopieren der Elemente aus dem angegebenen Wörterbuch in das neue Hashtable-Objekt.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. Das neue Hashtable-Objekt besitzt eine Anfangskapazität, die mit der Anzahl der kopierten Elemente identisch ist, und verwendet den Standardlastfaktor sowie den angegebenen Hashcodeanbieter und den angegebenen Comparer.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. Diese API ist veraltet.This API is obsolete. Eine Alternative finden Sie unter Hashtable(IDictionary, IEqualityComparer).For an alternative, see Hashtable(IDictionary, IEqualityComparer).

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

Initialisiert eine neue Instanz der Hashtable-Klasse durch Kopieren der Elemente aus dem angegebenen Wörterbuch in das neue Hashtable-Objekt.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. Das neue Hashtable-Objekt besitzt eine Anfangskapazität, die mit der Anzahl der kopierten Elemente identisch ist, und verwendet den angegebenen Lastfaktor sowie den Hashcode-Standardanbieter und den Standardcomparer.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)

Initialisiert eine neue Instanz der Hashtable-Klasse durch Kopieren der Elemente aus dem angegebenen Wörterbuch in das neue Hashtable-Objekt.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. Das neue Hashtable-Objekt besitzt eine Anfangskapazität, die mit der Anzahl der kopierten Elemente identisch ist, und verwendet den angegebenen Lastfaktor und das angegebene IEqualityComparer-Objekt.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)

Initialisiert eine neue Instanz der Hashtable-Klasse durch Kopieren der Elemente aus dem angegebenen Wörterbuch in das neue Hashtable-Objekt.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. Das neue Hashtable-Objekt besitzt eine Anfangskapazität, die mit der Anzahl der kopierten Elemente identisch ist, und verwendet den angegebenen Lastfaktor, den angegebenen Hashcodeanbieter und den angegebenen Comparer.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)

Initialisiert eine neue leere Instanz der Hashtable-Klasse unter Verwendung der anfänglichen Standardkapazität, des Standardlastfaktors und des angegebenen IEqualityComparer-Objekts.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)

Initialisiert eine neue leere Instanz der Hashtable-Klasse unter Verwendung der anfänglichen Standardkapazität, des Standardlastfaktors, des angegebenen Hashcodeanbieters und des angegebenen Comparers.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)

Initialisiert eine neue leere Instanz der Hashtable-Klasse unter Verwendung der angegebenen Anfangskapazität, des Standardlastfaktors, des Hashcode-Standardanbieters und des Standardcomparers.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)

Initialisiert eine neue leere Instanz der Hashtable-Klasse unter Verwendung der angegebenen Anfangskapazität und des angegebenen IEqualityComparer sowie des Standardlastfaktors.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)

Initialisiert eine neue leere Instanz der Hashtable-Klasse unter Verwendung der angegebenen Anfangskapazität, des angegebenen Hashcodeanbieters, des angegebenen Comparers und des Standardlastfaktors.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)

Initialisiert eine neue leere Instanz der Hashtable-Klasse unter Verwendung der angegebenen Anfangskapazität und des Lastfaktors sowie des Hashcode-Standardanbieter und des angegebenen Comparers.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)

Initialisiert eine neue leere Instanz der Hashtable-Klasse unter Verwendung der angegebenen Anfangskapazität, des angegebenen Lastfaktors und des angegebenen IEqualityComparer-Objekts.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)

Initialisiert eine neue leere Instanz der Hashtable-Klasse unter Verwendung der angegebenen Anfangskapazität, des angegebenen Lastfaktors, des angegebenen Hashcode-Anbieters und des angegebenen Comparers.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)

Initialisiert eine neue leere Instanz der Hashtable-Klasse, die serialisierbar ist, wobei die angegebenen SerializationInfo-Objekte und die angegebenen StreamingContext-Objekte verwendet werden.Initializes a new, empty instance of the Hashtable class that is serializable using the specified SerializationInfo and StreamingContext objects.

Eigenschaften

comparer comparer comparer comparer

Ruft den für die IComparer zu verwendenden Hashtable ab oder legt diesen fest.Gets or sets the IComparer to use for the Hashtable.

Count Count Count Count

Ruft die Anzahl der Schlüssel-Wert-Paare im Hashtable ab.Gets the number of key/value pairs contained in the Hashtable.

EqualityComparer EqualityComparer EqualityComparer EqualityComparer

Ruft den für die IEqualityComparer zu verwendenden Hashtable ab.Gets the IEqualityComparer to use for the Hashtable.

hcp hcp hcp hcp

Ruft das Objekt ab, das Hashcodes verteilen kann, oder legt dieses fest.Gets or sets the object that can dispense hash codes.

IsFixedSize IsFixedSize IsFixedSize IsFixedSize

Ruft einen Wert ab, der angibt, ob das Hashtable eine feste Größe aufweist.Gets a value indicating whether the Hashtable has a fixed size.

IsReadOnly IsReadOnly IsReadOnly IsReadOnly

Ruft einen Wert ab, der angibt, ob das Hashtable schreibgeschützt ist.Gets a value indicating whether the Hashtable is read-only.

IsSynchronized IsSynchronized IsSynchronized IsSynchronized

Ruft einen Wert ab, der angibt, ob der Zugriff auf die Hashtable synchronisiert (threadsicher) ist.Gets a value indicating whether access to the Hashtable is synchronized (thread safe).

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

Ruft den Wert ab, der dem angegebenen Schlüssel zugeordnet ist, oder legt diesen fest.Gets or sets the value associated with the specified key.

Keys Keys Keys Keys

Ruft eine ICollection ab, die die Schlüssel im Hashtable enthält.Gets an ICollection containing the keys in the Hashtable.

SyncRoot SyncRoot SyncRoot SyncRoot

Ruft ein Objekt ab, mit dem der Zugriff auf Hashtable synchronisiert werden kann.Gets an object that can be used to synchronize access to the Hashtable.

Values Values Values Values

Ruft eine ICollection ab, die die Werte im Hashtable enthält.Gets an ICollection containing the values in the Hashtable.

Methoden

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

Fügt dem Hashtable ein Element mit dem angegebenen Schlüssel und Wert hinzu.Adds an element with the specified key and value into the Hashtable.

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

Entfernt alle Elemente aus der Hashtable.Removes all elements from the Hashtable.

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

Erstellt eine flache Kopie von Hashtable.Creates a shallow copy of the Hashtable.

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

Stellt fest, ob der Hashtable einen bestimmten Schlüssel enthält.Determines whether the Hashtable contains a specific key.

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

Stellt fest, ob der Hashtable einen bestimmten Schlüssel enthält.Determines whether the Hashtable contains a specific key.

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

Ermittelt, ob die Hashtable einen bestimmten Wert enthält.Determines whether the Hashtable contains a specific value.

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

Kopiert die Hashtable-Elemente an den angegebenen Index in einer eindimensionalen Array-Instanz.Copies the Hashtable elements to a one-dimensional Array instance at the specified index.

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

Bestimmt, ob das angegebene Objekt mit dem aktuellen Objekt identisch ist.Determines whether the specified object is equal to the current object.

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

Gibt einen IDictionaryEnumerator zurück, der das Hashtable durchläuft.Returns an IDictionaryEnumerator that iterates through the Hashtable.

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

Gibt den Hashcode für den angegebenen Schlüssel zurück.Returns the hash code for the specified key.

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

Fungiert als Standardhashfunktion.Serves as the default hash function.

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

Implementiert die ISerializable-Schnittstelle und gibt die zum Serialisieren der Hashtable erforderlichen Daten zurück.Implements the ISerializable interface and returns the data needed to serialize the Hashtable.

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

Ruft den Type der aktuellen Instanz ab.Gets the Type of the current instance.

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

Vergleicht ein bestimmtes Object mit einem bestimmten Schlüssel in Hashtable.Compares a specific Object with a specific key in the Hashtable.

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

Erstellt eine flache Kopie des aktuellen Object.Creates a shallow copy of the current Object.

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

Implementiert die ISerializable-Schnittstelle und löst das Deserialisierungsereignis aus, sobald die Deserialisierung abgeschlossen ist.Implements the ISerializable interface and raises the deserialization event when the deserialization is complete.

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

Entfernt das Element mit dem angegebenen Schlüssel aus dem Hashtable.Removes the element with the specified key from the Hashtable.

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

Gibt einen synchronisierten (threadsicheren) Wrapper für die Hashtable zurück.Returns a synchronized (thread-safe) wrapper for the Hashtable.

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

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.Returns a string that represents the current object.

(Inherited from Object)

Explizite Schnittstellenimplementierungen

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

Gibt einen Enumerator zurück, der eine Auflistung durchläuft.Returns an enumerator that iterates through a collection.

Erweiterungsmethoden

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

Wandelt die Elemente eines IEnumerable in den angegebenen Typ umCasts the elements of an IEnumerable to the specified type.

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

Filtert die Elemente eines IEnumerable anhand eines angegebenen TypsFilters the elements of an IEnumerable based on a specified type.

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

Ermöglicht die Parallelisierung einer Abfrage.Enables parallelization of a query.

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

Konvertiert einen IEnumerable in einen IQueryable.Converts an IEnumerable to an IQueryable.

Gilt für:

Threadsicherheit

Hashtableist Thread sicher für die Verwendung durch mehrere Lesethreads und einen einzelnen Schreib Thread.Hashtable is thread safe for use by multiple reader threads and a single writing thread. Es ist Thread sicher für die Verwendung von mehreren Threads, wenn nur einer der Threads Schreibvorgänge (Update) ausführt, die Sperr freie Lesevorgänge ermöglichen, vorausgesetzt, dass die Writer in die Hashtableserialisiert werden.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. Zur Unterstützung mehrerer Writer müssen alle Vorgänge Hashtable auf dem durch den von der Synchronized(Hashtable) -Methode zurückgegebenen Wrapper erfolgen, vorausgesetzt, es sind keine Hashtable Threads vorhanden, die das Objekt lesen.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.

Das Auflisten durch eine Auflistung ist intrinsisch keine Thread sichere Prozedur.Enumerating through a collection is intrinsically not a thread safe procedure. Selbst wenn eine Auflistung synchronisiert wird, besteht die Möglichkeit, dass andere Threads sie ändern. Dies führt dazu, dass der Enumerator eine Ausnahme auslöst.Even when a collection is synchronized, other threads can still modify the collection, which causes the enumerator to throw an exception. Um während der Enumeration Threadsicherheit zu gewährleisten, können Sie entweder die Auflistung während der gesamten Enumeration sperren oder die Ausnahmen, die aus von anderen Threads stammenden Änderungen resultieren, abfangen.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.

Siehe auch