Hashtable Třída

Definice

Obor názvů:

System.Collections

Sestavení:

mscorlib.dll, System.Collections.NonGeneric.dll

Sestavení:

System.Runtime.dll

Sestavení:

System.Collections.NonGeneric.dll

Sestavení:

System.Runtime.Extensions.dll

Sestavení:

mscorlib.dll

Sestavení:

netstandard.dll

Představuje kolekci párů klíč/hodnota, které jsou uspořádané na základě kódu hash klíče.

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

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Hashtable = class
    interface IDictionary
    interface ISerializable
    interface IDeserializationCallback
    interface ICloneable
    interface ICollection
    interface IEnumerable

Public Class Hashtable
Implements IDictionary

Public Class Hashtable
Implements ICloneable, IDeserializationCallback, IDictionary, ISerializable

Dědičnost

Object

Hashtable

Odvozené

System.Configuration.SettingsAttributeDictionary

System.Configuration.SettingsContext

System.Data.PropertyCollection

System.Printing.IndexedProperties.PrintPropertyDictionary

Atributy

SerializableAttribute ComVisibleAttribute

Implementuje

ICollection IDictionary IEnumerable ICloneable IDeserializationCallback ISerializable

Příklady

Následující příklad ukazuje, jak vytvořit, inicializovat a provádět různé funkce pro Hashtable a jak vytisknout jeho klíče a hodnoty.

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

Poznámky

Každý prvek je pár klíč/hodnota uložený v objektu DictionaryEntry . Klíč nemůže být null, ale hodnota může být.

Důležité

Nedoporučujeme používat Hashtable třídu pro nový vývoj. Místo toho doporučujeme použít obecnou Dictionary<TKey,TValue> třídu. Další informace najdete v tématu Ne generické kolekce, které by se neměly používat na GitHub.

Objekty používané jako klíče jsou Hashtable nutné k přepsání Object.GetHashCode metody (nebo IHashCodeProvider rozhraní) a Object.Equals metody (nebo IComparer rozhraní). Implementace metod i rozhraní musí zpracovávat citlivost velkých a malých písmen stejným způsobem; jinak se Hashtable může chovat nesprávně. Například při vytváření Hashtabletřídy musíte použít CaseInsensitiveHashCodeProvider třídu (nebo jakoukoli implementaci nerozlišující malá a velká IHashCodeProvider písmena) se CaseInsensitiveComparer třídou (nebo jakoukoli implementací nerozlišující malá IComparer a velká písmena).

Tyto metody navíc musí vytvořit stejné výsledky při vyvolání se stejnými parametry, zatímco klíč existuje v souboru Hashtable. Alternativou je použití konstruktoru Hashtable s parametrem IEqualityComparer . Pokud by klíčová rovnost byla jednoduše odkazována na rovnost, zděděná implementace Object.GetHashCode a Object.Equals byla by dostatečná.

Klíčové objekty musí být neměnné, pokud se používají jako klíče v souboru Hashtable.

Při přidání elementu do elementu Hashtablese prvek umístí do kbelíku na základě kódu hash klíče. Následné vyhledávání klíče používá kód hash klíče k hledání pouze v jednom konkrétním kbelíku, čímž výrazně snižuje počet porovnání klíčů potřebných k vyhledání prvku.

Faktor zatížení Hashtable určuje maximální poměr prvků k kbelíkům. Menší faktory zatížení způsobují rychlejší průměrné doby vyhledávání za cenu zvýšené spotřeby paměti. Výchozí faktor zatížení 1,0 obecně poskytuje nejlepší rovnováhu mezi rychlostí a velikostí. Při vytváření je také možné zadat Hashtable jiný faktor zatížení.

Vzhledem k tomu, že se prvky přidají do Hashtable, skutečný zátěžový faktor nárůstu Hashtable . Když skutečný faktor zatížení dosáhne zadaného faktoru zatížení, počet kbelíků v Hashtable sadě se automaticky zvýší na nejmenší primární číslo, které je větší než dvakrát aktuální počet Hashtable kontejnerů.

Každý objekt klíče v objektu Hashtable musí poskytovat svou vlastní hash funkci, ke které je možné přistupovat voláním GetHash. Jakoukoli implementaci IHashCodeProvider objektu je však možné předat konstruktoru Hashtable a tato funkce hash se používá pro všechny objekty v tabulce.

Kapacita a Hashtable je počet prvků, které Hashtable může obsahovat. Vzhledem k tomu, že jsou prvky přidány do Hashtable, kapacita se automaticky zvýší podle potřeby prostřednictvím reallocation.

Pouze rozhraní .NET Framework: U velmi velkých Hashtable objektů můžete zvýšit maximální kapacitu na 2 miliardy prvků v 64bitovém systému nastavením enabled atributu <gcAllowVeryLargeObjects> elementu konfigurace do true prostředí za běhu.

