Hashtable Klasa

Definicja

Reprezentuje kolekcję par klucz/wartość, które są zorganizowane na podstawie kodu skrótu klucza.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
Dziedziczenie
Hashtable
Pochodne
Atrybuty
Implementuje

Przykłady

Poniższy przykład pokazuje, jak utworzyć, zainicjować i wykonać różne funkcje do Hashtable i jak wydrukować jego klucze i wartości.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.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ą w obiekcie DictionaryEntry.Each element is a key/value pair stored in a DictionaryEntry object. Klucz nie może być null, ale może być wartością.A key cannot be null, but a value can be.

Ważne

Nie zalecamy używania klasy Hashtable w celu tworzenia nowych rozwiązań.We don't recommend that you use the Hashtable class for new development. Zamiast tego zaleca się użycie klasy generycznej Dictionary<TKey,TValue>.Instead, we recommend that you use the generic Dictionary<TKey,TValue> class. Aby uzyskać więcej informacji, zobacz kolekcje nieogólne nie mogą być używane w serwisie GitHub.For more information, see Non-generic collections shouldn't be used on GitHub.

Obiekty używane jako klucze przez Hashtable muszą przesłaniać metodę Object.GetHashCode (lub interfejs IHashCodeProvider) oraz metodę Object.Equals (lub interfejs IComparer).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). Implementacja obu metod i interfejsów musi obsługiwać rozróżnianie wielkości liter w ten sam sposób; w przeciwnym razie Hashtable może zachowywać się nieprawidłowo.The implementation of both methods and interfaces must handle case sensitivity the same way; otherwise, the Hashtable might behave incorrectly. Na przykład w przypadku tworzenia Hashtable należy użyć klasy CaseInsensitiveHashCodeProvider (lub dowolnej implementacji IHashCodeProvider bez uwzględniania wielkości liter) z klasą CaseInsensitiveComparer (lub dowolną implementacją IComparer bez uwzględniania wielkości liter).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).

Ponadto te metody muszą generować te same wyniki w przypadku wywołania z tymi samymi parametrami, gdy klucz istnieje w Hashtable.Furthermore, these methods must produce the same results when called with the same parameters while the key exists in the Hashtable. Alternatywą jest użycie konstruktora Hashtable z parametrem IEqualityComparer.An alternative is to use a Hashtable constructor with an IEqualityComparer parameter. Jeśli równość klucza była po prostu odwołaniem równości, wystarczy, że dziedziczona implementacja Object.GetHashCode i Object.Equals.If key equality were simply reference equality, the inherited implementation of Object.GetHashCode and Object.Equals would suffice.

Obiekty kluczowe muszą być niezmienne, o ile są używane jako klucze w Hashtable.Key objects must be immutable as long as they are used as keys in the Hashtable.

Gdy element jest dodawany do Hashtable, element jest umieszczany w zasobniku na podstawie kodu skrótu klucza.When an element is added to the Hashtable, the element is placed into a bucket based on the hash code of the key. Kolejne wyszukiwania klucza używają kodu skrótu klucza do wyszukania tylko jednego określonego zasobnika, co znacznie zmniejsza liczbę porównań kluczowych wymaganych do znalezienia elementu.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.

Współczynnik obciążenia Hashtable określa maksymalny stosunek elementów do zasobników.The load factor of a Hashtable determines the maximum ratio of elements to buckets. Mniejsze czynniki obciążenia powodują skrócenie średniego czasu wyszukiwania przy kosztach zwiększonego zużycia pamięci.Smaller load factors cause faster average lookup times at the cost of increased memory consumption. Domyślny współczynnik obciążenia wynoszący 1,0 zazwyczaj zapewnia najlepszą równowagę między szybkością i rozmiarem.The default load factor of 1.0 generally provides the best balance between speed and size. Przy tworzeniu Hashtable można także określić inny współczynnik obciążenia.A different load factor can also be specified when the Hashtable is created.

Gdy elementy są dodawane do Hashtable, faktyczny współczynnik obciążenia Hashtable wzrasta.As elements are added to a Hashtable, the actual load factor of the Hashtable increases. Gdy rzeczywisty współczynnik obciążenia osiągnie określony współczynnik obciążenia, liczba przedziałów w Hashtable zostaje automatycznie zwiększona do najmniejszej liczby, która jest większa niż dwukrotnie bieżąca liczba zasobników Hashtable.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żdy obiekt klucza w Hashtable musi udostępniać własną funkcję mieszania, do której można uzyskać dostęp za pomocą wywołania GetHash.Each key object in the Hashtable must provide its own hash function, which can be accessed by calling GetHash. Jednak każdy obiekt implementujący IHashCodeProvider można przesłać do konstruktora Hashtable i ta funkcja skrótu jest używana dla wszystkich obiektów w tabeli.However, any object implementing IHashCodeProvider can be passed to a Hashtable constructor, and that hash function is used for all objects in the table.

