Hashtable Sınıf

Tanım

Ad Alanı:

System.Collections

Bütünleştirilmiş Kod:

System.Runtime.dll

Kaynak:

Hashtable.cs

Anahtarın karma koduna göre düzenlenmiş bir anahtar/değer çiftleri koleksiyonunu temsil eder.

public ref class Hashtable : ICloneable, System::Collections::IDictionary, System::Runtime::Serialization::IDeserializationCallback, System::Runtime::Serialization::ISerializable

public class Hashtable : ICloneable, System.Collections.IDictionary, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable

type Hashtable = class
    interface ICollection
    interface IEnumerable
    interface IDictionary
    interface ICloneable
    interface IDeserializationCallback
    interface ISerializable

Public Class Hashtable
Implements ICloneable, IDeserializationCallback, IDictionary, ISerializable

Devralma

Object

Hashtable

Türetilmiş

System.Configuration.SettingsAttributeDictionary

System.Configuration.SettingsContext

System.Data.PropertyCollection

System.Printing.IndexedProperties.PrintPropertyDictionary

Uygulamalar

ICollection IDictionary IEnumerable ICloneable IDeserializationCallback ISerializable

Örnekler

Aşağıdaki örnekte, ' Hashtable de çeşitli işlevlerin nasıl oluşturulacağı, başlatılıp gerçekleştirilacağı ve anahtarlarının ve değerlerinin nasıl yazdırılacağı gösterilmektedir.

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 nesnede depolanan bir DictionaryEntry anahtar/değer çiftidir. Anahtar olamaz null, ancak bir değer olabilir.

Önemli

sınıfını Hashtable yeni geliştirme için kullanmanızı önermiyoruz. Bunun yerine, genel Dictionary<TKey,TValue> sınıfı kullanmanızı öneririz. Daha fazla bilgi için bkz. GitHub'da genel olmayan koleksiyonlar kullanılmamalıdır .

tarafından anahtar Hashtable olarak kullanılan nesnelerin yöntemini (veya arabirimini) ve Object.Equals yöntemini (veya IHashCodeProvider arabiriminiIComparer) geçersiz kılmak Object.GetHashCode için gereklidir. Hem yöntemlerin hem de arabirimlerin uygulanması büyük/küçük harf duyarlılığını aynı şekilde ele almalıdır; aksi takdirde, Hashtable yanlış davranabilir. Örneğin, oluştururken Hashtablesınıfını CaseInsensitiveHashCodeProvider (veya büyük/küçük harfe duyarsız IHashCodeProvider herhangi bir uygulamayı) sınıfıyla (veya büyük/küçük harfe duyarsız IComparer herhangi bir uygulamaylaCaseInsensitiveComparer) kullanmanız gerekir.

Ayrıca, anahtar içinde mevcutken bu yöntemlerin aynı parametrelerle çağrıldığında aynı sonuçları üretmesi Hashtablegerekir. Alternatif olarak, bir oluşturucuyu parametresiyle IEqualityComparer birlikte kullanabilirsinizHashtable. Anahtar eşitliği yalnızca başvuru eşitliği olsaydı ve'nin Object.Equals devralınan Object.GetHashCode uygulaması yeterli olurdu.

anahtar nesneleri, içinde Hashtableanahtar olarak kullanıldıkları sürece sabit olmalıdır.

öğesine bir öğe eklendiğinde Hashtable, öğesi anahtarın karma koduna göre bir demet içine yerleştirilir. Anahtarın sonraki aramalarında yalnızca belirli bir demette arama yapmak için anahtarın karma kodu kullanılır ve böylece bir öğeyi bulmak için gereken anahtar karşılaştırmalarının sayısı önemli ölçüde azalır.

öğesinin Hashtable yük faktörü, öğelerin demetlere en yüksek oranını belirler. Daha küçük yük faktörleri, daha yüksek bellek tüketimi maliyetiyle ortalama arama sürelerinin daha hızlı gerçekleşmesine neden olur. Varsayılan yük faktörü olan 1.0 genellikle hız ve boyut arasında en iyi dengeyi sağlar. oluşturulduğunda farklı bir yük faktörü de belirtilebilir Hashtable .

