Hashtable Klasse

Definition

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

[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

public class Hashtable : ICloneable, System.Collections.IDictionary, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable

type Hashtable = class
    interface ICollection
    interface IEnumerable
    interface IDictionary

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

type Hashtable = class
    interface ICollection
    interface IEnumerable
    interface IDictionary
    interface ICloneable
    interface IDeserializationCallback
    interface ISerializable

Public Class Hashtable
Implements IDictionary

Public Class Hashtable
Implements ICloneable, IDeserializationCallback, IDictionary, ISerializable

Vererbung

Object

Hashtable

Abgeleitet

System.Configuration.SettingsAttributeDictionary

System.Configuration.SettingsContext

System.Data.PropertyCollection

System.Printing.IndexedProperties.PrintPropertyDictionary

Attribute

SerializableAttribute ComVisibleAttribute

Implementiert

ICollection IDictionary IEnumerable ICloneable IDeserializationCallback ISerializable

Beispiele

Das folgende Beispiel zeigt, wie Verschiedene Funktionen Hashtable erstellt, initialisiert und ausgeführt werden, und wie sie ihre Schlüssel und Werte drucken.

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

Die als Schlüssel eines Hashtable Objekts verwendeten Objekte sind erforderlich, um die Object.GetHashCode Methode (oder die IHashCodeProvider Schnittstelle) und die Object.Equals Methode (oder die IComparer Schnittstelle) außer Kraft zu setzen. Die Implementierung von Methoden und Schnittstellen muss die Groß-/Kleinschreibung auf die gleiche Weise behandeln; andernfalls verhält sich das Hashtable Verhalten möglicherweise falsch. Wenn Sie beispielsweise eine HashtableKlasse erstellen, müssen Sie die CaseInsensitiveHashCodeProvider Klasse (oder die Implementierung ohne Groß-/Kleinschreibung IHashCodeProvider ) mit der CaseInsensitiveComparer Klasse (oder bei jeder Implementierung ohne Groß-/Kleinschreibung IComparer ) verwenden.

Darüber hinaus müssen diese Methoden dieselben Ergebnisse erzeugen, wenn sie mit denselben Parametern aufgerufen werden, während der Schlüssel in der Hashtable. Eine Alternative besteht darin, einen Hashtable Konstruktor mit einem IEqualityComparer Parameter zu verwenden. Wenn die Schlüsselgleichstellung einfach auf die Gleichheit verweist, reicht die geerbte Implementierung aus Object.GetHashCode und Object.Equals reichte aus.

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

Wenn dem Element ein Element hinzugefügt Hashtablewird, wird das Element basierend auf dem Hashcode des Schlüssels in einen 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 Auffinden eines Elements erforderlich sind.

Der Ladefaktor eines Elements Hashtable bestimmt das maximale Verhältnis von Elementen zu Buckets. Kleinere Ladefaktoren führen zu schnelleren durchschnittlichen Nachschlagezeiten zu kosten einer erhöhten Speicherauslastung. Der Standardlastfaktor 1,0 bietet in der Regel das beste Gleichgewicht zwischen Geschwindigkeit und Größe. Ein anderer Ladefaktor kann auch beim Erstellen angegeben Hashtable werden.

Wenn Elemente zu einem Hashtablehinzugefügt werden, erhöht sich der tatsächliche Lastfaktor der Hashtable Erhöhungen. Wenn der tatsächliche Ladefaktor den angegebenen Lastfaktor erreicht, wird die Anzahl der Buckets in der Hashtable Folie automatisch auf die kleinste Primzahl erhöht, die größer als doppelt die aktuelle Anzahl von Hashtable Buckets ist.

Jedes Schlüsselobjekt in der Hashtable Muss eine eigene Hashfunktion bereitstellen, auf die durch Aufrufen GetHashzugegriffen werden kann. Jedes implementierte 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 Elements Hashtable ist die Anzahl der Elemente, die aufbewahrt Hashtable werden können. Wenn Elemente zu einem HashtableElement hinzugefügt werden, wird die Kapazität bei Bedarf durch Umschichtung automatisch 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 true in der Laufzeitumgebung festlegen.

Die foreach Anweisung der C#-Sprache (For Each in Visual Basic) gibt ein Objekt des Typs der Elemente in der Auflistung zurück. Da jedes Element ein Hashtable Schlüssel-Wert-Paar ist, ist der Elementtyp nicht der Typ des Schlüssels oder des Typs des Werts. Stattdessen lautet DictionaryEntryder Elementtyp . Beispiel:

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 von , nicht schreiben in die Auflistung ermöglicht.

Da die Serialisierung und Deserialisierung eines Enumerators für ein Hashtable Element dazu führen kann, dass die Elemente neu angeordnet werden, ist es nicht möglich, die Enumeration fortzusetzen, ohne die Reset Methode aufzurufen.

Threadsicherheit

Hashtable ist threadsicher für die Verwendung durch mehrere Lesethreads und einen einzelnen Schreibthread. Es ist threadsicher für die Verwendung mit mehreren Threads, wenn nur einer der Threads Schreibvorgänge (Update) ausführt, die sperrfreie Lesevorgänge ermöglichen, vorausgesetzt, die Autoren werden serialisiert in die Hashtable. Um mehrere Autoren zu unterstützen, müssen alle Vorgänge über Hashtable den von der Synchronized(Hashtable) Methode zurückgegebenen Wrapper ausgeführt werden, vorausgesetzt, es gibt keine Threads, die das Hashtable Objekt lesen.

Das Aufzählen durch eine Sammlung ist in der Regel keine threadsichere Prozedur. Selbst wenn eine Auflistung synchronisiert wird, können andere Threads die Auflistung weiterhin ändern, wodurch der Enumerator eine Ausnahme auslöst. Um die Threadsicherheit während der Enumeration zu gewährleisten, können Sie die Auflistung entweder während der gesamten Enumeration sperren oder die Ausnahmen erfassen, die sich aus Änderungen ergeben, die von anderen Threads vorgenommen wurden.

Weitere Informationen

• IDictionary
• IHashCodeProvider
• GetHashCode()
• Equals(Object)
• DictionaryEntry
• Dictionary<TKey,TValue>
• IEqualityComparer