Pojemność Hashtable to liczba elementów, które mogą być przechowywane w Hashtable.The capacity of a Hashtable is the number of elements the Hashtable can hold. Po dodaniu elementów do Hashtable pojemność jest automatycznie zwiększana zgodnie z wymaganiami ponownej alokacji.As elements are added to a Hashtable, the capacity is automatically increased as required through reallocation.

Tylko .NET Framework: Dla bardzo dużych obiektów Hashtable można zwiększyć maksymalną pojemność do 2 000 000 000 elementów w systemie 64-bitowym przez ustawienie atrybutu enabled @no__t elementu konfiguracji <gcAllowVeryLargeObjects> w środowisku czasu wykonywania..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.

Instrukcja foreach C# języka (For Each w Visual Basic) zwraca obiekt typu elementów w kolekcji.The foreach statement of the C# language (For Each in Visual Basic) returns an object of the type of the elements in the collection. Ponieważ każdy element Hashtable jest parą klucz/wartość, typ elementu nie jest typem klucza lub typem wartości.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. Zamiast tego typ elementu jest DictionaryEntry.Instead, the element type is DictionaryEntry. Na przykład:For example:

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

Instrukcja foreach to otoka wokół modułu wyliczającego, która umożliwia tylko odczyt z kolekcji.The foreach statement is a wrapper around the enumerator, which only allows reading from, not writing to, the collection.

Ponieważ Serializacja i deserializacja modułu wyliczającego dla Hashtable może spowodować zmianę kolejności elementów, nie można kontynuować wyliczania bez wywoływania metody Reset.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.

Uwaga

Ponieważ klucze mogą być dziedziczone i ich zachowanie zostało zmienione, ich absolutna unikatowość nie może być gwarantowana przez porównania przy użyciu metody Equals.Because keys can be inherited and their behavior changed, their absolute uniqueness cannot be guaranteed by comparisons using the Equals method.

Konstruktory

Hashtable()

Inicjuje nowe, puste wystąpienie klasy Hashtable przy użyciu domyślnej początkowej pojemności, współczynnika obciążenia, dostawcy kodu skrótu i funkcji porównującej.Initializes a new, empty instance of the Hashtable class using the default initial capacity, load factor, hash code provider, and comparer.

Hashtable(IDictionary)

Inicjuje nowe wystąpienie klasy Hashtable przez skopiowanie elementów z określonego słownika do nowego obiektu Hashtable.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. Nowy obiekt Hashtable ma pojemność początkową równą liczbie skopiowanych elementów i używa domyślnego współczynnika ładowania, dostawcy kodu skrótu i programu porównującego.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)

Inicjuje nowe wystąpienie klasy Hashtable przez skopiowanie elementów z określonego słownika do nowego obiektu Hashtable.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to a new Hashtable object. Nowy obiekt Hashtable ma pojemność początkową równą liczbie skopiowanych elementów i używa domyślnego współczynnika obciążenia i określonego obiektu IEqualityComparer.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)

Inicjuje nowe wystąpienie klasy Hashtable przez skopiowanie elementów z określonego słownika do nowego obiektu Hashtable.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. Nowy obiekt Hashtable ma pojemność początkową 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.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. Ten interfejs API jest nieaktualny.This API is obsolete. Aby zapoznać się z alternatywą, zobacz Hashtable(IDictionary, IEqualityComparer).For an alternative, see Hashtable(IDictionary, IEqualityComparer).

Hashtable(IDictionary, Single)

Inicjuje nowe wystąpienie klasy Hashtable przez skopiowanie elementów z określonego słownika do nowego obiektu Hashtable.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. Nowy obiekt Hashtable ma pojemność początkową równą liczbie skopiowanych elementów i używa określonego współczynnika obciążenia oraz domyślnego dostawcy kodu skrótu i programu porównującego.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)

Inicjuje nowe wystąpienie klasy Hashtable przez skopiowanie elementów z określonego słownika do nowego obiektu Hashtable.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. Nowy obiekt Hashtable ma pojemność początkową równą liczbie skopiowanych elementów i używa określonego współczynnika obciążenia i obiektu IEqualityComparer.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)

