Hashtable Osztály

Definíció

Névtér:

System.Collections

Szerelvények:

netstandard.dll, System.Runtime.dll

Forrás:

Hashtable.cs

A kulcs kivonatkódja alapján rendezett kulcs/érték párok gyűjteményét jelöli.

public ref 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
    interface ICloneable
    interface IDeserializationCallback
    interface ISerializable

Public Class Hashtable
Implements ICloneable, IDeserializationCallback, IDictionary, ISerializable

Öröklődés

Object

Hashtable

Származtatott

System.Configuration.SettingsAttributeDictionary

System.Configuration.SettingsContext

System.Data.PropertyCollection

System.Printing.IndexedProperties.PrintPropertyDictionary

Megvalósítás

ICollection IDictionary IEnumerable ICloneable IDeserializationCallback ISerializable

Példák

Az alábbi példa bemutatja, hogyan hozhat létre, inicializálhat és hajthat végre különböző függvényeket egy Hashtable adott függvényen, és hogyan nyomtathatja ki a kulcsait és értékeit.

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

Megjegyzések

Minden elem egy objektumban DictionaryEntry tárolt kulcs-érték pár. A kulcs nem lehet null, de egy érték lehet.

Important

Nem javasoljuk, hogy az osztályt Hashtable új fejlesztéshez használja. Ehelyett azt javasoljuk, hogy az általános Dictionary<TKey,TValue> osztályt használja. További információ: Non-generic gyűjtemények nem használhatók GitHub.

Az a Hashtable általuk kulcsként használt objektumokra a metódus (vagy az Object.GetHashCode interfész) és a IHashCodeProvider metódus (vagy az Object.Equals interfész) felülbírálásához IComparer van szükség. A módszerek és interfészek implementálásának ugyanúgy kell kezelnie a kis- és nagybetűk érzékenységét; ellenkező esetben helytelenül Hashtable viselkedhet. Például egy Hashtablelétrehozásakor az CaseInsensitiveHashCodeProvider osztályt (vagy bármilyen kis- és nagybetűs IHashCodeProvider implementációt) kell használnia az CaseInsensitiveComparer osztálysal (vagy bármilyen kis- és nagybetűs IComparer implementációval).

Ezen kívül ezeknek a metódusoknak ugyanazokat az eredményeket kell eredményezniük, amikor ugyanazokkal a paraméterekkel hívják meg őket, miközben a kulcs a .Hashtable Másik lehetőség, ha egy konstruktort Hashtable használ egy IEqualityComparer paraméterrel. Ha a kulcsegyenlőség csupán az egyenlőségre hivatkozna, az öröklött végrehajtás Object.GetHashCodeObject.Equals elegendő lenne.

A kulcsobjektumoknak nem módosíthatóknak kell lenniük mindaddig, amíg kulcsként használják őket a Hashtable.

Amikor hozzáad egy elemet a Hashtablekulcshoz, az elem egy gyűjtőbe kerül a kulcs kivonatkódja alapján. A kulcs későbbi keresései a kulcs kivonatkódját használják, hogy csak egy adott gyűjtőben keressenek, így jelentősen csökkentve az elemek kereséséhez szükséges kulcs-összehasonlítások számát.

A terhelési Hashtable tényező határozza meg az elemek és gyűjtők maximális arányát. A kisebb terhelési tényezők gyorsabb átlagos keresési időt okoznak a megnövekedett memóriahasználat költségén. Az alapértelmezett 1.0 terhelési tényező általában a sebesség és a méret közötti legjobb egyensúlyt biztosítja. A létrehozáskor Hashtable más terhelési tényező is megadható.

Az elemek hozzáadásakor Hashtablea tényleges terhelési Hashtable tényező nő. Amikor a tényleges terhelési tényező eléri a megadott terhelési tényezőt, a gyűjtők Hashtable száma automatikusan a legkisebb prímszámra nő, amely nagyobb, mint az aktuális gyűjtők számának kétszerese Hashtable .

A kulcsobjektumok mindegyikének Hashtable saját kivonatfüggvényt kell biztosítania, amely hívással GetHashérhető el. Az objektumok implementálását IHashCodeProvider azonban átadhatja egy Hashtable konstruktornak, és ez a kivonatfüggvény a tábla összes objektumához használható.

Egy adott elem kapacitása Hashtable a visszatartható elemek Hashtable száma. Az elemek hozzáadásakor Hashtablea kapacitás a szükséges módon automatikusan növekszik az újraelosztással.

csak .NET-keretrendszer: Nagyon nagy objektumok esetén a maximális kapacitást 2 milliárd elemre növelheti egy 64 bites rendszeren, ha a < konfigurációs elem attribútumát -ra állítja a futásidejű környezetben.

A C# nyelv foreach utasítása (For Each Visual Basic) a gyűjtemény elemeinek típusát adja vissza. Mivel a Hashtable kulcs minden eleme kulcs/érték pár, az elem típusa nem a kulcs típusa vagy az érték típusa. Ehelyett az elem típusa .DictionaryEntry Például:

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

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

