Hashtable Sınıf

Tanım

Anahtarın karma koduna göre düzenlenmiş anahtar/değer çiftleri koleksiyonunu temsil eder.Represents a collection of key/value pairs that are organized based on the hash code of the key.

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
Devralma
Hashtable
Türetilmiş
Öznitelikler
Uygulamalar

Örnekler

Aşağıdaki örnek, için çeşitli işlevlerin nasıl oluşturulduğunu, başlatılacağını ve gerçekleştirileceğini Hashtable ve anahtar ve değerlerini nasıl yazdırakullanacağınızı gösterir.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
#>

Açıklamalar

Her öğe, bir nesnesinde depolanan bir anahtar/değer çiftidir DictionaryEntry .Each element is a key/value pair stored in a DictionaryEntry object. Anahtar olamaz null , ancak bir değer olabilir.A key cannot be null, but a value can be.

Önemli

HashtableYeni geliştirme için sınıfını kullanmanızı önermiyoruz.We don't recommend that you use the Hashtable class for new development. Bunun yerine, genel sınıfını kullanmanızı öneririz Dictionary<TKey,TValue> .Instead, we recommend that you use the generic Dictionary<TKey,TValue> class. Daha fazla bilgi için bkz. GitHub 'da genel olmayan koleksiyonlar kullanılmamalıdır .For more information, see Non-generic collections shouldn't be used on GitHub.

Bir tarafından anahtar olarak kullanılan nesneler Hashtable , Object.GetHashCode Yöntemi (veya IHashCodeProvider arabirimi) ve Object.Equals Yöntemi (ya da IComparer arabirimini) geçersiz kılmak için gereklidir.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). Yöntemlerin ve arabirimlerin uygulanması aynı şekilde büyük/küçük harf duyarlılığını de işlemelidir; Aksi takdirde, Hashtable yanlış davranabilir.The implementation of both methods and interfaces must handle case sensitivity the same way; otherwise, the Hashtable might behave incorrectly. Örneğin, oluştururken, sınıfı (veya büyük/küçük Hashtable CaseInsensitiveHashCodeProvider harf duyarsız uygulama) ile sınıfı (veya büyük/küçük harf duyarsız IHashCodeProvider uygulama) kullanmanız gerekir CaseInsensitiveComparer IComparer .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).

Ayrıca, bu yöntemler, içinde anahtar mevcut olsa da aynı parametrelerle çağrıldığında aynı sonuçları üretmelidir Hashtable .Furthermore, these methods must produce the same results when called with the same parameters while the key exists in the Hashtable. Bir alternatif, bir Hashtable oluşturucunun parametresi ile kullanılması IEqualityComparer .An alternative is to use a Hashtable constructor with an IEqualityComparer parameter. Anahtar eşitlik yalnızca eşitlik Object.GetHashCode ile başvurulsaydı, devralınan ve ' nin devralınmış uygulamasıdır Object.Equals .If key equality were simply reference equality, the inherited implementation of Object.GetHashCode and Object.Equals would suffice.

Anahtar nesneler, içinde anahtar olarak kullanıldıkları sürece sabit olmalıdır Hashtable .Key objects must be immutable as long as they are used as keys in the Hashtable.

Öğesine bir öğe eklendiğinde Hashtable , öğesi anahtarın karma koduna göre bir sepete yerleştirilir.When an element is added to the Hashtable, the element is placed into a bucket based on the hash code of the key. Anahtarın sonraki aramaları, yalnızca tek bir demet içinde arama yapmak için anahtarın karma kodunu kullanır, bu nedenle bir öğe bulmak için gereken anahtar karşılaştırmaların sayısını önemli ölçüde azaltır.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.

