Hashtable Hashtable Hashtable Hashtable Class

Definice

Představuje kolekci párů klíč/hodnota, které jsou uspořádány na základě kódu hodnoty hash klíče.Represents a collection of key/value pairs that are organized based on the hash code of the key.

public ref class Hashtable : ICloneable, System::Collections::IDictionary, System::Runtime::Serialization::IDeserializationCallback, System::Runtime::Serialization::ISerializable
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public class Hashtable : ICloneable, System.Collections.IDictionary, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable
type Hashtable = class
    interface IDictionary
    interface ISerializable
    interface IDeserializationCallback
    interface ICloneable
    interface ICollection
    interface IEnumerable
Public Class Hashtable
Implements ICloneable, IDeserializationCallback, IDictionary, ISerializable
Dědičnost
HashtableHashtableHashtableHashtable
Odvozené
Atributy
Implementuje

Příklady

Následující příklad ukazuje, jak vytváření, inicializace a provádění různých funkcí Hashtable a o tom, který vytiskne jeho klíče a hodnoty.The following example shows how to create, initialize and perform various functions to a Hashtable and how to print out its keys and values.

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
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 dvojice klíč/hodnota uložená v DictionaryEntry objektu.Each element is a key/value pair stored in a DictionaryEntry object. Klíč nemůže být null, ale může být hodnota.A key cannot be null, but a value can be.

Důležité

Nedoporučujeme používat Hashtable třídy pro vývoj nových projektů.We don't recommend that you use the Hashtable class for new development. Namísto toho doporučujeme použít Obecné Dictionary<TKey,TValue> třídy.Instead, we recommend that you use the generic Dictionary<TKey,TValue> class. Další informace najdete v tématu neobecné kolekce by se neměly na Githubu.For more information, see Non-generic collections shouldn't be used on GitHub.

Objekty používané jako klíče podle Hashtable je potřeba přepsat Object.GetHashCode – metoda (nebo IHashCodeProvider rozhraní) a Object.Equals – metoda (nebo IComparer rozhraní).The objects used as keys by a Hashtable are required to override the Object.GetHashCode method (or the IHashCodeProvider interface) and the Object.Equals method (or the IComparer interface). Implementace metody a rozhraní, musí umět zpracovat rozlišování velikosti písmen stejným způsobem jako; v opačném případě Hashtable může být neočekávané chování.The implementation of both methods and interfaces must handle case sensitivity the same way; otherwise, the Hashtable might behave incorrectly. Například při vytváření Hashtable, je nutné použít CaseInsensitiveHashCodeProvider třídy (nebo jakékoli velká a malá písmena IHashCodeProvider implementace) s CaseInsensitiveComparer třídy (nebo jakékoli velkých a malých písmen IComparer implementace).For example, when creating a Hashtable, you must use the CaseInsensitiveHashCodeProvider class (or any case-insensitive IHashCodeProvider implementation) with the CaseInsensitiveComparer class (or any case-insensitive IComparer implementation).

Kromě toho musíte tyto metody vytvářejí stejné výsledky při volání se stejnými parametry, zatímco klíč existuje v Hashtable.Furthermore, these methods must produce the same results when called with the same parameters while the key exists in the Hashtable. Další možností je použít Hashtable konstruktor s IEqualityComparer parametru.An alternative is to use a Hashtable constructor with an IEqualityComparer parameter. Pokud byly klíče rovnosti jednoduše referenční rovnost, zděděná implementace metody Object.GetHashCode a Object.Equals bude stačit.If key equality were simply reference equality, the inherited implementation of Object.GetHashCode and Object.Equals would suffice.

Klíčové objekty musí být tak dlouho, dokud se používají jako klíče v neměnných Hashtable.Key objects must be immutable as long as they are used as keys in the Hashtable.

Při přidání elementu Hashtable, prvek umístěn do kontejneru na základě kódu hodnoty hash klíče.When an element is added to the Hashtable, the element is placed into a bucket based on the hash code of the key. Následná vyhledávání klíče slouží hodnota hash klíče k vyhledání ve jenom jeden konkrétní sadě, tedy výrazně omezuje počet klíčů porovnání se požaduje pro nalezení prvku.Subsequent lookups of the key use the hash code of the key to search in only one particular bucket, thus substantially reducing the number of key comparisons required to find an element.

