Freigeben über


Hashtable Klasse

Definition

Stellt eine Auflistung von Schlüssel-Wert-Paaren dar, die auf Grundlage des Hashcodes des Schlüssels geordnet sind.

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
Public Class Hashtable
Implements IDictionary
Public Class Hashtable
Implements ICloneable, IDeserializationCallback, IDictionary, ISerializable
Vererbung
Hashtable
Abgeleitet
Attribute
Implementiert

Beispiele

Im folgenden Beispiel wird gezeigt, wie Sie verschiedene Funktionen für ein Hashtable erstellen, initialisieren und ausführen und wie die Schlüssel und Werte gedruckt werden.

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 in einem DictionaryEntry Objekt gespeichert ist. Ein Schlüssel kann nicht sein null, aber ein Wert kann sein.

Wichtig

Es wird nicht empfohlen, die Hashtable -Klasse für neue Entwicklungen zu verwenden. Stattdessen wird empfohlen, die generische Dictionary<TKey,TValue> Klasse zu verwenden. Weitere Informationen finden Sie unter Nicht generische Sammlungen sollten nicht auf GitHub verwendet werden.

Die von einem Hashtable als Schlüssel verwendeten Objekte sind erforderlich, um die Object.GetHashCode -Methode (oder die IHashCodeProvider -Schnittstelle) und die Object.Equals -Methode (oder die IComparer -Schnittstelle) zu überschreiben. Die Implementierung von Methoden und Schnittstellen muss die Groß-/Kleinschreibung auf die gleiche Weise behandeln. andernfalls verhält sich die Hashtable möglicherweise falsch. Beim Erstellen eines Hashtablemüssen Sie beispielsweise die CaseInsensitiveHashCodeProvider -Klasse (oder eine beliebige Implementierung ohne Beachtung der Groß-/Kleinschreibung IHashCodeProvider ) mit der -Klasse (oder jeder Implementierung ohne Beachtung der CaseInsensitiveComparer Groß-/Kleinschreibung IComparer ) verwenden.

Darüber hinaus müssen diese Methoden die gleichen Ergebnisse erzeugen, wenn sie mit den gleichen Parametern aufgerufen werden, während der Schlüssel in vorhanden Hashtableist. Eine Alternative besteht darin, einen Hashtable Konstruktor mit einem IEqualityComparer Parameter zu verwenden. Wenn Schlüsselgleichheit lediglich Referenzgleichheit wäre, würde die geerbte Implementierung von Object.GetHashCode und Object.Equals ausreichen.

Schlüsselobjekte müssen unveränderlich sein, solange sie als Schlüssel in verwendet Hashtablewerden.

Wenn ein Element hinzugefügt Hashtablewird, wird das -Element basierend auf dem Hashcode des Schlüssels in einem Bucket platziert. Nachfolgende Nachschlagevorgänge des Schlüssels verwenden den Hashcode des Schlüssels, um nur in einem bestimmten Bucket zu suchen, wodurch die Anzahl der Schlüsselvergleiche erheblich reduziert wird, die zum Suchen eines Elements erforderlich sind.

Der Auslastungsfaktor eines Hashtable bestimmt das maximale Verhältnis von Elementen zu Buckets. Kleinere Auslastungsfaktoren führen zu schnelleren durchschnittlichen Nachschlagezeiten bei erhöhter Arbeitsspeicherauslastung. Der Standardladefaktor 1,0 bietet im Allgemeinen das beste Gleichgewicht zwischen Geschwindigkeit und Größe. Beim Erstellen von kann auch ein Hashtable anderer Auslastungsfaktor angegeben werden.

Wenn Elemente zu einem Hashtablehinzugefügt werden, erhöht sich der tatsächliche Auslastungsfaktor des Hashtable . Wenn der tatsächliche Auslastungsfaktor den angegebenen Ladefaktor erreicht, wird die Anzahl der Buckets in der Hashtable automatisch auf die kleinste Primzahl erhöht, die größer als das Doppelte der aktuellen Anzahl von Hashtable Buckets ist.

Jedes Schlüsselobjekt in Hashtable muss eine eigene Hashfunktion bereitstellen, auf die durch Aufrufen GetHashvon zugegriffen werden kann. Jedes implementierende IHashCodeProvider Objekt kann jedoch an einen Hashtable Konstruktor übergeben werden, und diese Hashfunktion wird für alle Objekte in der Tabelle verwendet.

