Hashtable Klasa

Definicja

Przestrzeń nazw:

System.Collections

Zestaw:

System.Runtime.dll

Źródło:

Hashtable.cs

Reprezentuje kolekcję par klucz/wartość, które są zorganizowane na podstawie kodu skrótu klucza.

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

Dziedziczenie

Object

Hashtable

Pochodne

System.Configuration.SettingsAttributeDictionary

System.Configuration.SettingsContext

System.Data.PropertyCollection

System.Printing.IndexedProperties.PrintPropertyDictionary

Implementuje

ICollection IDictionary IEnumerable ICloneable IDeserializationCallback ISerializable

Przykłady

W poniższym przykładzie pokazano, jak utworzyć, zainicjować i wykonać różne funkcje w Hashtable obiekcie oraz jak wyświetlić jego klucze i wartości.

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

Uwagi

Każdy element jest parą klucz/wartość przechowywaną DictionaryEntry w obiekcie. Klucz nie może być nullwartością , ale może to być wartość.

Ważne

Nie zalecamy używania Hashtable klasy do tworzenia nowych aplikacji. Zamiast tego zalecamy użycie klasy ogólnej Dictionary<TKey,TValue> . Aby uzyskać więcej informacji, zobacz Kolekcje nieogólne nie powinny być używane w usłudze GitHub.

Obiekty używane jako klucze przez element Hashtable są wymagane do zastąpienia Object.GetHashCode metody (lub interfejsu IHashCodeProvider ) i Object.Equals metody (lub interfejsu IComparer ). Implementacja obu metod i interfejsów musi obsługiwać wielkość liter w taki sam sposób; Hashtable w przeciwnym razie element może zachowywać się nieprawidłowo. Na przykład podczas tworzenia Hashtableklasy należy użyć CaseInsensitiveHashCodeProvider klasy (lub dowolnej implementacji IHashCodeProvider bez uwzględniania wielkości liter) z klasą CaseInsensitiveComparer (lub bez uwzględniania IComparer wielkości liter).

Ponadto te metody muszą generować te same wyniki, gdy są wywoływane z tymi samymi parametrami, gdy klucz istnieje w obiekcie Hashtable. Alternatywą jest użycie konstruktora Hashtable z parametrem IEqualityComparer . Gdyby równość klucza była po prostu równością referencyjną, odziedziczona implementacja Object.GetHashCode elementu i Object.Equals wystarczyłaby.

Obiekty kluczy muszą być niezmienne, o ile są używane jako klucze w obiekcie Hashtable.

Po dodaniu elementu do Hashtableelementu element jest umieszczany w zasobniku na podstawie kodu skrótu klucza. Kolejne wyszukiwania klucza używają kodu skrótu klucza do wyszukiwania tylko w jednym konkretnym zasobniku, co znacznie zmniejsza liczbę porównań kluczy wymaganych do znalezienia elementu.

Współczynnik obciążenia elementu Hashtable określa maksymalny współczynnik elementów do zasobników. Mniejsze czynniki obciążenia powodują szybsze średnie czasy wyszukiwania kosztem zwiększonego użycia pamięci. Domyślny współczynnik obciążenia 1.0 zazwyczaj zapewnia najlepszą równowagę między szybkością a rozmiarem. Podczas tworzenia elementu można również określić Hashtable inny współczynnik obciążenia.

Gdy elementy są dodawane do Hashtableelementu , rzeczywisty współczynnik Hashtable obciążenia zwiększa się. Gdy rzeczywisty współczynnik obciążenia osiągnie określony współczynnik obciążenia, liczba zasobników w elemencie Hashtable jest automatycznie zwiększana do najmniejszej liczby prime, która jest większa niż dwukrotnie większa niż bieżąca liczba Hashtable zasobników.