Příkaz foreach jazyka C# (For Eachv Visual Basic) vrátí objekt typu prvků v kolekci. Vzhledem k tomu, že každý prvek Hashtable páru klíč/hodnota je, typ prvku není typem klíče nebo typem hodnoty. Místo toho je DictionaryEntrytyp prvku . Příklad:

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

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

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

Příkaz foreach je obálka kolem enumerátoru, který umožňuje jen čtení z kolekce, nikoli zápis do kolekce.

Vzhledem k tomu, že serializace a deserializace výčtu pro Hashtable určitou může způsobit, že se prvky změní na pořadí, není možné pokračovat v výčtu bez volání Reset metody.

Poznámka

Protože klíče lze dědit a jejich chování změnit, jejich absolutní jedinečnost nelze zaručit porovnáním pomocí Equals metody.

Konstruktory

Hashtable()	Inicializuje novou prázdnou Hashtable instanci třídy pomocí výchozí počáteční kapacity, faktoru zatížení, zprostředkovatele hash kódu a porovnávače.
Hashtable(IDictionary)	Inicializuje novou instanci třídy zkopírováním elementů Hashtable ze zadaného slovníku do nového Hashtable objektu. Nový Hashtable objekt má počáteční kapacitu rovnou počtu zkopírovaných prvků a používá výchozí faktor zatížení, zprostředkovatele kódu hash a porovnávače.
Hashtable(IDictionary, IEqualityComparer)	Inicializuje novou instanci třídy zkopírováním elementů Hashtable ze zadaného slovníku do nového Hashtable objektu. Nový Hashtable objekt má počáteční kapacitu rovnou počtu zkopírovaných prvků a používá výchozí faktor zatížení a zadaný IEqualityComparer objekt.
Hashtable(IDictionary, IHashCodeProvider, IComparer)	Zastaralé. Zastaralé. Inicializuje novou instanci třídy zkopírováním elementů Hashtable ze zadaného slovníku do nového Hashtable objektu. Nový Hashtable objekt má počáteční kapacitu rovnou počtu zkopírovaných prvků a používá výchozí faktor zatížení a zadaný zprostředkovatel kódu hash a porovnávač. Toto rozhraní API je zastaralé. Alternativu najdete v tématu Hashtable(IDictionary, IEqualityComparer).
Hashtable(IDictionary, Single)	Inicializuje novou instanci třídy zkopírováním elementů Hashtable ze zadaného slovníku do nového Hashtable objektu. Nový Hashtable objekt má počáteční kapacitu rovnou počtu zkopírovaných prvků a používá zadaný faktor zatížení a výchozího zprostředkovatele kódu hash a porovnávače.
Hashtable(IDictionary, Single, IEqualityComparer)	Inicializuje novou instanci třídy zkopírováním elementů Hashtable ze zadaného slovníku do nového Hashtable objektu. Nový Hashtable objekt má počáteční kapacitu rovnou počtu zkopírovaných prvků a používá zadaný faktor zatížení a IEqualityComparer objekt.
Hashtable(IDictionary, Single, IHashCodeProvider, IComparer)	Zastaralé. Zastaralé. Inicializuje novou instanci Hashtable třídy zkopírováním prvků ze zadaného slovníku do nového Hashtable objektu. Nový Hashtable objekt má počáteční kapacitu, která se rovná počtu zkopírovaných prvků a používá zadaný faktor zatížení, zprostředkovatele kódu hash a porovnávač.
Hashtable(IEqualityComparer)	Inicializuje novou prázdnou Hashtable instanci třídy pomocí výchozí počáteční kapacity a faktoru zatížení a zadaného IEqualityComparer objektu.
Hashtable(IHashCodeProvider, IComparer)	Zastaralé. Zastaralé. Zastaralé. Inicializuje novou, prázdnou Hashtable instanci třídy pomocí výchozí počáteční kapacity a faktoru zatížení a zadaného zprostředkovatele kódu hash a porovnávače.
Hashtable(Int32)	Inicializuje novou, prázdnou Hashtable instanci třídy pomocí zadané počáteční kapacity a výchozí load factor, hash code provider a comparer.
Hashtable(Int32, IEqualityComparer)	Inicializuje novou prázdnou Hashtable instanci třídy pomocí zadané počáteční kapacity a IEqualityComparervýchozího faktoru zatížení.
Hashtable(Int32, IHashCodeProvider, IComparer)	Zastaralé. Zastaralé. Inicializuje novou prázdnou Hashtable instanci třídy pomocí zadané počáteční kapacity, zprostředkovatele kódu hash, porovnávače a výchozího faktoru zatížení.
Hashtable(Int32, Single)	Inicializuje novou, prázdnou Hashtable instanci třídy pomocí zadané počáteční kapacity a faktoru zatížení a výchozího zprostředkovatele kódu hash a porovnávače.
Hashtable(Int32, Single, IEqualityComparer)	Inicializuje novou prázdnou Hashtable instanci třídy pomocí zadané počáteční kapacity, faktoru zatížení a IEqualityComparer objektu.
Hashtable(Int32, Single, IHashCodeProvider, IComparer)	Zastaralé. Zastaralé. Inicializuje novou prázdnou Hashtable instanci třídy pomocí zadané počáteční kapacity, faktoru zatížení, zprostředkovatel kódu hash a porovnávače.
Hashtable(SerializationInfo, StreamingContext)	Inicializuje novou prázdnou Hashtable instanci třídy, která je serializovatelná pomocí zadané SerializationInfo a StreamingContext objekty.