Die Kapazität eines Hashtable ist die Anzahl der Elemente, die enthalten Hashtable können. Wenn Elemente zu einem Hashtablehinzugefügt werden, wird die Kapazität automatisch bei Bedarf durch Neuzuweisung erhöht.

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

Die foreach -Anweisung der C#-Sprache (For Each in Visual Basic) gibt ein Objekt vom Typ der Elemente in der Auflistung zurück. 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. Stattdessen ist DictionaryEntryder Elementtyp . Beispiel:

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

Die foreach -Anweisung ist ein Wrapper um den Enumerator, der nur das Lesen und nicht das Schreiben in die Auflistung zulässt.

Da das Serialisieren und Deserialisieren eines Enumerators für einen Hashtable dazu führen kann, dass die Elemente neu angeordnet werden, ist es nicht möglich, die Enumeration fortzusetzen, ohne die Reset -Methode aufzurufen.

Hinweis

Da Schlüssel vererbt und ihr Verhalten geändert werden kann, kann ihre absolute Eindeutigkeit nicht durch Vergleiche mit der Equals -Methode garantiert werden.

Konstruktoren

Hashtable()

Initialisiert eine neue leere Instanz der Hashtable-Klasse unter Verwendung der anfänglichen Standardkapazität, des Standardlastfaktors, Hashcode-Standardanbieters und des Standardcomparers.

Hashtable(IDictionary)

Initialisiert eine neue Instanz der Hashtable-Klasse durch Kopieren der Elemente aus dem angegebenen Wörterbuch in das neue Hashtable-Objekt. 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.

Hashtable(IDictionary, IEqualityComparer)

Initialisiert eine neue Instanz der Hashtable-Klasse durch Kopieren der Elemente aus dem angegebenen Wörterbuch in ein neues Hashtable-Objekt. 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.

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

Initialisiert eine neue Instanz der Hashtable-Klasse durch Kopieren der Elemente aus dem angegebenen Wörterbuch in das neue Hashtable-Objekt. 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. Diese API ist veraltet. Eine Alternative finden Sie unter Hashtable(IDictionary, IEqualityComparer).

Hashtable(IDictionary, Single)

Initialisiert eine neue Instanz der Hashtable-Klasse durch Kopieren der Elemente aus dem angegebenen Wörterbuch in das neue Hashtable-Objekt. 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.

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

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

Initialisiert eine neue Instanz der Hashtable-Klasse durch Kopieren der Elemente aus dem angegebenen Wörterbuch in das neue Hashtable-Objekt. 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.

Hashtable(IEqualityComparer)

Initialisiert eine neue leere Instanz der Hashtable-Klasse unter Verwendung der anfänglichen Standardkapazität, des Standardlastfaktors und des angegebenen IEqualityComparer-Objekts.

Hashtable(IHashCodeProvider, IComparer)
Veraltet.
Veraltet.
Veraltet.

Initialisiert eine neue leere Instanz der Hashtable-Klasse unter Verwendung der anfänglichen Standardkapazität, des Standardlastfaktors, des angegebenen Hashcodeanbieters und des angegebenen Comparers.

Hashtable(Int32)

Initialisiert eine neue leere Instanz der Hashtable-Klasse unter Verwendung der angegebenen Anfangskapazität, des Standardlastfaktors, des Hashcode-Standardanbieters und des Standardcomparers.

Hashtable(Int32, IEqualityComparer)

Initialisiert eine neue leere Instanz der Hashtable-Klasse unter Verwendung der angegebenen Anfangskapazität und des angegebenen IEqualityComparer sowie des Standardlastfaktors.

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

Initialisiert eine neue leere Instanz der Hashtable-Klasse unter Verwendung der angegebenen Anfangskapazität, des angegebenen Hashcodeanbieters, des angegebenen Comparers und des Standardlastfaktors.

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.

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.

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

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.

Hashtable(SerializationInfo, StreamingContext)
Veraltet.

Initialisiert eine neue leere Instanz der Hashtable-Klasse, die serialisierbar ist, wobei die angegebenen SerializationInfo-Objekte und die angegebenen StreamingContext-Objekte verwendet werden.

Eigenschaften

comparer
Veraltet.
Veraltet.

Ruft den für die IComparer zu verwendenden Hashtable ab oder legt diesen fest.

Count

Ruft die Anzahl der Schlüssel-Wert-Paare im Hashtable ab.

EqualityComparer

Ruft den IEqualityComparer ab, der für die Hashtable verwendet werden soll.

hcp
Veraltet.
Veraltet.

Ruft das Objekt ab, das Hashcodes verteilen kann, oder legt dieses fest.