Każdy obiekt klucza w obiekcie Hashtable musi podać własną funkcję skrótu, do której można uzyskać dostęp, wywołując metodę GetHash. Jednak wszystkie implementacje IHashCodeProvider obiektów można przekazać do konstruktora Hashtable , a ta funkcja skrótu jest używana dla wszystkich obiektów w tabeli.

Pojemność obiektu Hashtable to liczba elementów, które Hashtable mogą być przechowywane. W miarę dodawania Hashtableelementów do elementu pojemność jest automatycznie zwiększana zgodnie z wymaganiami za pośrednictwem lokalizacji rzeczywistej.

tylko .NET Framework: w przypadku bardzo dużych Hashtable obiektów można zwiększyć maksymalną pojemność do 2 miliardów elementów w systemie 64-bitowym, ustawiając enabled atrybut <gcAllowVeryLargeObjects> elementu konfiguracji na true w środowisku uruchomieniowym.

Instrukcja foreach języka C# (For Each w Visual Basic) zwraca obiekt typu elementów w kolekcji. Ponieważ każdy element Hashtable elementu jest parą klucz/wartość, typ elementu nie jest typem klucza ani typem wartości. Zamiast tego typ elementu to DictionaryEntry. Na przykład:

for each(DictionaryEntry de in myHashtable)
{
    // ...
}

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

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

Instrukcja foreach jest otoką wokół modułu wyliczającego, który umożliwia tylko odczytywanie, a nie zapisywanie w kolekcji.

Ponieważ serializowanie i deserializacji modułu wyliczającego może Hashtable spowodować, że elementy staną się ponownie uporządkowane, nie można kontynuować wyliczania bez wywoływania Reset metody.

Uwaga

Ponieważ klucze można dziedziczyć i zmieniać ich zachowanie, ich bezwzględna unikatowość nie może być gwarantowana przez porównania przy użyciu Equals metody .

Konstruktory