Az foreach utasítás egy burkoló az enumerátor körül, amely csak a gyűjteményből való olvasást teszi lehetővé, nem pedig a gyűjteménybe való írást.

Mivel egy enumerátor Hashtable szerializálása és deszerializálása az elemek átrendezését okozhatja, a metódus meghívása nélkül nem lehet folytatni az Reset enumerálást.

Note

Mivel a kulcsok örökölhetők, és viselkedésük megváltozik, abszolút egyediségük nem garantálható a Equals metódust használó összehasonlításokkal.

Konstruktorok

Name	Description
Hashtable()	Inicializálja az osztály új, üres példányát az Hashtable alapértelmezett kezdeti kapacitás, terhelési tényező, kivonatkód-szolgáltató és összehasonlító használatával.
Hashtable(IDictionary, IEqualityComparer)	Inicializálja az osztály új példányát úgy Hashtable , hogy a megadott szótár elemeit egy új Hashtable objektumba másolja. Az új Hashtable objektum kezdeti kapacitása megegyezik a másolt elemek számával, és az alapértelmezett terhelési tényezőt és a megadott IEqualityComparer objektumot használja.
Hashtable(IDictionary, IHashCodeProvider, IComparer)	Elavult. Inicializálja az osztály új példányát a Hashtable megadott szótár elemeinek az új Hashtable objektumba másolásával. Az új Hashtable objektum kezdeti kapacitása megegyezik a másolt elemek számával, és az alapértelmezett terhelési tényezőt, valamint a megadott kivonatkód-szolgáltatót és összehasonlítót használja. Ez az API elavult. Másik lehetőségként tekintse meg a következőt Hashtable(IDictionary, IEqualityComparer): .
Hashtable(IDictionary, Single, IEqualityComparer)	Inicializálja az osztály új példányát a Hashtable megadott szótár elemeinek az új Hashtable objektumba másolásával. Az új Hashtable objektum kezdeti kapacitása megegyezik a másolt elemek számával, és a megadott terhelési tényezőt és IEqualityComparer objektumot használja.
Hashtable(IDictionary, Single, IHashCodeProvider, IComparer)	Elavult. Inicializálja az osztály új példányát a Hashtable megadott szótár elemeinek az új Hashtable objektumba másolásával. Az új Hashtable objektum kezdeti kapacitása megegyezik a másolt elemek számával, és a megadott terhelési tényezőt, kivonatkód-szolgáltatót és összehasonlítót használja.
Hashtable(IDictionary, Single)	Inicializálja az osztály új példányát a Hashtable megadott szótár elemeinek az új Hashtable objektumba másolásával. Az új Hashtable objektum kezdeti kapacitása megegyezik a másolt elemek számával, és a megadott terhelési tényezőt, valamint az alapértelmezett kivonatkód-szolgáltatót és összehasonlítót használja.
Hashtable(IDictionary)	Inicializálja az osztály új példányát a Hashtable megadott szótár elemeinek az új Hashtable objektumba másolásával. Az új Hashtable objektum kezdeti kapacitása megegyezik a másolt elemek számával, és az alapértelmezett terhelési tényezőt, a kivonatkód-szolgáltatót és a összehasonlítót használja.
Hashtable(IEqualityComparer)	Inicializálja az osztály új, üres példányát az Hashtable alapértelmezett kezdeti kapacitás és terhelési tényező, valamint a megadott IEqualityComparer objektum használatával.
Hashtable(IHashCodeProvider, IComparer)	Elavult. Inicializálja az osztály új, üres példányát az Hashtable alapértelmezett kezdeti kapacitás és terhelési tényező, valamint a megadott kivonatkód-szolgáltató és összehasonlító használatával.
Hashtable(Int32, IEqualityComparer)	Inicializálja az osztály új, üres példányát a Hashtable megadott kezdeti kapacitás és IEqualityCompareraz alapértelmezett terhelési tényező használatával.
Hashtable(Int32, IHashCodeProvider, IComparer)	Elavult. Inicializálja az osztály új, üres példányát a Hashtable megadott kezdeti kapacitás, kivonatkód-szolgáltató, összehasonlító és az alapértelmezett terhelési tényező használatával.
Hashtable(Int32, Single, IEqualityComparer)	Inicializálja az osztály új, üres példányát a Hashtable megadott kezdeti kapacitás, terhelési tényező és IEqualityComparer objektum használatával.
Hashtable(Int32, Single, IHashCodeProvider, IComparer)	Elavult. Inicializálja az osztály új, üres példányát a Hashtable megadott kezdeti kapacitás, terhelési tényező, kivonatkód-szolgáltató és összehasonlító használatával.
Hashtable(Int32, Single)	Inicializálja az Hashtable osztály új, üres példányát a megadott kezdeti kapacitás és terhelési tényező, valamint az alapértelmezett kivonatkód-szolgáltató és összehasonlító használatával.
Hashtable(Int32)	Inicializálja az osztály új, üres példányát a Hashtable megadott kezdeti kapacitással, valamint az alapértelmezett terhelési tényezővel, kivonatkód-szolgáltatóval és összehasonlítóval.
Hashtable(SerializationInfo, StreamingContext)	Elavult. Inicializálja az Hashtable osztály új, üres példányát, amely szerializálható a megadott SerializationInfo és StreamingContext az objektumok használatával.