IsFixedSize

Ruft einen Wert ab, der angibt, ob das Hashtable eine feste Größe aufweist.

IsReadOnly

Ruft einen Wert ab, der angibt, ob das Hashtable schreibgeschützt ist.

IsSynchronized

Ruft einen Wert ab, der angibt, ob der Zugriff auf die Hashtable synchronisiert (threadsicher) ist.

Item[Object]

Ruft den Wert ab, der dem angegebenen Schlüssel zugeordnet ist, oder legt diesen fest.

Keys

Ruft eine ICollection ab, die die Schlüssel in der Hashtable enthält.

SyncRoot

Ruft ein Objekt ab, mit dem der Zugriff auf Hashtable synchronisiert werden kann.

Values

Ruft eine ICollection ab, die die Werte im Hashtable enthält.

Methoden

Add(Object, Object)

Fügt dem Hashtable ein Element mit dem angegebenen Schlüssel und Wert hinzu.

Clear()

Entfernt alle Elemente aus der Hashtable.

Clone()

Erstellt eine flache Kopie von Hashtable.

Contains(Object)

Stellt fest, ob der Hashtable einen bestimmten Schlüssel enthält.

ContainsKey(Object)

Stellt fest, ob der Hashtable einen bestimmten Schlüssel enthält.

ContainsValue(Object)

Ermittelt, ob die Hashtable einen bestimmten Wert enthält.

CopyTo(Array, Int32)

Kopiert die Hashtable-Elemente an den angegebenen Index in einer eindimensionalen Array-Instanz.

Equals(Object)

Bestimmt, ob das angegebene Objekt gleich dem aktuellen Objekt ist.

(Geerbt von Object)
GetEnumerator()

Gibt einen IDictionaryEnumerator zurück, der Hashtable durchläuft.

GetHash(Object)

Gibt den Hashcode für den angegebenen Schlüssel zurück.

GetHashCode()

Fungiert als Standardhashfunktion.

(Geerbt von Object)
GetObjectData(SerializationInfo, StreamingContext)
Veraltet.

Implementiert die ISerializable-Schnittstelle und gibt die zum Serialisieren der Hashtable erforderlichen Daten zurück.

GetType()

Ruft den Type der aktuellen Instanz ab.

(Geerbt von Object)
KeyEquals(Object, Object)

Vergleicht ein bestimmtes Object mit einem bestimmten Schlüssel in Hashtable.

MemberwiseClone()

Erstellt eine flache Kopie des aktuellen Object.

(Geerbt von Object)
OnDeserialization(Object)

Implementiert die ISerializable-Schnittstelle und löst das Deserialisierungsereignis aus, sobald die Deserialisierung abgeschlossen ist.

Remove(Object)

Entfernt das Element mit dem angegebenen Schlüssel aus dem Hashtable.

Synchronized(Hashtable)

Gibt einen synchronisierten (threadsicheren) Wrapper für die Hashtable zurück.

ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle Objekt darstellt.

(Geerbt von Object)

Explizite Schnittstellenimplementierungen

IEnumerable.GetEnumerator()

Gibt einen Enumerator zurück, der eine Auflistung durchläuft.

Erweiterungsmethoden

Cast<TResult>(IEnumerable)

Wandelt die Elemente eines IEnumerable in den angegebenen Typ um

OfType<TResult>(IEnumerable)

Filtert die Elemente eines IEnumerable anhand eines angegebenen Typs

AsParallel(IEnumerable)

Ermöglicht die Parallelisierung einer Abfrage.

AsQueryable(IEnumerable)

Konvertiert einen IEnumerable in einen IQueryable.

Gilt für:

Threadsicherheit

Hashtable ist threadsicher für die Verwendung durch mehrere Leserthreads und einen einzelnen Schreibthread. Es ist threadsicher für die Verwendung mit mehreren Threads, wenn nur einer der Threads Schreibvorgänge (Aktualisierungsvorgänge) ausführt. Dies ermöglicht Lesevorgänge ohne Sperren, sofern die Writer in serialisiert Hashtablewerden. Um mehrere Writer zu unterstützen, müssen alle Vorgänge auf dem Hashtable über den von der Synchronized(Hashtable) -Methode zurückgegebenen Wrapper erfolgen, vorausgesetzt, es gibt keine Threads, die das Hashtable Objekt lesen.

Das Aufzählen durch eine Sammlung ist intrinsisch keine threadsichere Prozedur. 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. 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.

Weitere Informationen