Hashtable()	Inicjuje nowe, puste wystąpienie Hashtable klasy przy użyciu domyślnej pojemności początkowej, współczynnika obciążenia, dostawcy kodu skrótu i modułu porównującego.
Hashtable(IDictionary)	Inicjuje Hashtable nowe wystąpienie klasy, kopiując elementy z określonego słownika do nowego Hashtable obiektu. Nowy Hashtable obiekt ma początkową pojemność równą liczbie skopiowanych elementów i używa domyślnego współczynnika obciążenia, dostawcy kodu skrótu i modułu porównującego.
Hashtable(IDictionary, IEqualityComparer)	Inicjuje Hashtable nowe wystąpienie klasy, kopiując elementy z określonego słownika do nowego Hashtable obiektu. Nowy Hashtable obiekt ma początkową pojemność równą liczbie skopiowanych elementów i używa domyślnego współczynnika obciążenia i określonego IEqualityComparer obiektu.
Hashtable(IDictionary, IHashCodeProvider, IComparer)	Przestarzałe. Inicjuje Hashtable nowe wystąpienie klasy, kopiując elementy z określonego słownika do nowego Hashtable obiektu. Nowy Hashtable obiekt ma początkową pojemność równą liczbie skopiowanych elementów i używa domyślnego współczynnika obciążenia oraz określonego dostawcy kodu skrótu i modułu porównującego. Ten interfejs API jest nieaktualny. Aby uzyskać alternatywę, zobacz Hashtable(IDictionary, IEqualityComparer).
Hashtable(IDictionary, Single)	Inicjuje Hashtable nowe wystąpienie klasy, kopiując elementy z określonego słownika do nowego Hashtable obiektu. Nowy Hashtable obiekt ma początkową pojemność równą liczbie skopiowanych elementów i używa określonego współczynnika obciążenia oraz domyślnego dostawcy kodu skrótu i porównania.
Hashtable(IDictionary, Single, IEqualityComparer)	Inicjuje Hashtable nowe wystąpienie klasy, kopiując elementy z określonego słownika do nowego Hashtable obiektu. Nowy Hashtable obiekt ma początkową pojemność równą liczbie skopiowanych elementów i używa określonego współczynnika obciążenia i IEqualityComparer obiektu.
Hashtable(IDictionary, Single, IHashCodeProvider, IComparer)	Przestarzałe. Inicjuje Hashtable nowe wystąpienie klasy, kopiując elementy z określonego słownika do nowego Hashtable obiektu. Nowy Hashtable obiekt ma początkową pojemność równą liczbie skopiowanych elementów i używa określonego współczynnika obciążenia, dostawcy kodu skrótu i modułu porównującego.
Hashtable(IEqualityComparer)	Inicjuje nowe, puste wystąpienie Hashtable klasy przy użyciu domyślnej początkowej pojemności i współczynnika obciążenia oraz określonego IEqualityComparer obiektu.
Hashtable(IHashCodeProvider, IComparer)	Przestarzałe. Inicjuje nowe, puste wystąpienie Hashtable klasy przy użyciu domyślnej pojemności początkowej i współczynnika obciążenia oraz określonego dostawcy kodu skrótu i modułu porównującego.
Hashtable(Int32)	Inicjuje nowe, puste wystąpienie Hashtable klasy przy użyciu określonej pojemności początkowej oraz domyślny współczynnik obciążenia, dostawca kodu skrótu i moduł porównawczy.
Hashtable(Int32, IEqualityComparer)	Inicjuje nowe, puste wystąpienie Hashtable klasy przy użyciu określonej pojemności początkowej i IEqualityComparer, oraz domyślny współczynnik obciążenia.
Hashtable(Int32, IHashCodeProvider, IComparer)	Przestarzałe. Inicjuje nowe, puste wystąpienie Hashtable klasy przy użyciu określonej pojemności początkowej, dostawcy kodu skrótu, porównania i domyślnego współczynnika obciążenia.
Hashtable(Int32, Single)	Inicjuje nowe, puste wystąpienie klasy przy użyciu określonej początkowej Hashtable pojemności i współczynnika obciążenia oraz domyślnego dostawcy kodu skrótu i modułu porównującego.
Hashtable(Int32, Single, IEqualityComparer)	Inicjuje nowe, puste wystąpienie Hashtable klasy przy użyciu określonej pojemności początkowej, współczynnika obciążenia i IEqualityComparer obiektu.
Hashtable(Int32, Single, IHashCodeProvider, IComparer)	Przestarzałe. Inicjuje nowe, puste wystąpienie Hashtable klasy przy użyciu określonej pojemności początkowej, współczynnika obciążenia, dostawcy kodu skrótu i modułu porównującego.
Hashtable(SerializationInfo, StreamingContext)	Przestarzałe. Inicjuje nowe, puste wystąpienie Hashtable klasy, które można serializować przy użyciu określonych SerializationInfo obiektów i StreamingContext .

Właściwości

comparer	Przestarzałe. Pobiera lub ustawia wartość IComparer , która ma być używana dla .Hashtable
Count	Pobiera liczbę par klucz/wartość zawartych w obiekcie Hashtable.
EqualityComparer	Pobiera element IEqualityComparer do użycia dla .Hashtable
hcp	Przestarzałe. Pobiera lub ustawia obiekt, który może wydawać kody skrótów.
IsFixedSize	Pobiera wartość wskazującą, czy ma Hashtable stały rozmiar.
IsReadOnly	Pobiera wartość wskazującą, czy kolekcja Hashtable jest przeznaczona tylko do odczytu.
IsSynchronized	Pobiera wartość wskazującą, czy dostęp do elementu Hashtable jest synchronizowany (bezpieczny wątk).
Item[Object]	Pobiera lub ustawia wartość skojarzona z określonym kluczem.
Keys	Pobiera element ICollection zawierający klucze w obiekcie Hashtable.
SyncRoot	Pobiera obiekt, który może służyć do synchronizowania dostępu do obiektu Hashtable.
Values	Pobiera element ICollection zawierający wartości w obiekcie Hashtable.