Faktor zatížení Hashtable Určuje poměr maximálně prvků, které se kbelíků.The load factor of a Hashtable determines the maximum ratio of elements to buckets. Menší faktory zatížení způsobit rychlejší vyhledávání průměrné doby za cenu využití paměti.Smaller load factors cause faster average lookup times at the cost of increased memory consumption. Výchozí faktor zaplnění 1.0 obecně poskytuje nejlepší poměr mezi rychlostí a velikosti.The default load factor of 1.0 generally provides the best balance between speed and size. Různé vytížení může být také zadán při Hashtable se vytvoří.A different load factor can also be specified when the Hashtable is created.

Jak prvky jsou přidány do Hashtable, faktor vlastní operaci načtení Hashtable zvyšuje.As elements are added to a Hashtable, the actual load factor of the Hashtable increases. Když faktor skutečné zatížení dosáhne faktor zaplnění zadaný, počet kbelíků, v Hashtable automaticky navýšena na nejmenší prime číslo, které je větší než dvakrát aktuální počet Hashtable kbelíků.When the actual load factor reaches the specified load factor, the number of buckets in the Hashtable is automatically increased to the smallest prime number that is larger than twice the current number of Hashtable buckets.

Každý objekt klíče v Hashtable musíte zadat své vlastní funkce hash, která je přístupná pomocí volání GetHash.Each key object in the Hashtable must provide its own hash function, which can be accessed by calling GetHash. Ale žádný objekt implementace IHashCodeProvider mohou být předány Hashtable konstruktor a že se používá funkce hash pro všechny objekty v tabulce.However, any object implementing IHashCodeProvider can be passed to a Hashtable constructor, and that hash function is used for all objects in the table.

Kapacita Hashtable je počet elementů Hashtable může obsahovat.The capacity of a Hashtable is the number of elements the Hashtable can hold. Jak prvky jsou přidány do Hashtable, je automaticky zvýšit kapacitu podle potřeby prostřednictvím přerozdělení.As elements are added to a Hashtable, the capacity is automatically increased as required through reallocation.

Pouze v rozhraní .NET framework: Pro velmi velké Hashtable objekty, můžete zvýšit maximální kapacitu na 2 miliardy elementy v 64bitovém systému tak, že nastavíte enabled atribut <gcAllowVeryLargeObjects> prvku konfigurace true v běhové prostředí..NET Framework only: For very large Hashtable objects, you can increase the maximum capacity to 2 billion elements on a 64-bit system by setting the enabled attribute of the <gcAllowVeryLargeObjects> configuration element to true in the run-time environment.

foreach Příkaz jazyka C# (For Each v jazyce Visual Basic) vrátí objekt typ prvků v kolekci.The foreach statement of the C# language (For Each in Visual Basic) returns an object of the type of the elements in the collection. Protože každý prvek Hashtable je dvojice klíč/hodnota, typ elementu není typ klíče nebo typu hodnoty.Since each element of the Hashtable is a key/value pair, the element type is not the type of the key or the type of the value. Místo toho typ prvku je DictionaryEntry.Instead, the element type is DictionaryEntry. Příklad:For example:

for each(DictionaryEntry de in myHashtable)
{
    // ...
}
foreach(DictionaryEntry de in myHashtable)
{
    // ...
}
For Each de As DictionaryEntry In myHashtable
    ' ...
Next de

foreach Příkaz představuje obálku kolem enumerátor, který povoluje jen čtení z nezapíše se do kolekce.The foreach statement is a wrapper around the enumerator, which only allows reading from, not writing to, the collection.

Protože serializaci a deserializaci enumerátor pro Hashtable může způsobit, že prvky, které mají být pořadí změníte, není možné pokračovat ve vytváření výčtu bez volání Reset metody.Because serializing and deserializing an enumerator for a Hashtable can cause the elements to become reordered, it is not possible to continue enumeration without calling the Reset method.

Poznámka