Bir öğesinin yük faktörü, Hashtable öğelerin demetlere en büyük oranını belirler.The load factor of a Hashtable determines the maximum ratio of elements to buckets. Daha küçük yük etmenleri, artan bellek tüketiminin maliyetinde daha hızlı ortalama arama sürelerine neden olur.Smaller load factors cause faster average lookup times at the cost of increased memory consumption. Varsayılan 1,0 yük faktörü genellikle hız ve boyut arasındaki en iyi dengeyi sağlar.The default load factor of 1.0 generally provides the best balance between speed and size. Oluşturulduğunda farklı bir yük faktörü de belirtilebilir Hashtable .A different load factor can also be specified when the Hashtable is created.

Öğesi öğesine eklendiğinde Hashtable , artar gerçek yük faktörü Hashtable .As elements are added to a Hashtable, the actual load factor of the Hashtable increases. Gerçek yük faktörü belirtilen yük etmenlerine ulaştığında, içindeki demetlerin sayısı Hashtable otomatik olarak geçerli demet sayısından daha büyük olan en küçük asal sayıya yükseltilir 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.

İçindeki her anahtar nesnesinin, Hashtable çağırarak erişilebilen kendi karma işlevini sağlaması gerekir GetHash .Each key object in the Hashtable must provide its own hash function, which can be accessed by calling GetHash. Ancak, uygulayan herhangi IHashCodeProvider bir nesne bir Hashtable oluşturucuya geçirilebilir ve bu karma işlev tablodaki tüm nesneler için kullanılır.However, any object implementing IHashCodeProvider can be passed to a Hashtable constructor, and that hash function is used for all objects in the table.

Bir öğesinin kapasitesi, Hashtable Hashtable tutabileceğiniz öğe sayısıdır.The capacity of a Hashtable is the number of elements the Hashtable can hold. Öğesi öğesine eklendikçe Hashtable , yeniden tahsisatın yapılması için kapasite otomatik olarak artar.As elements are added to a Hashtable, the capacity is automatically increased as required through reallocation.

Yalnızca .NET Framework: Çok büyük Hashtable nesneler için, enabled <gcAllowVeryLargeObjects> yapılandırma öğesinin özniteliğini true çalışma zamanı ortamında olarak ayarlayarak 64 bit sistemdeki en fazla 2.000.000.000 öğeye kapasiteyi artırabilirsiniz..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.

foreachC# dilinin ( For Each Visual Basic) deyimleri koleksiyondaki öğelerin türünün bir nesnesini döndürür.The foreach statement of the C# language (For Each in Visual Basic) returns an object of the type of the elements in the collection. Öğesinin her öğesi Hashtable bir anahtar/değer çifti olduğundan, öğe türü anahtarın türü veya değer türü değil.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. Bunun yerine, öğe türü DictionaryEntry .Instead, the element type is DictionaryEntry. Örnek:For example:

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

foreachİfade, bir Numaralandırıcı etrafında bir sarmalayıcıdır. Bu, koleksiyon için yalnızca okuma ve yazma için izin verir.The foreach statement is a wrapper around the enumerator, which only allows reading from, not writing to, the collection.

Bir Numaralandırıcının serileştirilmesi ve serisini Hashtable çıkarmak öğelerin yeniden düzenlenmesine neden olabileceğinden, yöntemi çağrılmadan numaralandırmaya devam etmek mümkün değildir 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.

Not

Anahtarlar devralınabileceğinden ve davranışları değiştiği için, yöntemi kullanılarak karşılaştırmalar tarafından mutlak benzersizliği garanti edilemez Equals .Because keys can be inherited and their behavior changed, their absolute uniqueness cannot be guaranteed by comparisons using the Equals method.

Oluşturucular

Hashtable()

HashtableVarsayılan başlangıç kapasitesini, yük etmenini, karma kod sağlayıcısını ve karşılaştırıcıyı kullanarak sınıfının yeni, boş bir örneğini başlatır.Initializes a new, empty instance of the Hashtable class using the default initial capacity, load factor, hash code provider, and comparer.

Hashtable(IDictionary)

HashtableBelirtilen sözlükten öğeleri yeni nesneye kopyalayarak sınıfın yeni bir örneğini başlatır Hashtable .Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. Yeni Hashtable nesne, kopyalanmış öğe sayısına eşit olan bir başlangıç kapasitesine sahiptir ve varsayılan Yük etmenini, karma kod sağlayıcısını ve karşılaştırıcıyı kullanır.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)

