Hashtable Klas

Definitie

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

Overname

Object

Hashtable

Afgeleid

System.Configuration.SettingsAttributeDictionary

System.Configuration.SettingsContext

System.Data.PropertyCollection

System.Printing.IndexedProperties.PrintPropertyDictionary

Kenmerken

SerializableAttribute ComVisibleAttribute

Implementeringen

ICollection IDictionary IEnumerable ICloneable IDeserializationCallback ISerializable

Voorbeelden

In het volgende voorbeeld ziet u hoe u verschillende functies maakt, initialiseert en uitvoert op een Hashtable en hoe u de sleutels en waarden kunt afdrukken.

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

Opmerkingen

Elk element is een sleutel/waardepaar dat is opgeslagen in een DictionaryEntry object. Een sleutel kan niet zijn null, maar een waarde kan zijn.

De objecten die door een sleutel Hashtable worden gebruikt, moeten de Object.GetHashCode methode (of de IHashCodeProvider interface) en de Object.Equals methode (of de IComparer interface) overschrijven. De implementatie van beide methoden en interfaces moet op dezelfde manier omgaan met hoofdlettergevoeligheid; anders gedraagt het Hashtable zich mogelijk onjuist. Als u bijvoorbeeld een Hashtableklasse maakt, moet u de CaseInsensitiveHashCodeProvider klasse (of elke niet-hoofdlettergevoelige IHashCodeProvider implementatie) gebruiken met de CaseInsensitiveComparer klasse (of elke niet-hoofdlettergevoelige IComparer implementatie).

Bovendien moeten deze methoden dezelfde resultaten produceren wanneer ze worden aangeroepen met dezelfde parameters terwijl de sleutel aanwezig is in de Hashtable. Een alternatief is het gebruik van een Hashtable constructor met een IEqualityComparer parameter. Als de gelijkheid van de sleutel alleen maar naar gelijkheid verwijst, zou de overgenomen tenuitvoerlegging van Object.GetHashCode en Object.Equals volstaan.

Sleutelobjecten moeten onveranderbaar zijn zolang ze worden gebruikt als sleutels in de Hashtable.

Wanneer een element aan de Hashtablesleutel wordt toegevoegd, wordt het element in een bucket geplaatst op basis van de hash-code van de sleutel. Volgende zoekacties van de sleutel gebruiken de hashcode van de sleutel om in slechts één bepaalde bucket te zoeken, waardoor het aantal sleutelvergelijkingen dat nodig is om een element te vinden aanzienlijk wordt verminderd.

De belastingfactor van een bepaalt Hashtable de maximale verhouding van elementen tot buckets. Kleinere belastingsfactoren veroorzaken snellere gemiddelde opzoektijden ten koste van een verhoogd geheugenverbruik. De standaardbelastingfactor van 1,0 biedt over het algemeen de beste balans tussen snelheid en grootte. Er kan ook een andere belastingfactor worden opgegeven wanneer de Hashtable taak wordt gemaakt.

Als elementen worden toegevoegd aan een Hashtable, wordt de werkelijke belastingfactor van de Hashtable toenamen toegevoegd. Wanneer de werkelijke belastingfactor de opgegeven belastingfactor bereikt, wordt het aantal buckets in de Hashtable bucket automatisch verhoogd tot het kleinste priemgetall dat groter is dan twee keer het huidige aantal Hashtable buckets.

Elk sleutelobject in de Hashtable sleutel moet een eigen hash-functie opgeven, die toegankelijk is door aan te roepen GetHash. Het implementeren IHashCodeProvider van objecten kan echter worden doorgegeven aan een Hashtable constructor en die hash-functie wordt gebruikt voor alle objecten in de tabel.

De capaciteit van een Hashtable is het aantal elementen dat de Hashtable kan bevatten. Als er elementen aan een Hashtableworden toegevoegd, wordt de capaciteit automatisch verhoogd als vereist via herlocatie.

.NET Framework alleen: Voor zeer grote Hashtable-objecten kunt u de maximale capaciteit verhogen tot 2 miljard elementen op een 64-bits systeem door het kenmerk enabled van het <gcAllowVeryLargeObjects>-configuratie-element in te stellen op true in de runtimeomgeving.

De instructie foreach van de C#-taal (For Each in Visual Basic) retourneert een object van het type elementen in de verzameling. Omdat elk element van het Hashtable element een sleutel/waardepaar is, is het elementtype niet het type van de sleutel of het type van de waarde. In plaats daarvan is DictionaryEntryhet elementtype . Voorbeeld:

foreach(DictionaryEntry de in myHashtable)
{
    // ...
}

For Each de As DictionaryEntry In myHashtable
    ' ...
Next de

De foreach instructie is een wrapper rond de enumerator, waarmee alleen kan worden gelezen van, niet schrijven naar, de verzameling.

Omdat het serialiseren en deserialiseren van een enumerator voor een Hashtable kan ertoe leiden dat de elementen opnieuw worden gerangschikt, is het niet mogelijk om de opsomming voort te zetten zonder de Reset methode aan te roepen.

Veiligheid thread

Hashtable is thread veilig voor gebruik door meerdere lezerthreads en één schrijfthread. Het is thread veilig voor gebruik met meerdere threads wanneer slechts één van de threads schrijfbewerkingen (updatebewerkingen) uitvoert, waardoor leesbewerkingen zonder vergrendeling mogelijk zijn, mits de schrijvers worden geserialiseerd naar de Hashtable. Om meerdere schrijvers te ondersteunen, moeten alle bewerkingen op de Hashtable schrijfbewerking worden uitgevoerd via de wrapper die door de Synchronized(Hashtable) methode wordt geretourneerd, mits er geen threads zijn die het Hashtable object lezen.

Het inventariseren via een verzameling is intrinsiek geen threadveilige procedure. Zelfs wanneer een verzameling wordt gesynchroniseerd, kunnen andere threads de verzameling nog steeds wijzigen, waardoor de enumerator een uitzondering genereert. Om de veiligheid van threads tijdens de inventarisatie te garanderen, kunt u de verzameling vergrendelen tijdens de volledige inventarisatie of de uitzonderingen ondervangen die het gevolg zijn van wijzigingen die door andere threads zijn aangebracht.

Zie ook

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