Protože je možné zdědit klíčů a jejich chování změnit, jejich absolutní jedinečnost nelze zaručit podle porovnání pomocí Equals metody.Because keys can be inherited and their behavior changed, their absolute uniqueness cannot be guaranteed by comparisons using the Equals method.

Konstruktory

Hashtable() Hashtable() Hashtable() Hashtable()

Inicializuje novou, prázdnou instanci Hashtable pomocí výchozí počáteční kapacitu, zatížení faktor, zprostředkovatele kódu hash a porovnávání.Initializes a new, empty instance of the Hashtable class using the default initial capacity, load factor, hash code provider, and comparer.

Hashtable(IDictionary) Hashtable(IDictionary) Hashtable(IDictionary) Hashtable(IDictionary)

Inicializuje novou instanci třídy Hashtable zkopírováním prvky ze zadaného slovníku k novému Hashtable objektu.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. Nové Hashtable objektu se rovná počtu elementů zkopírovaných počáteční kapacitu a používá výchozí faktor zaplnění, zprostředkovatele kódu hash a porovnávání.The new Hashtable object has an initial capacity equal to the number of elements copied, and uses the default load factor, hash code provider, and comparer.

Hashtable(IDictionary, IEqualityComparer) Hashtable(IDictionary, IEqualityComparer) Hashtable(IDictionary, IEqualityComparer) Hashtable(IDictionary, IEqualityComparer)

Inicializuje novou instanci třídy Hashtable zkopírováním prvky ze zadaného slovníku na nový Hashtable objektu.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to a new Hashtable object. Nové Hashtable objektu se rovná počtu elementů zkopírovaných počáteční kapacitu a používá výchozí faktor zaplnění a zadaný IEqualityComparer objektu.The new Hashtable object has an initial capacity equal to the number of elements copied, and uses the default load factor and the specified IEqualityComparer object.

Hashtable(IDictionary, IHashCodeProvider, IComparer) Hashtable(IDictionary, IHashCodeProvider, IComparer) Hashtable(IDictionary, IHashCodeProvider, IComparer) Hashtable(IDictionary, IHashCodeProvider, IComparer)

Inicializuje novou instanci třídy Hashtable zkopírováním prvky ze zadaného slovníku k novému Hashtable objektu.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. Nové Hashtable objektu se rovná počtu elementů zkopírovaných počáteční kapacitu a používá výchozí faktor zaplnění a zprostředkovatele kódu zadanou hodnotu hash a porovnávací metody.The new Hashtable object has an initial capacity equal to the number of elements copied, and uses the default load factor, and the specified hash code provider and comparer. Toto rozhraní API je zastaralé.This API is obsolete. Alternativu, naleznete v tématu Hashtable(IDictionary, IEqualityComparer).For an alternative, see Hashtable(IDictionary, IEqualityComparer).

Hashtable(IDictionary, Single) Hashtable(IDictionary, Single) Hashtable(IDictionary, Single) Hashtable(IDictionary, Single)

Inicializuje novou instanci třídy Hashtable zkopírováním prvky ze zadaného slovníku k novému Hashtable objektu.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. Nové Hashtable objektu se rovná počtu elementů zkopírovaných počáteční kapacitu a používá zadané vytížení a výchozí hodnota hash kódu zprostředkovatele a porovnávací metody.The new Hashtable object has an initial capacity equal to the number of elements copied, and uses the specified load factor, and the default hash code provider and comparer.

Hashtable(IDictionary, Single, IEqualityComparer) Hashtable(IDictionary, Single, IEqualityComparer) Hashtable(IDictionary, Single, IEqualityComparer) Hashtable(IDictionary, Single, IEqualityComparer)

Inicializuje novou instanci třídy Hashtable zkopírováním prvky ze zadaného slovníku k novému Hashtable objektu.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. Nové Hashtable objektu se rovná počtu elementů zkopírovaných počáteční kapacitu a používá zadané vytížení a IEqualityComparer objektu.The new Hashtable object has an initial capacity equal to the number of elements copied, and uses the specified load factor and IEqualityComparer object.