öğesine öğe eklendikçe Hashtable, öğesinin gerçek yük faktörü Hashtable artar. Gerçek yük faktörü belirtilen yük faktörüne ulaştığında, içindeki Hashtable demetlerin sayısı otomatik olarak geçerli demet sayısının iki katından daha büyük olan en küçük asal sayıya Hashtable yükseltilir.

içindeki Hashtable her anahtar nesnesi, çağrılarak GetHasherişilebilen kendi karma işlevini sağlamalıdır. Ancak, uygulayan IHashCodeProvider herhangi bir nesne bir Hashtable oluşturucuya geçirilebilir ve bu karma işlevi tablodaki tüm nesneler için kullanılır.

bir Hashtable öğesinin kapasitesi, barındırabileceği öğelerin Hashtable sayısıdır. öğesine öğe eklendikçe Hashtable, kapasite yeniden konumlandırma yoluyla gerektiği gibi otomatik olarak artırılır.

Yalnızca .NET Framework: Çok büyük Hashtable nesneler için, çalışma zamanı ortamında yapılandırma öğesinin özniteliğini <gcAllowVeryLargeObjects> olarak ayarlayarak enabled 64 bitlik bir sistemde maksimum kapasiteyi 2 milyar öğeye true çıkarabilirsiniz.

foreach C# dilinin deyimi (For EachVisual Basic'te) koleksiyondaki öğelerin türünde bir nesne döndürür. öğesinin Hashtable her öğesi bir anahtar/değer çifti olduğundan, öğe türü anahtarın türü veya değerin türü değildir. Bunun yerine, öğe türü şeklindedir DictionaryEntry. Örnek:

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

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

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

deyimi foreach , numaralandırıcının etrafındaki bir sarmalayıcıdır ve bu sarmalayıcı yalnızca koleksiyonun okunmasına izin verir, yazmaya değil.

için bir numaralandırıcıyı seri hale getirme ve seri durumdan çıkarma, öğelerin yeniden sıralanmalarına neden olabileceğinden Hashtable , yöntemini çağırmadan numaralandırmaya Reset devam etmek mümkün değildir.

Not

Anahtarlar devralınabildiği ve davranışları değiştirilebildiği için, yöntemi kullanılarak Equals yapılan karşılaştırmalarla mutlak benzersizlikleri garanti edilemez.

Oluşturucular