Inicjuje nowe wystąpienie klasy Hashtable przez skopiowanie elementów z określonego słownika do nowego obiektu Hashtable.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. Nowy obiekt Hashtable ma pojemność początkową równą liczbie skopiowanych elementów i używa określonego współczynnika obciążenia, dostawcy kodu skrótu i programu porównującego.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)

Inicjuje nowe, puste wystąpienie klasy Hashtable przy użyciu domyślnego współczynnika pojemności początkowej i obciążenia oraz określonego obiektu IEqualityComparer.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)

Inicjuje nowe, puste wystąpienie klasy Hashtable przy użyciu domyślnego współczynnika pojemności początkowej i obciążenia oraz określonego dostawcy kodu skrótu i funkcji porównującej.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)

Inicjuje nowe, puste wystąpienie klasy Hashtable z określoną pojemnością początkową oraz domyślny współczynnik obciążenia, dostawcę kodu skrótu i funkcję porównującą.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)

Inicjuje nowe, puste wystąpienie klasy Hashtable przy użyciu określonej początkowej pojemności i IEqualityComparer i domyślnego współczynnika obciążenia.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)

Inicjuje nowe, puste wystąpienie klasy Hashtable przy użyciu określonej pojemności początkowej, dostawcy kodu skrótu, funkcji porównującej i domyślnego współczynnika obciążenia.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)

Inicjuje nowe, puste wystąpienie klasy Hashtable przy użyciu określonej początkowej pojemności i współczynnika obciążenia oraz domyślnego dostawcy kodu skrótu i funkcji porównującej.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)

Inicjuje nowe, puste wystąpienie klasy Hashtable z określoną pojemnością początkową, współczynnikiem obciążenia i obiektem IEqualityComparer.Initializes a new, empty instance of the Hashtable class using the specified initial capacity, load factor, and IEqualityComparer object.

Hashtable(Int32, Single, IHashCodeProvider, IComparer)

Inicjuje nowe, puste wystąpienie klasy Hashtable przy użyciu określonej pojemności początkowej, współczynnika obciążenia, dostawcy kodu skrótu i funkcji porównującej.Initializes a new, empty instance of the Hashtable class using the specified initial capacity, load factor, hash code provider, and comparer.

Hashtable(SerializationInfo, StreamingContext)

Inicjuje nowe, puste wystąpienie klasy Hashtable, która jest możliwa do serializacji przy użyciu określonych SerializationInfo i StreamingContext obiektów.Initializes a new, empty instance of the Hashtable class that is serializable using the specified SerializationInfo and StreamingContext objects.

Właściwości

comparer

Pobiera lub ustawia IComparer do użycia dla Hashtable.Gets or sets the IComparer to use for the Hashtable.

Count

Pobiera liczbę par klucz/wartość zawartych w Hashtable.Gets the number of key/value pairs contained in the Hashtable.

EqualityComparer

Pobiera IEqualityComparer do użycia dla Hashtable.Gets the IEqualityComparer to use for the Hashtable.

hcp

Pobiera lub ustawia obiekt, który może odnieść kody skrótów.Gets or sets the object that can dispense hash codes.

IsFixedSize

Pobiera wartość wskazującą, czy Hashtable ma stały rozmiar.Gets a value indicating whether the Hashtable has a fixed size.

IsReadOnly

Pobiera wartość wskazującą, czy Hashtable jest tylko do odczytu.Gets a value indicating whether the Hashtable is read-only.

IsSynchronized

Pobiera wartość wskazującą, czy dostęp do Hashtable jest synchronizowany (bezpieczny wątkowo).Gets a value indicating whether access to the Hashtable is synchronized (thread safe).

Item[Object]

Pobiera lub ustawia wartość skojarzoną z określonym kluczem.Gets or sets the value associated with the specified key.

Keys

Pobiera ICollection zawierający klucze w Hashtable.Gets an ICollection containing the keys in the Hashtable.

SyncRoot

Pobiera obiekt, którego można użyć do synchronizowania dostępu do Hashtable.Gets an object that can be used to synchronize access to the Hashtable.

Values

Pobiera ICollection zawierający wartości z Hashtable.Gets an ICollection containing the values in the Hashtable.

Metody

Add(Object, Object)

Dodaje element z określonym kluczem i wartością do Hashtable.Adds an element with the specified key and value into the Hashtable.

Clear()

Usuwa wszystkie elementy z Hashtable.Removes all elements from the Hashtable.