HashtableBelirtilen sözlükten öğeleri yeni bir nesneye kopyalayarak sınıfın yeni bir örneğini başlatır Hashtable .Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to a new Hashtable object. Yeni Hashtable nesne, kopyalanmış öğe sayısına eşit olan bir başlangıç kapasitesine sahiptir ve varsayılan yükleme faktörünü ve belirtilen IEqualityComparer nesneyi kullanır.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)
Kullanımdan kalktı.

HashtableBelirtilen sözlükten öğeleri yeni nesneye kopyalayarak sınıfın yeni bir örneğini başlatır Hashtable .Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. Yeni Hashtable nesne, kopyalanmış öğe sayısına eşit olan bir başlangıç kapasitesine sahiptir ve varsayılan Yük etmenini ve belirtilen karma kod sağlayıcısını ve karşılaştırıcıyı kullanır.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. Bu, API artık kullanılmıyor.This API is obsolete. Alternatif için, bkz Hashtable(IDictionary, IEqualityComparer) ..For an alternative, see Hashtable(IDictionary, IEqualityComparer).

Hashtable(IDictionary, Single)

HashtableBelirtilen sözlükten öğeleri yeni nesneye kopyalayarak sınıfın yeni bir örneğini başlatır Hashtable .Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. Yeni Hashtable nesne, kopyalanmış öğe sayısına eşit olan bir başlangıç kapasitesine sahiptir ve belirtilen yük etmenini ve varsayılan karma kod sağlayıcısını ve karşılaştırıcıyı kullanır.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)

HashtableBelirtilen sözlükten öğeleri yeni nesneye kopyalayarak sınıfın yeni bir örneğini başlatır Hashtable .Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. Yeni Hashtable nesne, kopyalanmış öğe sayısına eşit olan bir başlangıç kapasitesine sahiptir ve belirtilen yükleme faktörünü ve IEqualityComparer nesnesini kullanır.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)
Kullanımdan kalktı.

HashtableBelirtilen sözlükten öğeleri yeni nesneye kopyalayarak sınıfın yeni bir örneğini başlatır Hashtable .Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. Yeni Hashtable nesne, kopyalanmış öğe sayısına eşit olan bir başlangıç kapasitesine sahiptir ve belirtilen yük etmenini, karma kod sağlayıcısını ve karşılaştırıcıyı kullanır.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)

HashtableVarsayılan başlangıç kapasitesini ve yük etmenini ve belirtilen nesneyi kullanarak sınıfının yeni, boş bir örneğini başlatır 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)
Kullanımdan kalktı.

HashtableVarsayılan başlangıç kapasitesini ve yük etmenini ve belirtilen karma kod sağlayıcısını ve karşılaştırıcıyı kullanarak sınıfının yeni, boş bir örneğini başlatır.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)

HashtableBelirtilen başlangıç kapasitesini ve varsayılan yükleme faktörünü, karma kod sağlayıcısını ve karşılaştırıcıyı kullanarak sınıfının yeni, boş bir örneğini başlatır.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)

HashtableBelirtilen başlangıç kapasitesini ve IEqualityComparer varsayılan Yük etmenini kullanarak sınıfının yeni, boş bir örneğini başlatır.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)
Kullanımdan kalktı.

HashtableBelirtilen başlangıç kapasitesini, karma kod sağlayıcısını, karşılaştırıcıyı ve varsayılan Yük etmenini kullanarak sınıfının yeni, boş bir örneğini başlatır.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)

HashtableBelirtilen başlangıç kapasitesini ve yük etmenini ve varsayılan karma kod sağlayıcısı ve karşılaştırıcı 'yı kullanarak sınıfının yeni, boş bir örneğini başlatır.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)

HashtableBelirtilen başlangıç kapasitesini, yük etmenini ve nesneyi kullanarak sınıfının yeni, boş bir örneğini başlatır 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)
Kullanımdan kalktı.