Tulajdonságok

Name	Description
comparer	Elavult. Lekéri vagy beállítja a IComparer használni kívánt .Hashtable
Count	Lekéri a kulcs/érték párok számát a Hashtable.
EqualityComparer	Lekéri a IEqualityComparer használni Hashtablea .
hcp	Elavult. Lekéri vagy beállítja a kivonatkódokat kiosztó objektumot.
IsFixedSize	Egy értéket kap, amely jelzi, hogy a Hashtable méret rögzített-e.
IsReadOnly	Beolvas egy értéket, amely jelzi, hogy az Hashtable írásvédett-e.
IsSynchronized	Beolvas egy értéket, amely jelzi, hogy a Hashtable hozzáférés szinkronizálva van-e (a szál biztonságos).
Item[Object]	Lekéri vagy beállítja a megadott kulccsal társított értéket.
Keys	ICollection Lekéri a kulcsokat Hashtablea .
SyncRoot	Lekéri az objektumot, amely a hozzáférés szinkronizálására használható.Hashtable
Values	A beolvas egy ICollection olyan értéket, amely tartalmazza a . Hashtableértékét.

Metódusok

Name	Description
Add(Object, Object)	Hozzáad egy elemet a megadott kulccsal és értékkel a Hashtable.
Clear()	Eltávolítja az összes elemet a Hashtable.
Clone()	Létrehoz egy sekély másolatot a Hashtable.
Contains(Object)	Meghatározza, hogy a Hashtable kulcs tartalmaz-e egy adott kulcsot.
ContainsKey(Object)	Meghatározza, hogy a Hashtable kulcs tartalmaz-e egy adott kulcsot.
ContainsValue(Object)	Meghatározza, hogy az Hashtable adott érték tartalmaz-e.
CopyTo(Array, Int32)	Másolja az Hashtable elemeket egy egydimenziós Array példányba a megadott indexben.
Equals(Object)	Meghatározza, hogy a megadott objektum egyenlő-e az aktuális objektummal. (Öröklődés forrása Object)
GetEnumerator()	Egy olyan értéket IDictionaryEnumerator ad vissza, amely a Hashtable.
GetHash(Object)	A megadott kulcs kivonatkódját adja vissza.
GetHashCode()	Ez az alapértelmezett kivonatoló függvény. (Öröklődés forrása Object)
GetObjectData(SerializationInfo, StreamingContext)	Elavult. Implementálja az interfészt ISerializable , és visszaadja a szerializáláshoz Hashtableszükséges adatokat.
GetType()	Lekéri az Type aktuális példányt. (Öröklődés forrása Object)
KeyEquals(Object, Object)	Egy adott Object és egy adott kulcs összehasonlítása a Hashtable.
MemberwiseClone()	Az aktuális Objectpéldány sekély másolatát hozza létre. (Öröklődés forrása Object)
OnDeserialization(Object)	Implementálja az ISerializable interfészt, és a deszerializálás befejezésekor aktiválja a deszerializálási eseményt.
Remove(Object)	Eltávolítja a megadott kulccsal rendelkező elemet a Hashtable.
Synchronized(Hashtable)	Szinkronizált (szálbiztos) burkolót ad vissza a Hashtable.
ToString()	Az aktuális objektumot jelképező sztringet ad vissza. (Öröklődés forrása Object)

Explicit interfész-implementációk

Name	Description
IEnumerable.GetEnumerator()	Egy gyűjteményen keresztül iteráló enumerátort ad vissza.

Bővítő metódusok

Name	Description
AsParallel(IEnumerable)	Lehetővé teszi a lekérdezés párhuzamosítását.
AsQueryable(IEnumerable)	Átalakítja az egyiket IEnumerableIQueryable.
Cast<TResult>(IEnumerable)	Egy elem elemeit IEnumerable a megadott típusra veti.
OfType<TResult>(IEnumerable)	Egy adott típus alapján szűri IEnumerable egy adott elem elemeit.

Szálbiztonság

Hashtable több olvasószál és egyetlen írási szál által használható. Többszálas használatra biztonságos, ha csak az egyik szál végez írási (frissítési) műveleteket, ami lehetővé teszi a zárolás nélküli olvasást, feltéve, hogy az írók szerializálva vannak a Hashtable. Több író támogatásához az összes műveletet a Hashtable metódus által Synchronized(Hashtable) visszaadott burkolón keresztül kell elvégezni, feltéve, hogy nincsenek szálak az Hashtable objektumot olvasva.

A gyűjteményen keresztüli számbavétel alapvetően nem szálbiztos eljárás. A gyűjtemény szinkronizálása esetén is más szálak módosíthatják a gyűjteményt, ami miatt az enumerátor kivételt okoz. Az enumerálás során a szálbiztonság garantálása érdekében zárolhatja a gyűjteményt a teljes enumerálás során, vagy elkaphatja a más szálak által végrehajtott módosításokból eredő kivételeket.

Lásd még

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