Hashtable()	Varsayılan başlangıç kapasitesini, yük faktörünü Hashtable , karma kod sağlayıcısını ve karşılaştırıcıyı kullanarak sınıfın yeni, boş bir örneğini başlatır.
Hashtable(IDictionary)	Belirtilen sözlükten yeni nesneye Hashtable öğeleri kopyalayarak sınıfının yeni Hashtable bir örneğini başlatır. Yeni Hashtable nesne, kopyalanan öğe sayısına eşit bir başlangıç kapasitesine sahiptir ve varsayılan yük faktörünü, karma kod sağlayıcısını ve karşılaştırıcıyı kullanır.
Hashtable(IDictionary, IEqualityComparer)	Belirtilen sözlükten yeni bir nesneye Hashtable öğeleri kopyalayarak sınıfının yeni Hashtable bir örneğini başlatır. Yeni Hashtable nesne, kopyalanan öğe sayısına eşit bir başlangıç kapasitesine sahiptir ve varsayılan yük faktörünü ve belirtilen IEqualityComparer nesneyi kullanır.
Hashtable(IDictionary, IHashCodeProvider, IComparer)	Geçersiz. Belirtilen sözlükten yeni nesneye Hashtable öğeleri kopyalayarak sınıfının yeni Hashtable bir örneğini başlatır. Yeni Hashtable nesne, kopyalanan öğelerin sayısına eşit bir başlangıç kapasitesine sahiptir ve varsayılan yük faktörünü ve belirtilen karma kod sağlayıcısını ve karşılaştırıcıyı kullanır. Bu, API artık kullanılmıyor. Alternatif olarak bkz Hashtable(IDictionary, IEqualityComparer). .
Hashtable(IDictionary, Single)	Belirtilen sözlükten yeni nesneye Hashtable öğeleri kopyalayarak sınıfının yeni Hashtable bir örneğini başlatır. Yeni Hashtable nesne, kopyalanan öğe sayısına eşit bir başlangıç kapasitesine sahiptir ve belirtilen yük faktörünü ve varsayılan karma kod sağlayıcısı ile karşılaştırıcıyı kullanır.
Hashtable(IDictionary, Single, IEqualityComparer)	Belirtilen sözlükten yeni nesneye Hashtable öğeleri kopyalayarak sınıfının yeni Hashtable bir örneğini başlatır. Yeni Hashtable nesne, kopyalanan öğelerin sayısına eşit bir başlangıç kapasitesine sahiptir ve belirtilen yük faktörü ile IEqualityComparer nesnesini kullanır.
Hashtable(IDictionary, Single, IHashCodeProvider, IComparer)	Geçersiz. Belirtilen sözlükten yeni nesneye Hashtable öğeleri kopyalayarak sınıfının yeni Hashtable bir örneğini başlatır. Yeni Hashtable nesne, kopyalanan öğe sayısına eşit bir başlangıç kapasitesine sahiptir ve belirtilen yük faktörünü, karma kod sağlayıcısını ve karşılaştırıcıyı kullanır.
Hashtable(IEqualityComparer)	Varsayılan ilk kapasiteyi ve yük faktörünü Hashtable ve belirtilen IEqualityComparer nesneyi kullanarak sınıfın yeni, boş bir örneğini başlatır.
Hashtable(IHashCodeProvider, IComparer)	Geçersiz. Varsayılan ilk kapasiteyi ve yük faktörünü Hashtable ve belirtilen karma kod sağlayıcısını ve karşılaştırıcıyı kullanarak sınıfın yeni, boş bir örneğini başlatır.
Hashtable(Int32)	Belirtilen ilk kapasiteyi ve varsayılan yük 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 Hashtable başlatır.
Hashtable(Int32, IEqualityComparer)	Belirtilen ilk kapasiteyi ve ve IEqualityComparervarsayılan yük faktörünü kullanarak sınıfın yeni, boş bir örneğini Hashtable başlatır.
Hashtable(Int32, IHashCodeProvider, IComparer)	Geçersiz. Belirtilen ilk kapasiteyi, karma kod sağlayıcısını Hashtable , karşılaştırıcıyı ve varsayılan yük faktörünü kullanarak sınıfın yeni, boş bir örneğini başlatır.
Hashtable(Int32, Single)	Belirtilen ilk kapasiteyi ve yük faktörünü Hashtable ve varsayılan 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.
Hashtable(Int32, Single, IEqualityComparer)	Belirtilen ilk kapasiteyi, yük faktörünü ve nesneyi kullanarak sınıfın Hashtable yeni, IEqualityComparer boş bir örneğini başlatır.
Hashtable(Int32, Single, IHashCodeProvider, IComparer)	Geçersiz. Belirtilen ilk kapasiteyi, yük faktörünü, karma kod sağlayıcısını Hashtable ve karşılaştırıcıyı kullanarak sınıfının yeni, boş bir örneğini başlatır.
Hashtable(SerializationInfo, StreamingContext)	Geçersiz. Belirtilen SerializationInfo ve nesnelerini kullanarak sınıfının seri hale getirilebilen yeni, StreamingContext boş bir örneğini Hashtable başlatır.

Özellikler

comparer	Geçersiz. için Hashtablekullanılacak öğesini IComparer alır veya ayarlar.
Count	içinde yer alan Hashtableanahtar/değer çiftlerinin sayısını alır.
EqualityComparer	IEqualityComparer için kullanılacak öğesini Hashtablealır.
hcp	Geçersiz. Karma kodları dağıtabilen nesneyi alır veya ayarlar.
IsFixedSize	değerinin sabit bir boyuta sahip olup olmadığını Hashtable belirten bir değer alır.
IsReadOnly	Hashtable öğesinin salt okunur olup olmadığını belirten bir değer alır.
IsSynchronized	erişimin Hashtable eşitlenip eşitlenmediğini belirten bir değer alır (iş parçacığı güvenli).
Item[Object]	Belirtilen anahtarla ilişkili değeri alır veya ayarlar.
Keys	içindeki Hashtableanahtarları içeren bir ICollection alır.
SyncRoot	erişimi Hashtableeşitlemek için kullanılabilecek bir nesnesi alır.
Values	içindeki Hashtabledeğerleri içeren bir ICollection alır.