HashtableBelirtilen başlangıç kapasitesini, yük etmenini, karma kod sağlayıcısını ve karşılaştırıcıyı kullanarak sınıfının yeni, boş bir örneğini başlatır.Initializes a new, empty instance of the Hashtable class using the specified initial capacity, load factor, hash code provider, and comparer.

Hashtable(SerializationInfo, StreamingContext)

HashtableBelirtilen ve nesneleri kullanılarak seri hale getirilebilir bir sınıfın yeni, boş bir örneğini başlatır SerializationInfo StreamingContext .Initializes a new, empty instance of the Hashtable class that is serializable using the specified SerializationInfo and StreamingContext objects.

Özellikler

comparer
Kullanımdan kalktı.

İçin kullanılacak öğesini alır veya ayarlar IComparer Hashtable .Gets or sets the IComparer to use for the Hashtable.

Count

İçinde yer alan anahtar/değer çiftlerinin sayısını alır Hashtable .Gets the number of key/value pairs contained in the Hashtable.

EqualityComparer

IEqualityComparerİçin kullanımını alır Hashtable .Gets the IEqualityComparer to use for the Hashtable.

hcp
Kullanımdan kalktı.

Karma kodları dağıtılan nesneyi alır veya ayarlar.Gets or sets the object that can dispense hash codes.

IsFixedSize

Değerinin sabit boyutta olup olmadığını gösteren bir değer alır Hashtable .Gets a value indicating whether the Hashtable has a fixed size.

IsReadOnly

Hashtable öğesinin salt okunur olup olmadığını belirten bir değer alır.Gets a value indicating whether the Hashtable is read-only.

IsSynchronized

Erişiminin Hashtable eşitlenip eşitlenmediğini (iş parçacığı güvenli) gösteren bir değer alır.Gets a value indicating whether access to the Hashtable is synchronized (thread safe).

Item[Object]

Belirtilen anahtarla ilişkili değeri alır veya ayarlar.Gets or sets the value associated with the specified key.

Keys

ICollectionİçindeki anahtarları içeren bir alır Hashtable .Gets an ICollection containing the keys in the Hashtable.

SyncRoot

Erişimini eşitlemede kullanılabilecek bir nesne alır Hashtable .Gets an object that can be used to synchronize access to the Hashtable.

Values

ICollectionİçindeki değerleri içeren bir öğesini alır Hashtable .Gets an ICollection containing the values in the Hashtable.

Yöntemler

Add(Object, Object)

Öğesine belirtilen anahtarı ve değeri içeren bir öğesi ekler Hashtable .Adds an element with the specified key and value into the Hashtable.

Clear()

Tüm öğeleri Hashtable koleksiyonundan kaldırır.Removes all elements from the Hashtable.

Clone()

Öğesinin basit bir kopyasını oluşturur Hashtable .Creates a shallow copy of the Hashtable.

Contains(Object)

' In Hashtable belirli bir anahtar içerip içermediğini belirler.Determines whether the Hashtable contains a specific key.

ContainsKey(Object)

' In Hashtable belirli bir anahtar içerip içermediğini belirler.Determines whether the Hashtable contains a specific key.

ContainsValue(Object)

' In Hashtable belirli bir değer içerip içermediğini belirler.Determines whether the Hashtable contains a specific value.

CopyTo(Array, Int32)

HashtableÖğeleri belirtilen dizindeki tek boyutlu bir örneğe kopyalar Array .Copies the Hashtable elements to a one-dimensional Array instance at the specified index.

Equals(Object)

Belirtilen nesnenin geçerli nesneye eşit olup olmadığını belirler.Determines whether the specified object is equal to the current object.

(Devralındığı yer: Object)
GetEnumerator()

IDictionaryEnumeratorİle yinelenen bir döndürür Hashtable .Returns an IDictionaryEnumerator that iterates through the Hashtable.

GetHash(Object)