Metody

Add(Object, Object)	Dodaje element z określonym kluczem i wartością do elementu Hashtable.
Clear()	Usuwa wszystkie elementy z obiektu Hashtable.
Clone()	Tworzy płytkią kopię obiektu Hashtable.
Contains(Object)	Określa, czy element Hashtable zawiera określony klucz.
ContainsKey(Object)	Określa, czy element Hashtable zawiera określony klucz.
ContainsValue(Object)	Określa, czy element Hashtable zawiera określoną wartość.
CopyTo(Array, Int32)	Kopiuje Hashtable elementy do wystąpienia jednowymiarowego Array w określonym indeksie.
Equals(Object)	Określa, czy dany obiekt jest taki sam, jak bieżący obiekt. (Odziedziczone po Object)
GetEnumerator()	Zwraca wartość IDictionaryEnumerator , która iteruje za pośrednictwem elementu Hashtable.
GetHash(Object)	Zwraca kod skrótu dla określonego klucza.
GetHashCode()	Służy jako domyślna funkcja skrótu. (Odziedziczone po Object)
GetObjectData(SerializationInfo, StreamingContext)	Przestarzałe. Implementuje ISerializable interfejs i zwraca dane potrzebne do serializacji .Hashtable
GetType()	Type Pobiera wartość bieżącego wystąpienia. (Odziedziczone po Object)
KeyEquals(Object, Object)	Porównuje określony Object klucz z określonym kluczem w pliku Hashtable.
MemberwiseClone()	Tworzy płytkią kopię bieżącego Objectelementu . (Odziedziczone po Object)
OnDeserialization(Object)	Implementuje ISerializable interfejs i zgłasza zdarzenie deserializacji po zakończeniu deserializacji.
Remove(Object)	Usuwa element z określonym kluczem z .Hashtable
Synchronized(Hashtable)	Zwraca zsynchronizowaną otokę (bezpieczną wątkowo) dla elementu Hashtable.
ToString()	Zwraca ciąg reprezentujący bieżący obiekt. (Odziedziczone po Object)

Jawne implementacje interfejsu

IEnumerable.GetEnumerator()

Zwraca moduł wyliczający, który iteruje po kolekcji.

Metody rozszerzania

Cast<TResult>(IEnumerable)	Rzutuje elementy obiektu IEnumerable na określony typ.
OfType<TResult>(IEnumerable)	Filtruje elementy IEnumerable elementu na podstawie określonego typu.
AsParallel(IEnumerable)	Umożliwia równoległość zapytania.
AsQueryable(IEnumerable)	Konwertuje element IEnumerable na .IQueryable

Bezpieczeństwo wątkowe

Hashtable jest bezpieczny dla wątków używanych przez wiele wątków czytnika i jeden wątek zapisu. Jest bezpieczny dla wątków używanych w wielu wątkach, gdy tylko jeden z wątków wykonuje operacje zapisu (aktualizacji), co pozwala na operacje odczytu bez blokady pod warunkiem, że zapisy są serializowane do Hashtableelementu . Aby obsługiwać wiele składników zapisywania wszystkie operacje na Hashtable obiekcie, należy wykonać za pośrednictwem otoki zwróconej przez metodę Synchronized(Hashtable) , pod warunkiem, że nie ma wątków odczytujących Hashtable obiekt.

Wyliczanie przez kolekcję nie jest wewnętrznie bezpieczną procedurą wątku. Nawet gdy kolekcja jest synchronizowana, inne wątki nadal mogą ją modyfikować. Powoduje to zgłaszanie wyjątku przez moduł wyliczający. Aby zagwarantować bezpieczeństwo wątków podczas wyliczania, można zablokować kolekcję podczas całego procesu wyliczania albo rejestrować wyjątki wynikłe ze zmian wprowadzanych przez inne wątków.

Zobacz też

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