Vlastnosti

comparer	Zastaralé. Zastaralé. Získá nebo nastaví IComparer použití pro Hashtable.
Count	Získá počet párů klíč/hodnota obsažených v souboru Hashtable.
EqualityComparer	IEqualityComparer Získá použití pro Hashtable.
hcp	Zastaralé. Zastaralé. Získá nebo nastaví objekt, který může vydávat hash kódy.
IsFixedSize	Získá hodnotu určující, zda Hashtable má pevnou velikost.
IsReadOnly	Získá hodnotu, která určuje, zda je Hashtable určena jen pro čtení.
IsSynchronized	Získá hodnotu označující, zda je přístup k této Hashtable synchronizaci (bezpečné vlákno).
Item[Object]	Získá nebo nastaví hodnotu přidruženou k zadanému klíči.
Keys	ICollection Získá obsahující klíče v .Hashtable
SyncRoot	Získá objekt, který lze použít k synchronizaci přístupu k Hashtable.
Values	ICollection Získá obsahující hodnoty v souboru Hashtable.

Metody

Add(Object, Object)	Přidá prvek se zadaným klíčem a hodnotou do objektu Hashtable.
Clear()	Odebere všechny elementy z kolekce Hashtable.
Clone()	Vytvoří použádnou kopii .Hashtable
Contains(Object)	Určuje, zda Hashtable obsahuje konkrétní klíč.
ContainsKey(Object)	Určuje, zda Hashtable obsahuje konkrétní klíč.
ContainsValue(Object)	Určuje, zda Hashtable obsahuje konkrétní hodnotu.
CopyTo(Array, Int32)	Hashtable Zkopíruje prvky do jednorozměrné Array instance v zadaném indexu.
Equals(Object)	Určí, zda se zadaný objekt rovná aktuálnímu objektu. (Zděděno od Object)
GetEnumerator()	IDictionaryEnumerator Vrátí iteruje přes Hashtable.
GetHash(Object)	Vrátí kód hash pro zadaný klíč.
GetHashCode()	Slouží jako výchozí funkce hash. (Zděděno od Object)
GetObjectData(SerializationInfo, StreamingContext)	Implementuje ISerializable rozhraní a vrátí data potřebná k serializaci Hashtable.
GetType()	Type Získá aktuální instanci. (Zděděno od Object)
KeyEquals(Object, Object)	Porovná konkrétní Object klíč s konkrétním klíčem v sadě Hashtable.
MemberwiseClone()	Vytvoří použádnou kopii aktuálního souboru Object. (Zděděno od Object)
OnDeserialization(Object)	Implementuje ISerializable rozhraní a vyvolá událost deserializace po dokončení deserializace.
Remove(Object)	Odebere prvek se zadaným klíčem z objektu Hashtable.
Synchronized(Hashtable)	Vrátí synchronizovaný obálku (bez vláken) pro Hashtable.
ToString()	Vrátí řetězec, který představuje aktuální objekt. (Zděděno od Object)

Explicitní implementace rozhraní

IEnumerable.GetEnumerator()

Vrací enumerátor procházející kolekci.

Metody rozšíření

Cast<TResult>(IEnumerable)	Přetypuje prvky zadaného IEnumerable typu.
OfType<TResult>(IEnumerable)	Filtruje prvky IEnumerable založené na zadaném typu.
AsParallel(IEnumerable)	Umožňuje paralelizaci dotazu.
AsQueryable(IEnumerable)	Převede na IEnumerable IQueryable.

Bezpečný přístup z více vláken

Hashtable je bezpečné vlákno pro použití více vláken čtenáře a jediné vlákno zápisu. Je bezpečné pro více vláken použití, když pouze jedno z vláken provádí operace zápisu (aktualizace), což umožňuje uzamčené čtení za předpokladu, že zapisovací moduly jsou serializovány do Hashtable. Aby bylo možné podporovat více zapisovačů, je nutné provést všechny operace Hashtable prostřednictvím obálky vrácené Synchronized(Hashtable) metodou za předpokladu, že objekt nenačítá Hashtable žádné vlákna.

Výčet prostřednictvím kolekce není vnitřně bezpečným postupem vlákna. I v případě, že jde o synchronizovanou kolekci, mohou úpravy provádět i ostatní vlákna, což způsobuje vyvolání výjimky enumerátorem. K zaručení bezpečnosti přístupu z více vláken můžete buďto zamknout kolekci na celou dobu práce s výčtem, nebo zachycovat výjimky vzniklé v důsledku změn prováděných ostatními vlákny.

Viz také

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