Yöntemler

Add(Object, Object)	öğesine belirtilen anahtar ve değere Hashtablesahip bir öğe ekler.
Clear()	Tüm öğeleri Hashtable koleksiyonundan kaldırır.
Clone()	öğesinin Hashtablesığ bir kopyasını oluşturur.
Contains(Object)	öğesinin Hashtable belirli bir anahtar içerip içermediğini belirler.
ContainsKey(Object)	öğesinin Hashtable belirli bir anahtar içerip içermediğini belirler.
ContainsValue(Object)	öğesinin Hashtable belirli bir değer içerip içermediğini belirler.
CopyTo(Array, Int32)	Öğeleri belirtilen dizindeki Hashtable tek boyutlu Array bir örneğe kopyalar.
Equals(Object)	Belirtilen nesnenin geçerli nesneye eşit olup olmadığını belirler. (Devralındığı yer: Object)
GetEnumerator()	aracılığıyla Hashtableyineleyen bir IDictionaryEnumerator döndürür.
GetHash(Object)	Belirtilen anahtar için karma kodu döndürür.
GetHashCode()	Varsayılan karma işlevi işlevi görür. (Devralındığı yer: Object)
GetObjectData(SerializationInfo, StreamingContext)	Geçersiz. arabirimini ISerializable uygular ve seri hale Hashtablegetirmek için gereken verileri döndürür.
GetType()	Type Geçerli örneğini alır. (Devralındığı yer: Object)
KeyEquals(Object, Object)	Belirli Object bir anahtarı içindeki Hashtablebelirli bir anahtarla karşılaştırır.
MemberwiseClone()	Geçerli Objectöğesinin sığ bir kopyasını oluşturur. (Devralındığı yer: Object)
OnDeserialization(Object)	Arabirimini ISerializable uygular ve seri durumdan çıkarma işlemi tamamlandığında seri durumdan çıkarma olayını başlatır.
Remove(Object)	belirtilen anahtara sahip öğesini öğesinden Hashtablekaldırır.
Synchronized(Hashtable)	için eşitlenmiş (iş parçacığı güvenli) sarmalayıcı döndürür Hashtable.
ToString()	Geçerli nesneyi temsil eden dizeyi döndürür. (Devralındığı yer: Object)

Belirtik Arabirim Kullanımları

IEnumerable.GetEnumerator()

Bir toplulukta tekrarlanan bir numaralandırıcı döndürür.

Uzantı Metotları

Cast<TResult>(IEnumerable)	öğesinin IEnumerable öğelerini belirtilen türe atar.
OfType<TResult>(IEnumerable)	Öğesinin IEnumerable öğelerini belirtilen türe göre filtreler.
AsParallel(IEnumerable)	Sorgunun paralelleştirilmesini etkinleştirir.
AsQueryable(IEnumerable)	bir IEnumerable öğesini öğesine IQueryabledönüştürü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 güvenlidir. İş parçacıklarından yalnızca biri yazma (güncelleştirme) işlemleri gerçekleştirdiğinde, yazıcıların üzerinde seri hale getirilmiş olması koşuluyla, kilitsiz okumalara olanak tanıyan çok iş parçacıklı kullanım için Hashtableiş parçacığı güvenlidir. Birden çok yazıcıyı desteklemek için, nesnesini okuyan Hashtable iş parçacığı olmaması koşuluyla üzerindeki tüm işlemlerin HashtableSynchronized(Hashtable) yöntemi tarafından döndürülen sarmalayıcı aracılığıyla yapılması gerekir.

Bir koleksiyonda numaralandırmak, doğası gereği iş parçacığı güvenli bir yordam değildir. 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. 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.

Ayrıca bkz.

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