Hashtable(IDictionary, Single, IHashCodeProvider, IComparer) Hashtable(IDictionary, Single, IHashCodeProvider, IComparer) Hashtable(IDictionary, Single, IHashCodeProvider, IComparer) Hashtable(IDictionary, Single, IHashCodeProvider, IComparer)

Inicializuje novou instanci třídy Hashtable zkopírováním prvky ze zadaného slovníku k novému Hashtable objektu.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. Nové Hashtable objektu se rovná počtu elementů zkopírovaných počáteční kapacitu a používá zadané vytížení, zprostředkovatele kódu hash a porovnávání.The new Hashtable object has an initial capacity equal to the number of elements copied, and uses the specified load factor, hash code provider, and comparer.

Hashtable(IEqualityComparer) Hashtable(IEqualityComparer) Hashtable(IEqualityComparer) Hashtable(IEqualityComparer)

Inicializuje novou, prázdnou instanci Hashtable pomocí výchozí počáteční kapacitu a načíst factor a zadaný IEqualityComparer objektu.Initializes a new, empty instance of the Hashtable class using the default initial capacity and load factor, and the specified IEqualityComparer object.

Hashtable(IHashCodeProvider, IComparer) Hashtable(IHashCodeProvider, IComparer) Hashtable(IHashCodeProvider, IComparer) Hashtable(IHashCodeProvider, IComparer)

Inicializuje novou, prázdnou instanci Hashtable pomocí výchozí počáteční kapacitu a načíst faktor a zprostředkovatele kódu zadanou hodnotu hash a porovnávací metody.Initializes a new, empty instance of the Hashtable class using the default initial capacity and load factor, and the specified hash code provider and comparer.

Hashtable(Int32) Hashtable(Int32) Hashtable(Int32) Hashtable(Int32)

Inicializuje novou, prázdnou instanci Hashtable třídy pomocí zadané počáteční kapacitu a výchozí faktor zaplnění, zprostředkovatele kódu hash a porovnávací metody.Initializes a new, empty instance of the Hashtable class using the specified initial capacity, and the default load factor, hash code provider, and comparer.

Hashtable(Int32, IEqualityComparer) Hashtable(Int32, IEqualityComparer) Hashtable(Int32, IEqualityComparer) Hashtable(Int32, IEqualityComparer)

Inicializuje novou, prázdnou instanci Hashtable třídy pomocí zadané počáteční kapacitu a IEqualityComparera faktor zaplnění výchozí.Initializes a new, empty instance of the Hashtable class using the specified initial capacity and IEqualityComparer, and the default load factor.

Hashtable(Int32, IHashCodeProvider, IComparer) Hashtable(Int32, IHashCodeProvider, IComparer) Hashtable(Int32, IHashCodeProvider, IComparer) Hashtable(Int32, IHashCodeProvider, IComparer)

Inicializuje novou, prázdnou instanci Hashtable třídy pomocí zadané počáteční kapacitu, zprostředkovatele kódu hash, porovnávací metody a faktor zaplnění výchozí.Initializes a new, empty instance of the Hashtable class using the specified initial capacity, hash code provider, comparer, and the default load factor.

Hashtable(Int32, Single) Hashtable(Int32, Single) Hashtable(Int32, Single) Hashtable(Int32, Single)

Inicializuje novou, prázdnou instanci Hashtable třídy pomocí zadané počáteční kapacitu a načíst faktor a výchozí hodnota hash kódu zprostředkovatele a porovnávací metody.Initializes a new, empty instance of the Hashtable class using the specified initial capacity and load factor, and the default hash code provider and comparer.

Hashtable(Int32, Single, IEqualityComparer) Hashtable(Int32, Single, IEqualityComparer) Hashtable(Int32, Single, IEqualityComparer) Hashtable(Int32, Single, IEqualityComparer)

Inicializuje novou, prázdnou instanci Hashtable třídy pomocí zadané počáteční kapacitu, faktor zaplnění a IEqualityComparer objektu.Initializes a new, empty instance of the Hashtable class using the specified initial capacity, load factor, and IEqualityComparer object.

Hashtable(Int32, Single, IHashCodeProvider, IComparer) Hashtable(Int32, Single, IHashCodeProvider, IComparer) Hashtable(Int32, Single, IHashCodeProvider, IComparer) Hashtable(Int32, Single, IHashCodeProvider, IComparer)