Clone()

Tworzy skróconą kopię Hashtable.Creates a shallow copy of the Hashtable.

Contains(Object)

Określa, czy Hashtable zawiera określony klucz.Determines whether the Hashtable contains a specific key.

ContainsKey(Object)

Określa, czy Hashtable zawiera określony klucz.Determines whether the Hashtable contains a specific key.

ContainsValue(Object)

Określa, czy Hashtable zawiera konkretną wartość.Determines whether the Hashtable contains a specific value.

CopyTo(Array, Int32)

Kopiuje elementy Hashtable do jednowymiarowego wystąpienia Array o określonym indeksie.Copies the Hashtable elements to a one-dimensional Array instance at the specified index.

Equals(Object)

Określa, czy określony obiekt jest równy bieżącemu obiektowi.Determines whether the specified object is equal to the current object.

(Odziedziczone po Object)
GetEnumerator()

Zwraca IDictionaryEnumerator, który wykonuje iterację przez Hashtable.Returns an IDictionaryEnumerator that iterates through the Hashtable.

GetHash(Object)

Zwraca kod skrótu dla określonego klucza.Returns the hash code for the specified key.

GetHashCode()

Służy jako domyślna funkcja skrótu.Serves as the default hash function.

(Odziedziczone po Object)
GetObjectData(SerializationInfo, StreamingContext)

Implementuje interfejs ISerializable i zwraca dane, które są konieczne do serializacji Hashtable.Implements the ISerializable interface and returns the data needed to serialize the Hashtable.

GetType()

Type Pobiera bieżące wystąpienie.Gets the Type of the current instance.

(Odziedziczone po Object)
KeyEquals(Object, Object)

Porównuje konkretną Object z określonym kluczem w Hashtable.Compares a specific Object with a specific key in the Hashtable.

MemberwiseClone()

Tworzy skróconą kopię bieżącego Objectelementu.Creates a shallow copy of the current Object.

(Odziedziczone po Object)
OnDeserialization(Object)

Implementuje interfejs ISerializable i wywołuje zdarzenie deserializacji po zakończeniu deserializacji.Implements the ISerializable interface and raises the deserialization event when the deserialization is complete.

Remove(Object)

Usuwa element z określonym kluczem z Hashtable.Removes the element with the specified key from the Hashtable.

Synchronized(Hashtable)

Zwraca zsynchronizowaną (z bezpiecznym wątkem) otokę dla Hashtable.Returns a synchronized (thread-safe) wrapper for the Hashtable.

ToString()

Zwraca ciąg, który reprezentuje bieżący obiekt.Returns a string that represents the current object.

(Odziedziczone po Object)

Jawne implementacje interfejsu

IEnumerable.GetEnumerator()

Zwraca moduł wyliczający, który dokonuje iteracji w kolekcji.Returns an enumerator that iterates through a collection.

Metody rozszerzania

Cast<TResult>(IEnumerable)

Rzutuje elementy IEnumerable do określonego typu.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

Filtruje elementy IEnumerable w oparciu o określony typ.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

Włącza przetwarzanie równoległe zapytania.Enables parallelization of a query.

AsQueryable(IEnumerable)

IEnumerable KonwertujeIQueryabledo.Converts an IEnumerable to an IQueryable.

Dotyczy

Bezpieczeństwo wątkowe

Hashtable jest bezpieczny wątkowo do użytku przez wiele wątków czytnika i jeden wątek zapisujący.Hashtable is thread safe for use by multiple reader threads and a single writing thread. Wątek jest bezpieczny dla wielu wątków, gdy tylko jeden z wątków wykonuje operacje Write (Update), które umożliwia odczyty bez blokady, pod warunkiem, że moduły zapisujące są serializowane do 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. Aby zapewnić obsługę wielu składników zapisywania, wszystkie operacje na Hashtable muszą zostać wykonane przez otokę zwróconą przez metodę Synchronized(Hashtable), pod warunkiem, że nie ma wątków odczytujących obiekt Hashtable.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.

Wyliczanie za pomocą kolekcji nie jest wewnętrznie procedurą bezpiecznego wątku.Enumerating through a collection is intrinsically not a thread safe procedure. Nawet gdy kolekcja jest synchronizowana, inne wątki nadal mogą ją modyfikować. Powoduje to zgłaszanie wyjątku przez moduł wyliczający.Even when a collection is synchronized, other threads can still modify the collection, which causes the enumerator to throw an exception. 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.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.

Zobacz też