Belirtilen anahtarın karma kodunu döndürür.Returns the hash code for the specified key.

GetHashCode()

Varsayılan karma işlevi olarak işlev görür.Serves as the default hash function.

(Devralındığı yer: Object)
GetObjectData(SerializationInfo, StreamingContext)

Arabirimini uygular ISerializable ve seri hale getirmek için gereken verileri döndürür Hashtable .Implements the ISerializable interface and returns the data needed to serialize the Hashtable.

GetType()

TypeGeçerli örneği alır.Gets the Type of the current instance.

(Devralındığı yer: Object)
KeyEquals(Object, Object)

Objectİçindeki belirli bir anahtarla belirli bir anahtarla karşılaştırır Hashtable .Compares a specific Object with a specific key in the Hashtable.

MemberwiseClone()

Geçerli bir basit kopyasını oluşturur Object .Creates a shallow copy of the current Object.

(Devralındığı yer: Object)
OnDeserialization(Object)

Arabirimini uygular ISerializable ve serisini kaldırma tamamlandığında seri kaldırma olayını başlatır.Implements the ISerializable interface and raises the deserialization event when the deserialization is complete.

Remove(Object)

Öğesinden belirtilen anahtara sahip öğeyi kaldırır Hashtable .Removes the element with the specified key from the Hashtable.

Synchronized(Hashtable)

İçin eşitlenmiş (iş parçacığı açısından güvenli) sarmalayıcı döndürür Hashtable .Returns a synchronized (thread-safe) wrapper for the Hashtable.

ToString()

Geçerli nesneyi temsil eden dizeyi döndürür.Returns a string that represents the current object.

(Devralındığı yer: Object)

Belirtik Arabirim Kullanımları

IEnumerable.GetEnumerator()

Bir toplulukta tekrarlanan bir numaralandırıcı döndürür.Returns an enumerator that iterates through a collection.

Uzantı Metotları

Cast<TResult>(IEnumerable)

Öğesinin öğelerini IEnumerable belirtilen türe yayınlar.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable)

Öğesinin öğelerini IEnumerable belirtilen bir türe göre filtreler.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable)

Bir sorgunun paralelleştirilmesini mümkün hale getirme.Enables parallelization of a query.

AsQueryable(IEnumerable)

Bir IEnumerable öğesine dönüştürür IQueryable .Converts an IEnumerable to an IQueryable.

Şunlara uygulanır

İş Parçacığı Güvenliği

Hashtable, birden çok okuyucu iş parçacığı ve tek bir yazma iş parçacığı tarafından kullanılmak üzere iş parçacığı güvenlidir.Hashtable is thread safe for use by multiple reader threads and a single writing thread. Birden çok iş parçacığı kullanımı için iş parçacığından yalnızca biri yazma (güncelleştirme) işlemleri gerçekleştirirken, yazıcıların ' a serileştirildiği kilit serbest okuma işlemlerine izin veren iş parçacığı güvenlidir 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. Birden çok yazıcının desteklenmesi için, üzerinde tüm işlemlerin, Hashtable Synchronized(Hashtable) nesneyi okuyan iş parçacığı olmaması şartıyla, yöntemi tarafından döndürülen sarmalayıcı aracılığıyla yapılması gerekir 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.

Bir koleksiyonun içinden sıralama, bir iş parçacığı güvenli yordamı değil doğası gereği.Enumerating through a collection is intrinsically not a thread safe procedure. Bir koleksiyon eşitlendiği zaman bile, diğer iş parçacıkları numaralandırıcının özel durum oluşturmasına neden olan koleksiyonu değiştirebilir.Even when a collection is synchronized, other threads can still modify the collection, which causes the enumerator to throw an exception. Numaralandırma sırasında iş parçacığı güvenliği sağlamak için tüm numaralandırma sırasında koleksiyonu kilitleyebilir veya diğer iş parçacıkları tarafından yapılan değişikliklerden kaynaklanan özel durumları yakalayabilirsiniz.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.

Ayrıca bkz.