Inicializuje novou, prázdnou instanci Hashtable třídy pomocí zadané počáteční kapacitu, zatížení faktor, zprostředkovatele kódu hash a porovnávání.Initializes a new, empty instance of the Hashtable class using the specified initial capacity, load factor, hash code provider, and comparer.

Hashtable(SerializationInfo, StreamingContext) Hashtable(SerializationInfo, StreamingContext) Hashtable(SerializationInfo, StreamingContext) Hashtable(SerializationInfo, StreamingContext)

Inicializuje novou, prázdnou instanci Hashtable třídu, která je serializovatelný, pomocí zadaného SerializationInfo a StreamingContext objekty.Initializes a new, empty instance of the Hashtable class that is serializable using the specified SerializationInfo and StreamingContext objects.

Vlastnosti

comparer comparer comparer comparer

Získá nebo nastaví IComparer pro Hashtable.Gets or sets the IComparer to use for the Hashtable.

Count Count Count Count

Získá počet dvojic klíč/hodnota obsažených ve Hashtable.Gets the number of key/value pairs contained in the Hashtable.

EqualityComparer EqualityComparer EqualityComparer EqualityComparer

Získá IEqualityComparer pro Hashtable.Gets the IEqualityComparer to use for the Hashtable.

hcp hcp hcp hcp

Získá nebo nastaví objekt, který se obejít kódů hash.Gets or sets the object that can dispense hash codes.

IsFixedSize IsFixedSize IsFixedSize IsFixedSize

Získává hodnotu označující, zda Hashtable má pevnou velikost.Gets a value indicating whether the Hashtable has a fixed size.

IsReadOnly IsReadOnly IsReadOnly IsReadOnly

Získává hodnotu označující, zda Hashtable je jen pro čtení.Gets a value indicating whether the Hashtable is read-only.

IsSynchronized IsSynchronized IsSynchronized IsSynchronized

Získá hodnotu, která určuje, zda přístup k Hashtable se synchronizují (bezpečný).Gets a value indicating whether access to the Hashtable is synchronized (thread safe).

Item[Object] Item[Object] Item[Object] Item[Object]

Získá nebo nastaví hodnotu přidruženou k zadanému klíči.Gets or sets the value associated with the specified key.

Keys Keys Keys Keys

Získá ICollection obsahující klíče ve slovníku Hashtable.Gets an ICollection containing the keys in the Hashtable.

SyncRoot SyncRoot SyncRoot SyncRoot

Získá objekt, který slouží k synchronizaci přístupu k Hashtable.Gets an object that can be used to synchronize access to the Hashtable.

Values Values Values Values

Získá ICollection obsahující hodnoty ve Hashtable.Gets an ICollection containing the values in the Hashtable.

Metody

Add(Object, Object) Add(Object, Object) Add(Object, Object) Add(Object, Object)

Přidá element se zadaným klíčem a hodnotou do Hashtable.Adds an element with the specified key and value into the Hashtable.

Clear() Clear() Clear() Clear()

Odebere všechny prvky z Hashtable.Removes all elements from the Hashtable.

Clone() Clone() Clone() Clone()

Vytvoří Mělkou kopii Hashtable.Creates a shallow copy of the Hashtable.

Contains(Object) Contains(Object) Contains(Object) Contains(Object)

Určuje, zda Hashtable obsahuje konkrétní klíč.Determines whether the Hashtable contains a specific key.

ContainsKey(Object) ContainsKey(Object) ContainsKey(Object) ContainsKey(Object)

Určuje, zda Hashtable obsahuje konkrétní klíč.Determines whether the Hashtable contains a specific key.

ContainsValue(Object) ContainsValue(Object) ContainsValue(Object) ContainsValue(Object)

Určuje, zda Hashtable obsahuje určitou hodnotu.Determines whether the Hashtable contains a specific value.

CopyTo(Array, Int32) CopyTo(Array, Int32) CopyTo(Array, Int32) CopyTo(Array, Int32)

Kopie Hashtable prvků, které mají jednorozměrný Array instance v zadaném indexu.Copies the Hashtable elements to a one-dimensional Array instance at the specified index.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Určuje, zda se zadaný objekt rovná aktuálnímu objektu.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetEnumerator() GetEnumerator() GetEnumerator() GetEnumerator()

Vrátí IDictionaryEnumerator , který iteruje Hashtable.Returns an IDictionaryEnumerator that iterates through the Hashtable.

GetHash(Object) GetHash(Object) GetHash(Object) GetHash(Object)

Vrátí hodnotu hash pro zadaný klíč.Returns the hash code for the specified key.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Slouží jako výchozí funkce hash.Serves as the default hash function.

(Inherited from Object)
GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext)

Implementuje ISerializable rozhraní a vrací data potřebná k serializaci Hashtable.Implements the ISerializable interface and returns the data needed to serialize the Hashtable.

GetType() GetType() GetType() GetType()

Získá Type aktuální instance.Gets the Type of the current instance.

(Inherited from Object)
KeyEquals(Object, Object) KeyEquals(Object, Object) KeyEquals(Object, Object) KeyEquals(Object, Object)

Porovnává konkrétní Object s určitým klíčem ve Hashtable.Compares a specific Object with a specific key in the Hashtable.

MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Vytvoří Mělkou kopii aktuální Object.Creates a shallow copy of the current Object.

(Inherited from Object)
OnDeserialization(Object) OnDeserialization(Object) OnDeserialization(Object) OnDeserialization(Object)

Implementuje ISerializable rozhraní a vyvolává událost deserializace po dokončení rekonstrukce.Implements the ISerializable interface and raises the deserialization event when the deserialization is complete.

Remove(Object) Remove(Object) Remove(Object) Remove(Object)

Odebere element se zadaným klíčem z Hashtable.Removes the element with the specified key from the Hashtable.

Synchronized(Hashtable) Synchronized(Hashtable) Synchronized(Hashtable) Synchronized(Hashtable)

Vrátí synchronizované obálky (bezpečná pro vlákno) pro Hashtable.Returns a synchronized (thread-safe) wrapper for the Hashtable.

ToString() ToString() ToString() ToString()

Vrací řetězec, který představuje aktuální objekt.Returns a string that represents the current object.

(Inherited from Object)

Explicitní implementace rozhraní

IEnumerable.GetEnumerator() IEnumerable.GetEnumerator() IEnumerable.GetEnumerator() IEnumerable.GetEnumerator()

Vrátí enumerátor, který iteruje kolekci.Returns an enumerator that iterates through a collection.

Extension Methods

Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable)

Přetypování prvky IEnumerable do zadaného typu.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable)

Filtruje prvky IEnumerable podle zadaného typu.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable)

Povolí paralelizaci dotazu.Enables parallelization of a query.

AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable)

Převede IEnumerable do IQueryable.Converts an IEnumerable to an IQueryable.

Platí pro

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

Hashtable vlákno je bezpečný pro použití více vláken čtečky a jeden zápis vláknem.Hashtable is thread safe for use by multiple reader threads and a single writing thread. Je bezpečné pro vlákna pro více vláken použít, když pouze jedno z vláken provádění operací zápisu (update), která umožňuje bez zámku čtení za předpokladu, že jsou zapisovače serializován, chcete-li Hashtable.It is thread safe for multi-thread use when only one of the threads perform write (update) operations, which allows for lock-free reads provided that the writers are serialized to the Hashtable. Pro podporu více zapisovačů všechny operace na Hashtable se musí provést prostřednictvím obálky vrácené Synchronized(Hashtable) metodě, že neexistují žádná vlákna čtení Hashtable objektu.To support multiple writers all operations on the Hashtable must be done through the wrapper returned by the Synchronized(Hashtable) method, provided that there are no threads reading the Hashtable object.

Výčet prostřednictvím kolekce není bezpečné procedura vlákna.Enumerating through a collection is intrinsically not a thread safe procedure. 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.Even when a collection is synchronized, other threads can still modify the collection, which causes the enumerator to throw an exception. 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.To guarantee thread safety during enumeration, you can either lock the collection during the entire enumeration or catch the exceptions resulting from changes made by other threads.

Viz také