Hashtable Oluşturucular

Tanım

Ad Alanı:

System.Collections

Bütünleştirilmiş Kod:

System.Runtime.dll

Hashtable sınıfının yeni bir örneğini başlatır.

Aşırı Yüklemeler

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(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(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(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, 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(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, 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(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(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.
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(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, 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(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(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(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(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()

Kaynak:

Hashtable.cs

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.

public:
 Hashtable();

public Hashtable ();

Public Sub New ()

Örnekler

Aşağıdaki kod örneği, farklı Hashtable oluşturucular kullanarak karma tablolar oluşturur ve her biri aynı öğeleri içerse bile karma tabloların davranışındaki farkları gösterir.

using namespace System;
using namespace System::Collections;
using namespace System::Globalization;

ref class myComparer : IEqualityComparer
{
public:
    virtual bool Equals(Object^ x, Object^ y) 
    {
        return x->Equals(y);
    }

    virtual int GetHashCode(Object^ obj)
    {
        return obj->ToString()->ToLower()->GetHashCode();
    }
};

ref class myCultureComparer : IEqualityComparer
{
private:
    CaseInsensitiveComparer^ myComparer;

public:
    myCultureComparer()
    {
        myComparer = CaseInsensitiveComparer::DefaultInvariant;
    }

    myCultureComparer(CultureInfo^ myCulture)
    {
        myComparer = gcnew CaseInsensitiveComparer(myCulture);
    }

    virtual bool Equals(Object^ x, Object^ y) 
    {
        if (myComparer->Compare(x, y) == 0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    virtual int GetHashCode(Object^ obj)
    {
        return obj->ToString()->ToLower()->GetHashCode();
    }
};

int main()
{
   
   // Create a hash table using the default hash code provider and the default comparer.
   Hashtable^ myHT1 = gcnew Hashtable((IEqualityComparer^)nullptr);
   myHT1->Add( "FIRST", "Hello" );
   myHT1->Add( "SECOND", "World" );
   myHT1->Add( "THIRD", "!" );
   
   // Create a hash table using the specified IEqualityComparer that uses
   // the default Object.Equals to determine equality.
   Hashtable^ myHT2 = gcnew Hashtable(gcnew myComparer());
   myHT2->Add( "FIRST", "Hello" );
   myHT2->Add( "SECOND", "World" );
   myHT2->Add( "THIRD", "!" );
   
   // Create a hash table using a case-insensitive hash code provider and
   // case-insensitive comparer based on the InvariantCulture.
   Hashtable^ myHT3 = gcnew Hashtable(
            CaseInsensitiveHashCodeProvider::DefaultInvariant,
            CaseInsensitiveComparer::DefaultInvariant);
   myHT3->Add( "FIRST", "Hello" );
   myHT3->Add( "SECOND", "World" );
   myHT3->Add( "THIRD", "!" );
   
   // Create a hash table using an IEqualityComparer that is based on
   // the Turkish culture (tr-TR) where "I" is not the uppercase
   // version of "i".
   CultureInfo^ myCul = gcnew CultureInfo("tr-TR");
   Hashtable^ myHT4 = gcnew Hashtable( gcnew myCultureComparer(myCul) );
   myHT4->Add( "FIRST", "Hello" );
   myHT4->Add( "SECOND", "World" );
   myHT4->Add( "THIRD", "!" );
   
   // Search for a key in each hash table.
   Console::WriteLine( "first is in myHT1: {0}", myHT1->ContainsKey( "first" ) );
   Console::WriteLine( "first is in myHT2: {0}", myHT2->ContainsKey( "first" ) );
   Console::WriteLine( "first is in myHT3: {0}", myHT3->ContainsKey( "first" ) );
   Console::WriteLine( "first is in myHT4: {0}", myHT4->ContainsKey( "first" ) );
}

/* 
This code produces the following output.  Results vary depending on the system's culture settings.

first is in myHT1: False
first is in myHT2: False
first is in myHT3: True
first is in myHT4: False

*/

using System;
using System.Collections;
using System.Globalization;

class myComparer : IEqualityComparer
{
    public new bool Equals(object x, object y)
    {
        return x.Equals(y);
    }

    public int GetHashCode(object obj)
    {
        return obj.ToString().ToLower().GetHashCode();
    }
}

class myCultureComparer : IEqualityComparer
{
    public CaseInsensitiveComparer myComparer;

    public myCultureComparer()
    {
        myComparer = CaseInsensitiveComparer.DefaultInvariant;
    }

    public myCultureComparer(CultureInfo myCulture)
    {
        myComparer = new CaseInsensitiveComparer(myCulture);
    }

    public new bool Equals(object x, object y)
    {
        return myComparer.Compare(x, y) == 0;
    }

    public int GetHashCode(object obj)
    {
        return obj.ToString().ToLower().GetHashCode();
    }
}

public class SamplesHashtable
{

    public static void Main()
    {

        // Create a hash table using the default comparer.
        var myHT1 = new Hashtable();
        myHT1.Add("FIRST", "Hello");
        myHT1.Add("SECOND", "World");
        myHT1.Add("THIRD", "!");

        // Create a hash table using the specified IEqualityComparer that uses
        // the default Object.Equals to determine equality.
        var myHT2 = new Hashtable(new myComparer());
        myHT2.Add("FIRST", "Hello");
        myHT2.Add("SECOND", "World");
        myHT2.Add("THIRD", "!");

        // Create a hash table using a case-insensitive hash code provider and
        // case-insensitive comparer based on the InvariantCulture.
        Hashtable myHT3 = new Hashtable(
            CaseInsensitiveHashCodeProvider.DefaultInvariant,
            CaseInsensitiveComparer.DefaultInvariant);
        myHT3.Add("FIRST", "Hello");
        myHT3.Add("SECOND", "World");
        myHT3.Add("THIRD", "!");

        // Create a hash table using an IEqualityComparer that is based on
        // the Turkish culture (tr-TR) where "I" is not the uppercase
        // version of "i".
        var myCul = new CultureInfo("tr-TR");
        var myHT4 = new Hashtable(new myCultureComparer(myCul));
        myHT4.Add("FIRST", "Hello");
        myHT4.Add("SECOND", "World");
        myHT4.Add("THIRD", "!");

        // Search for a key in each hash table.
        Console.WriteLine($"first is in myHT1: {myHT1.ContainsKey("first")}");
        Console.WriteLine($"first is in myHT2: {myHT2.ContainsKey("first")}");
        Console.WriteLine($"first is in myHT3: {myHT3.ContainsKey("first")}");
        Console.WriteLine($"first is in myHT4: {myHT4.ContainsKey("first")}");
    }
}


/*
This code produces the following output.
Results vary depending on the system's culture settings.

first is in myHT1: False
first is in myHT2: False
first is in myHT3: True
first is in myHT4: False

*/

Imports System.Collections
Imports System.Globalization

Public Class myComparer
    Implements IEqualityComparer
    Public Function Equals1(ByVal x As Object, ByVal y As Object) _
        As Boolean Implements IEqualityComparer.Equals

        Return x.Equals(y)
    End Function

    Public Function GetHashCode1(ByVal obj As Object) _
        As Integer Implements IEqualityComparer.GetHashCode

        Return obj.ToString().ToLower().GetHashCode()
    End Function

End Class

Public Class myCultureComparer
    Implements IEqualityComparer

    Dim myComparer As CaseInsensitiveComparer

    Public Sub New()
        myComparer = CaseInsensitiveComparer.DefaultInvariant
    End Sub

    Public Sub New(ByVal myCulture As CultureInfo)
        myComparer = New CaseInsensitiveComparer(myCulture)
    End Sub

    Public Function Equals1(ByVal x As Object, ByVal y As Object) _
        As Boolean Implements IEqualityComparer.Equals

        Return myComparer.Compare(x, y) = 0
    End Function

    Public Function GetHashCode1(ByVal obj As Object) _
        As Integer Implements IEqualityComparer.GetHashCode
        Return obj.ToString().ToLower().GetHashCode()
    End Function
End Class

Public Class SamplesHashtable

    Public Shared Sub Main()

        ' Create a hash table using the default comparer.
        Dim myHT1 As New Hashtable()
        myHT1.Add("FIRST", "Hello")
        myHT1.Add("SECOND", "World")
        myHT1.Add("THIRD", "!")

        ' Create a hash table using the specified IEqualityComparer that uses
        ' the default Object.Equals to determine equality.
        Dim myHT2 As New Hashtable(New myComparer())
        myHT2.Add("FIRST", "Hello")
        myHT2.Add("SECOND", "World")
        myHT2.Add("THIRD", "!")

        ' Create a hash table using a case-insensitive hash code provider and
        ' case-insensitive comparer based on the InvariantCulture.
        Dim myHT3 As New Hashtable( _
            CaseInsensitiveHashCodeProvider.DefaultInvariant, _
            CaseInsensitiveComparer.DefaultInvariant)
        myHT3.Add("FIRST", "Hello")
        myHT3.Add("SECOND", "World")
        myHT3.Add("THIRD", "!")

        ' Create a hash table using an IEqualityComparer that is based on
        ' the Turkish culture (tr-TR) where "I" is not the uppercase
        ' version of "i".
        Dim myCul As New CultureInfo("tr-TR")
        Dim myHT4 As New Hashtable(New myCultureComparer(myCul))
        myHT4.Add("FIRST", "Hello")
        myHT4.Add("SECOND", "World")
        myHT4.Add("THIRD", "!")

        ' Search for a key in each hash table.
        Console.WriteLine($"first is in myHT1: {myHT1.ContainsKey("first")}")
        Console.WriteLine($"first is in myHT2: {myHT2.ContainsKey("first")}")
        Console.WriteLine($"first is in myHT3: {myHT3.ContainsKey("first")}")
        Console.WriteLine($"first is in myHT4: {myHT4.ContainsKey("first")}")

    End Sub

End Class

'This code produces the following output.
'Results vary depending on the system's culture settings.

'first is in myHT1: False
'first is in myHT2: False
'first is in myHT3: True
'first is in myHT4: False

Açıklamalar

Karma tablosunun kapasitesi, yük faktörüne göre en uygun karma tablo demet sayısını hesaplamak için kullanılır. Kapasite gerektiğinde otomatik olarak artırılır.

Yük faktörü, öğelerin demetlere en yüksek oranıdır. Daha küçük bir yük faktörü, artan bellek tüketimi maliyetiyle daha hızlı arama anlamına gelir.

Gerçek yük faktörü belirtilen yük faktörüne ulaştığında, demet 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 yükseltilir.

Karma kod sağlayıcısı nesnedeki Hashtable anahtarlar için karma kodları dağıtır. Varsayılan karma kod sağlayıcısı anahtarın uygulamasıdır Object.GetHashCode.

Karşılaştırıcı, iki anahtarın eşit olup olmadığını belirler. içindeki Hashtable her anahtar benzersiz olmalıdır. Varsayılan karşılaştırıcı anahtarın uygulamasıdır Object.Equals.

Bu oluşturucu bir O(1) işlemdir.

Ayrıca bkz.

• GetHashCode()
• Equals(Object)

Hashtable(Int32, Single, IHashCodeProvider, IComparer)

Kaynak:

Hashtable.cs

Dikkat

This constructor has been deprecated. Use Hashtable(int, float, IEqualityComparer) instead.

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.

public:
 Hashtable(int capacity, float loadFactor, System::Collections::IHashCodeProvider ^ hcp, System::Collections::IComparer ^ comparer);

[System.Obsolete("This constructor has been deprecated. Use Hashtable(int, float, IEqualityComparer) instead.")]
public Hashtable (int capacity, float loadFactor, System.Collections.IHashCodeProvider? hcp, System.Collections.IComparer? comparer);

[<System.Obsolete("This constructor has been deprecated. Use Hashtable(int, float, IEqualityComparer) instead.")>]
new System.Collections.Hashtable : int * single * System.Collections.IHashCodeProvider * System.Collections.IComparer -> System.Collections.Hashtable

Public Sub New (capacity As Integer, loadFactor As Single, hcp As IHashCodeProvider, comparer As IComparer)

Parametreler

capacity

Int32

Nesnenin Hashtable başlangıçta içerebileceği yaklaşık öğe sayısı.

loadFactor

Single

0,1 ile 1,0 aralığındaki bir sayı, en iyi performansı sağlayan varsayılan değerle çarpılır. Sonuç, öğelerin demetlere en yüksek oranıdır.

hcp

IHashCodeProvider

içindeki IHashCodeProvider tüm anahtarlar Hashtableiçin karma kodları sağlayan nesnesi.

-veya-

null her anahtarın uygulaması olan varsayılan karma kod sağlayıcısını kullanmak için GetHashCode().

comparer

IComparer

İki anahtarın IComparer eşit olup olmadığını belirlemek için kullanılacak nesne.

-veya-

null her anahtarın uygulaması olan varsayılan karşılaştırıcıyı kullanmak için Equals(Object).

Öznitelikler

ObsoleteAttribute

Özel durumlar

ArgumentOutOfRangeException

capacity, sıfırdan küçüktür.

-veya-

loadFactor 0,1'den küçüktür.

-veya-

loadFactor 1,0'dan büyük.

Örnekler

Aşağıdaki kod örneği, farklı Hashtable oluşturucular kullanarak karma tablolar oluşturur ve her biri aynı öğeleri içerse bile karma tabloların davranışındaki farkları gösterir.

using namespace System;
using namespace System::Collections;
using namespace System::Globalization;

ref class myCultureComparer : public IEqualityComparer
{
public:
    CaseInsensitiveComparer^ myComparer;

public:
    myCultureComparer()
    {
        myComparer = CaseInsensitiveComparer::DefaultInvariant;
    }

public:
    myCultureComparer(CultureInfo^ myCulture)
    {
        myComparer = gcnew CaseInsensitiveComparer(myCulture);
    }

public:
    virtual bool Equals(Object^ x, Object^ y)
    {
        if (myComparer->Compare(x, y) == 0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

public:
    virtual int GetHashCode(Object^ obj)
    {
        // Compare the hash code for the lowercase versions of the strings.
        return obj->ToString()->ToLower()->GetHashCode();
    }
};

public ref class SamplesHashtable
{

public:
    static void Main()
    {
        // Create a hash table using the default comparer.
        Hashtable^ myHT1 = gcnew Hashtable(3, .8f);
        myHT1->Add("FIRST", "Hello");
        myHT1->Add("SECOND", "World");
        myHT1->Add("THIRD", "!");

        // Create a hash table using the specified IEqualityComparer that uses
        // the CaseInsensitiveComparer.DefaultInvariant to determine equality.
        Hashtable^ myHT2 = gcnew Hashtable(3, .8f, gcnew myCultureComparer());
        myHT2->Add("FIRST", "Hello");
        myHT2->Add("SECOND", "World");
        myHT2->Add("THIRD", "!");

        // Create a hash table using an IEqualityComparer that is based on
        // the Turkish culture (tr-TR) where "I" is not the uppercase
        // version of "i".
        CultureInfo^ myCul = gcnew CultureInfo("tr-TR");
        Hashtable^ myHT3 = gcnew Hashtable(3, .8f, gcnew myCultureComparer(myCul));
        myHT3->Add("FIRST", "Hello");
        myHT3->Add("SECOND", "World");
        myHT3->Add("THIRD", "!");

        // Search for a key in each hash table.
        Console::WriteLine("first is in myHT1: {0}", myHT1->ContainsKey("first"));
        Console::WriteLine("first is in myHT2: {0}", myHT2->ContainsKey("first"));
        Console::WriteLine("first is in myHT3: {0}", myHT3->ContainsKey("first"));

    }
};

int main()
{
    SamplesHashtable::Main();
}

/* 
This code produces the following output.  Results vary depending on the system's culture settings.

first is in myHT1: False
first is in myHT2: True
first is in myHT3: False

*/

using System;
using System.Collections;
using System.Globalization;

class myCultureComparer : IEqualityComparer
{
    public CaseInsensitiveComparer myComparer;

    public myCultureComparer()
    {
        myComparer = CaseInsensitiveComparer.DefaultInvariant;
    }

    public myCultureComparer(CultureInfo myCulture)
    {
        myComparer = new CaseInsensitiveComparer(myCulture);
    }

    public new bool Equals(object x, object y)
    {
        if (myComparer.Compare(x, y) == 0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    public int GetHashCode(object obj)
    {
        // Compare the hash code for the lowercase versions of the strings.
        return obj.ToString().ToLower().GetHashCode();
    }
}

public class SamplesHashtable
{

    public static void Main()
    {

        // Create a hash table using the default comparer.
        Hashtable myHT1 = new Hashtable(3, .8f);
        myHT1.Add("FIRST", "Hello");
        myHT1.Add("SECOND", "World");
        myHT1.Add("THIRD", "!");

        // Create a hash table using the specified IEqualityComparer that uses
        // the CaseInsensitiveComparer.DefaultInvariant to determine equality.
        Hashtable myHT2 = new Hashtable(3, .8f, new myCultureComparer());
        myHT2.Add("FIRST", "Hello");
        myHT2.Add("SECOND", "World");
        myHT2.Add("THIRD", "!");

        // Create a hash table using an IEqualityComparer that is based on
        // the Turkish culture (tr-TR) where "I" is not the uppercase
        // version of "i".
        CultureInfo myCul = new CultureInfo("tr-TR");
        Hashtable myHT3 = new Hashtable(3, .8f, new myCultureComparer(myCul));

        myHT3.Add("FIRST", "Hello");
        myHT3.Add("SECOND", "World");
        myHT3.Add("THIRD", "!");

        // Search for a key in each hash table.
        Console.WriteLine("first is in myHT1: {0}", myHT1.ContainsKey("first"));
        Console.WriteLine("first is in myHT2: {0}", myHT2.ContainsKey("first"));
        Console.WriteLine("first is in myHT3: {0}", myHT3.ContainsKey("first"));
    }
}


/*
This code produces the following output.
Results vary depending on the system's culture settings.

first is in myHT1: False
first is in myHT2: True
first is in myHT3: False

*/

Imports System.Collections
Imports System.Globalization

Public Class myCultureComparer
    Implements IEqualityComparer

    Dim myComparer As CaseInsensitiveComparer

    Public Sub New()
        myComparer = CaseInsensitiveComparer.DefaultInvariant
    End Sub

    Public Sub New(ByVal myCulture As CultureInfo)
        myComparer = New CaseInsensitiveComparer(myCulture)
    End Sub

    Public Function Equals1(ByVal x As Object, ByVal y As Object) _
        As Boolean Implements IEqualityComparer.Equals

        If (myComparer.Compare(x, y) = 0) Then
            Return True
        Else
            Return False
        End If
    End Function

    Public Function GetHashCode1(ByVal obj As Object) _
        As Integer Implements IEqualityComparer.GetHashCode
        Return obj.ToString().ToLower().GetHashCode()
    End Function
End Class

Public Class SamplesHashtable

    Public Shared Sub Main()

        ' Create a hash table using the default comparer.
        Dim myHT1 As New Hashtable(3, System.Convert.ToSingle(0.8))
        myHT1.Add("FIRST", "Hello")
        myHT1.Add("SECOND", "World")
        myHT1.Add("THIRD", "!")

        ' Create a hash table using the specified IEqualityComparer that uses
        ' the CaseInsensitiveComparer.DefaultInvariant to determine equality.
        Dim myHT2 As New Hashtable(3, System.Convert.ToSingle(0.8), _
            New myCultureComparer())

        myHT2.Add("FIRST", "Hello")
        myHT2.Add("SECOND", "World")
        myHT2.Add("THIRD", "!")

        ' Create a hash table using an IEqualityComparer that is based on
        ' the Turkish culture (tr-TR) where "I" is not the uppercase
        ' version of "i".
        Dim myCul As New CultureInfo("tr-TR")
        Dim myHT3 As New Hashtable(3, System.Convert.ToSingle(0.8), _
            New myCultureComparer(myCul))

        myHT3.Add("FIRST", "Hello")
        myHT3.Add("SECOND", "World")
        myHT3.Add("THIRD", "!")

        ' Search for a key in each hash table.
        Console.WriteLine("first is in myHT1: {0}", myHT1.ContainsKey("first"))
        Console.WriteLine("first is in myHT2: {0}", myHT2.ContainsKey("first"))
        Console.WriteLine("first is in myHT3: {0}", myHT3.ContainsKey("first"))

    End Sub

End Class


'This code produces the following output.
'Results vary depending on the system's culture settings.
'
'first is in myHT1: False
'first is in myHT2: True
'first is in myHT3: False

Açıklamalar

İlk kapasitenin belirtilmesi, nesneye öğe eklerken bir dizi yeniden boyutlandırma işlemi gerçekleştirme gereksinimini Hashtable ortadan kaldırır. Kapasite, yük faktörüne bağlı olarak gerektiğinde otomatik olarak artırılır.

Yük faktörü, öğelerin demetlere en yüksek oranıdır. Daha küçük bir yük faktörü, artan bellek tüketimi maliyetiyle daha hızlı arama anlamına gelir. 1,0 yük faktörü, hız ve boyut arasındaki en iyi dengedir.

Gerçek yük faktörü belirtilen yük faktörüne ulaştığında, demet 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 yükseltilir.

Karma kod sağlayıcısı içindeki anahtarlar Hashtableiçin karma kodları dağıtır. Varsayılan karma kod sağlayıcısı anahtarın uygulamasıdır Object.GetHashCode.

Karşılaştırıcı, iki anahtarın eşit olup olmadığını belirler. içindeki Hashtable her anahtar benzersiz olmalıdır. Varsayılan karşılaştırıcı anahtarın uygulamasıdır Object.Equals.

Özel karma kod sağlayıcısı ve özel karşılaştırıcı, büyük/küçük harfe duyarlı olmayan dizelerle arama yapma gibi senaryoları etkinleştirir.

Bu oluşturucu, n parametresi olan bir O(n) işlemdircapacity.

Ayrıca bkz.

• IHashCodeProvider
• IComparer
• GetHashCode()
• Equals(Object)

Hashtable(IDictionary, Single, IHashCodeProvider, IComparer)

Kaynak:

Hashtable.cs

Dikkat

This constructor has been deprecated. Use Hashtable(IDictionary, float, IEqualityComparer) instead.

Belirtilen sözlükten yeni nesneye Hashtable öğeleri kopyalayarak sınıfı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ü, karma kod sağlayıcısı ve karşılaştırıcıyı kullanır.

public:
 Hashtable(System::Collections::IDictionary ^ d, float loadFactor, System::Collections::IHashCodeProvider ^ hcp, System::Collections::IComparer ^ comparer);

[System.Obsolete("This constructor has been deprecated. Use Hashtable(IDictionary, float, IEqualityComparer) instead.")]
public Hashtable (System.Collections.IDictionary d, float loadFactor, System.Collections.IHashCodeProvider? hcp, System.Collections.IComparer? comparer);

[<System.Obsolete("This constructor has been deprecated. Use Hashtable(IDictionary, float, IEqualityComparer) instead.")>]
new System.Collections.Hashtable : System.Collections.IDictionary * single * System.Collections.IHashCodeProvider * System.Collections.IComparer -> System.Collections.Hashtable

Public Sub New (d As IDictionary, loadFactor As Single, hcp As IHashCodeProvider, comparer As IComparer)

Parametreler

d

IDictionary

IDictionary Yeni Hashtable bir nesneye kopyalanacak nesne.

loadFactor

Single

0,1 ile 1,0 aralığındaki bir sayı, en iyi performansı sağlayan varsayılan değerle çarpılır. Sonuç, öğelerin demetlere en yüksek oranıdır.

hcp

IHashCodeProvider

içindeki IHashCodeProvider tüm anahtarlar Hashtableiçin karma kodları sağlayan nesne.

-veya-

null her anahtarın uygulaması olan varsayılan karma kod sağlayıcısını kullanmak için GetHashCode().

comparer

IComparer

İki anahtarın IComparer eşit olup olmadığını belirlemek için kullanılacak nesne.

-veya-

null her anahtarın uygulaması olan varsayılan karşılaştırıcıyı kullanmak için Equals(Object).

Öznitelikler

ObsoleteAttribute

Özel durumlar

ArgumentNullException

d, null değeridir.

ArgumentOutOfRangeException

loadFactor 0,1'den küçüktür.

-veya-

loadFactor 1,0'dan büyük.

Örnekler

Aşağıdaki kod örneği, farklı Hashtable oluşturucular kullanarak karma tablolar oluşturur ve her biri aynı öğeleri içerse bile karma tabloların davranışındaki farkları gösterir.

using namespace System;
using namespace System::Collections;
using namespace System::Globalization;

ref class myCultureComparer : public IEqualityComparer
{
public:
    CaseInsensitiveComparer^ myComparer;

public:
    myCultureComparer()
    {
        myComparer = CaseInsensitiveComparer::DefaultInvariant;
    }

public:
    myCultureComparer(CultureInfo^ myCulture)
    {
        myComparer = gcnew CaseInsensitiveComparer(myCulture);
    }

public:
    virtual bool Equals(Object^ x, Object^ y)
    {
        if (myComparer->Compare(x, y) == 0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

public:
    virtual int GetHashCode(Object^ obj)
    {
        // Compare the hash code for the lowercase versions of the strings.
        return obj->ToString()->ToLower()->GetHashCode();
    }
};

public ref class SamplesHashtable
{

public:
    static void Main()
    {
       
       // Create the dictionary.
       SortedList^ mySL = gcnew SortedList;
       mySL->Add( "FIRST", "Hello" );
       mySL->Add( "SECOND", "World" );
       mySL->Add( "THIRD", "!" );
       
       // Create a hash table using the default hash code provider and the default comparer.
       Hashtable^ myHT1 = gcnew Hashtable( mySL, .8f );
       
       // Create a hash table using the specified case-insensitive hash code provider and case-insensitive comparer.
       Hashtable^ myHT2 = gcnew Hashtable( mySL, .8f, gcnew myCultureComparer() );
       
       // Create a hash table using the specified KeyComparer.
       // The KeyComparer uses a case-insensitive hash code provider and a case-insensitive comparer,
       // which are based on the Turkish culture (tr-TR), where "I" is not the uppercase version of "i".
       CultureInfo^ myCul = gcnew CultureInfo( "tr-TR" );
       Hashtable^ myHT3 = gcnew Hashtable( mySL, .8f, gcnew myCultureComparer( myCul ) );
       
       // Search for a key in each hash table.
       Console::WriteLine( "first is in myHT1: {0}", myHT1->ContainsKey( "first" ) );
       Console::WriteLine( "first is in myHT2: {0}", myHT2->ContainsKey( "first" ) );
       Console::WriteLine( "first is in myHT3: {0}", myHT3->ContainsKey( "first" ) );
    }
};

int main()
{
    SamplesHashtable::Main();
}

/* 
This code produces the following output.  Results vary depending on the system's culture settings.

first is in myHT1: False
first is in myHT2: True
first is in myHT3: False

*/

using System;
using System.Collections;
using System.Globalization;

class myCultureComparer : IEqualityComparer
{
    public CaseInsensitiveComparer myComparer;

    public myCultureComparer()
    {
        myComparer = CaseInsensitiveComparer.DefaultInvariant;
    }

    public myCultureComparer(CultureInfo myCulture)
    {
        myComparer = new CaseInsensitiveComparer(myCulture);
    }

    public new bool Equals(object x, object y)
    {
        if (myComparer.Compare(x, y) == 0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    public int GetHashCode(object obj)
    {
        // Compare the hash code for the lowercase versions of the strings.
        return obj.ToString().ToLower().GetHashCode();
    }
}

public class SamplesHashtable
{

    public static void Main()
    {

        // Create the dictionary.
        SortedList mySL = new SortedList();
        mySL.Add("FIRST", "Hello");
        mySL.Add("SECOND", "World");
        mySL.Add("THIRD", "!");

        // Create a hash table using the default comparer.
        Hashtable myHT1 = new Hashtable(mySL, .8f);

        // Create a hash table using the specified IEqualityComparer that uses
        // the CaseInsensitiveComparer.DefaultInvariant to determine equality.
        Hashtable myHT2 = new Hashtable(mySL, .8f,
            new myCultureComparer());

        // Create a hash table using an IEqualityComparer that is based on
        // the Turkish culture (tr-TR) where "I" is not the uppercase
        // version of "i".
        CultureInfo myCul = new CultureInfo("tr-TR");
        Hashtable myHT3 = new Hashtable(mySL, .8f, new myCultureComparer(myCul));

        // Search for a key in each hash table.
        Console.WriteLine("first is in myHT1: {0}", myHT1.ContainsKey("first"));
        Console.WriteLine("first is in myHT2: {0}", myHT2.ContainsKey("first"));
        Console.WriteLine("first is in myHT3: {0}", myHT3.ContainsKey("first"));
    }
}


/*
This code produces the following output.
Results vary depending on the system's culture settings.

first is in myHT1: False
first is in myHT2: True
first is in myHT3: False

*/

Imports System.Collections
Imports System.Globalization

Public Class myCultureComparer
    Implements IEqualityComparer

    Dim myComparer As CaseInsensitiveComparer

    Public Sub New()
        myComparer = CaseInsensitiveComparer.DefaultInvariant
    End Sub

    Public Sub New(ByVal myCulture As CultureInfo)
        myComparer = New CaseInsensitiveComparer(myCulture)
    End Sub

    Public Function Equals1(ByVal x As Object, ByVal y As Object) _
        As Boolean Implements IEqualityComparer.Equals

        If (myComparer.Compare(x, y) = 0) Then
            Return True
        Else
            Return False
        End If
    End Function

    Public Function GetHashCode1(ByVal obj As Object) _
        As Integer Implements IEqualityComparer.GetHashCode
        Return obj.ToString().ToLower().GetHashCode()
    End Function
End Class

Public Class SamplesHashtable   

   Public Shared Sub Main()

      ' Create the dictionary.
      Dim mySL As New SortedList()
      mySL.Add("FIRST", "Hello")
      mySL.Add("SECOND", "World")
      mySL.Add("THIRD", "!")

      ' Create a hash table using the default comparer.
      Dim myHT1 As New Hashtable(mySL, System.Convert.ToSingle(0.8))

      ' Create a hash table using the specified IEqualityComparer that uses
      ' the CaseInsensitiveComparer.DefaultInvariant to determine equality.
      Dim myHT2 As New Hashtable(mySL, System.Convert.ToSingle(0.8), _
        New myCultureComparer())

      ' Create a hash table using an IEqualityComparer that is based on
      ' the Turkish culture (tr-TR) where "I" is not the uppercase
      ' version of "i".
      Dim myCul As New CultureInfo("tr-TR")
      Dim myHT3 As New Hashtable(mySL, System.Convert.ToSingle(0.8), _
        New myCultureComparer(myCul))

      ' Search for a key in each hash table.
      Console.WriteLine("first is in myHT1: {0}", myHT1.ContainsKey("first"))
      Console.WriteLine("first is in myHT2: {0}", myHT2.ContainsKey("first"))
      Console.WriteLine("first is in myHT3: {0}", myHT3.ContainsKey("first"))

   End Sub

End Class


'This code produces the following output.
'Results vary depending on the system's culture settings.
'
'first is in myHT1: False
'first is in myHT2: True
'first is in myHT3: False

Açıklamalar

İlk kapasite, kaynak sözlükteki öğe sayısına ayarlanır. Kapasite, yük faktörüne göre gerektiği gibi otomatik olarak artırılır.

Yük faktörü, öğelerin demetlere en yüksek oranıdır. Daha küçük bir yük faktörü, artan bellek tüketimi maliyetinde daha hızlı arama anlamına gelir. 1,0 yük faktörü, hız ve boyut arasındaki en iyi dengedir.

Gerçek yük faktörü belirtilen yük faktörüne ulaştığında, demet 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 yükseltilir.

Karma kod sağlayıcısı nesnedeki Hashtable anahtarlar için karma kodları dağıtır. Varsayılan karma kod sağlayıcısı anahtarın uygulamasıdır Object.GetHashCode.

Karşılaştırıcı, iki anahtarın eşit olup olmadığını belirler. içindeki Hashtable her anahtar benzersiz olmalıdır. Varsayılan karşılaştırıcı anahtarın uygulamasıdır Object.Equals.

Özel karma kod sağlayıcısı ve özel karşılaştırıcı, büyük/küçük harfe duyarlı olmayan dizelerle arama yapma gibi senaryoları etkinleştirir.

Yeni Hashtable öğesinin öğeleri, numaralandırıcının nesne üzerinden IDictionary yinelendiği sırayla sıralanır.

Bu oluşturucu, n parametresindeki d öğelerin sayısı olan bir O(n) işlemdir.

Hashtable(Int32, Single, IEqualityComparer)

Kaynak:

Hashtable.cs

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.

public:
 Hashtable(int capacity, float loadFactor, System::Collections::IEqualityComparer ^ equalityComparer);

public Hashtable (int capacity, float loadFactor, System.Collections.IEqualityComparer? equalityComparer);

new System.Collections.Hashtable : int * single * System.Collections.IEqualityComparer -> System.Collections.Hashtable

Public Sub New (capacity As Integer, loadFactor As Single, equalityComparer As IEqualityComparer)

Parametreler

capacity

Int32

Nesnenin Hashtable başlangıçta içerebileceği yaklaşık öğe sayısı.

loadFactor

Single

0,1 ile 1,0 aralığındaki bir sayı, en iyi performansı sağlayan varsayılan değerle çarpılır. Sonuç, öğelerin demetlere en yüksek oranıdır.

equalityComparer

IEqualityComparer

IEqualityComparer karma kod sağlayıcısını ve ile Hashtablekullanılacak karşılaştırıcıyı tanımlayan nesne.

-veya-

null varsayılan karma kod sağlayıcısını ve varsayılan karşılaştırıcıyı kullanmak için. Varsayılan karma kod sağlayıcısı her anahtarın GetHashCode() uygulamasıdır ve varsayılan karşılaştırıcı her anahtarın Equals(Object)uygulamasıdır.

Özel durumlar

ArgumentOutOfRangeException

capacity, sıfırdan küçüktür.

-veya-

loadFactor 0,1'den küçüktür.

-veya-

loadFactor 1,0'dan büyük.

Örnekler

Aşağıdaki kod örneği, farklı Hashtable oluşturucular kullanarak karma tablolar oluşturur ve her biri aynı öğeleri içerse bile karma tabloların davranışındaki farkları gösterir.

using namespace System;
using namespace System::Collections;
using namespace System::Globalization;

ref class myCultureComparer : public IEqualityComparer
{
public:
    CaseInsensitiveComparer^ myComparer;

public:
    myCultureComparer()
    {
        myComparer = CaseInsensitiveComparer::DefaultInvariant;
    }

public:
    myCultureComparer(CultureInfo^ myCulture)
    {
        myComparer = gcnew CaseInsensitiveComparer(myCulture);
    }

public:
    virtual bool Equals(Object^ x, Object^ y)
    {
        if (myComparer->Compare(x, y) == 0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

public:
    virtual int GetHashCode(Object^ obj)
    {
        // Compare the hash code for the lowercase versions of the strings.
        return obj->ToString()->ToLower()->GetHashCode();
    }
};

public ref class SamplesHashtable
{

public:
    static void Main()
    {
        // Create a hash table using the default comparer.
        Hashtable^ myHT1 = gcnew Hashtable(3, .8f);
        myHT1->Add("FIRST", "Hello");
        myHT1->Add("SECOND", "World");
        myHT1->Add("THIRD", "!");

        // Create a hash table using the specified IEqualityComparer that uses
        // the CaseInsensitiveComparer.DefaultInvariant to determine equality.
        Hashtable^ myHT2 = gcnew Hashtable(3, .8f, gcnew myCultureComparer());
        myHT2->Add("FIRST", "Hello");
        myHT2->Add("SECOND", "World");
        myHT2->Add("THIRD", "!");

        // Create a hash table using an IEqualityComparer that is based on
        // the Turkish culture (tr-TR) where "I" is not the uppercase
        // version of "i".
        CultureInfo^ myCul = gcnew CultureInfo("tr-TR");
        Hashtable^ myHT3 = gcnew Hashtable(3, .8f, gcnew myCultureComparer(myCul));
        myHT3->Add("FIRST", "Hello");
        myHT3->Add("SECOND", "World");
        myHT3->Add("THIRD", "!");

        // Search for a key in each hash table.
        Console::WriteLine("first is in myHT1: {0}", myHT1->ContainsKey("first"));
        Console::WriteLine("first is in myHT2: {0}", myHT2->ContainsKey("first"));
        Console::WriteLine("first is in myHT3: {0}", myHT3->ContainsKey("first"));

    }
};

int main()
{
    SamplesHashtable::Main();
}

/* 
This code produces the following output.  Results vary depending on the system's culture settings.

first is in myHT1: False
first is in myHT2: True
first is in myHT3: False

*/

using System;
using System.Collections;
using System.Globalization;

class myCultureComparer : IEqualityComparer
{
    public CaseInsensitiveComparer myComparer;

    public myCultureComparer()
    {
        myComparer = CaseInsensitiveComparer.DefaultInvariant;
    }

    public myCultureComparer(CultureInfo myCulture)
    {
        myComparer = new CaseInsensitiveComparer(myCulture);
    }

    public new bool Equals(object x, object y)
    {
        if (myComparer.Compare(x, y) == 0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    public int GetHashCode(object obj)
    {
        // Compare the hash code for the lowercase versions of the strings.
        return obj.ToString().ToLower().GetHashCode();
    }
}

public class SamplesHashtable
{

    public static void Main()
    {

        // Create a hash table using the default comparer.
        Hashtable myHT1 = new Hashtable(3, .8f);
        myHT1.Add("FIRST", "Hello");
        myHT1.Add("SECOND", "World");
        myHT1.Add("THIRD", "!");

        // Create a hash table using the specified IEqualityComparer that uses
        // the CaseInsensitiveComparer.DefaultInvariant to determine equality.
        Hashtable myHT2 = new Hashtable(3, .8f, new myCultureComparer());
        myHT2.Add("FIRST", "Hello");
        myHT2.Add("SECOND", "World");
        myHT2.Add("THIRD", "!");

        // Create a hash table using an IEqualityComparer that is based on
        // the Turkish culture (tr-TR) where "I" is not the uppercase
        // version of "i".
        CultureInfo myCul = new CultureInfo("tr-TR");
        Hashtable myHT3 = new Hashtable(3, .8f, new myCultureComparer(myCul));

        myHT3.Add("FIRST", "Hello");
        myHT3.Add("SECOND", "World");
        myHT3.Add("THIRD", "!");

        // Search for a key in each hash table.
        Console.WriteLine("first is in myHT1: {0}", myHT1.ContainsKey("first"));
        Console.WriteLine("first is in myHT2: {0}", myHT2.ContainsKey("first"));
        Console.WriteLine("first is in myHT3: {0}", myHT3.ContainsKey("first"));
    }
}


/*
This code produces the following output.
Results vary depending on the system's culture settings.

first is in myHT1: False
first is in myHT2: True
first is in myHT3: False

*/

Imports System.Collections
Imports System.Globalization

Public Class myCultureComparer
    Implements IEqualityComparer

    Dim myComparer As CaseInsensitiveComparer

    Public Sub New()
        myComparer = CaseInsensitiveComparer.DefaultInvariant
    End Sub

    Public Sub New(ByVal myCulture As CultureInfo)
        myComparer = New CaseInsensitiveComparer(myCulture)
    End Sub

    Public Function Equals1(ByVal x As Object, ByVal y As Object) _
        As Boolean Implements IEqualityComparer.Equals

        If (myComparer.Compare(x, y) = 0) Then
            Return True
        Else
            Return False
        End If
    End Function

    Public Function GetHashCode1(ByVal obj As Object) _
        As Integer Implements IEqualityComparer.GetHashCode
        Return obj.ToString().ToLower().GetHashCode()
    End Function
End Class

Public Class SamplesHashtable

    Public Shared Sub Main()

        ' Create a hash table using the default comparer.
        Dim myHT1 As New Hashtable(3, System.Convert.ToSingle(0.8))
        myHT1.Add("FIRST", "Hello")
        myHT1.Add("SECOND", "World")
        myHT1.Add("THIRD", "!")

        ' Create a hash table using the specified IEqualityComparer that uses
        ' the CaseInsensitiveComparer.DefaultInvariant to determine equality.
        Dim myHT2 As New Hashtable(3, System.Convert.ToSingle(0.8), _
            New myCultureComparer())

        myHT2.Add("FIRST", "Hello")
        myHT2.Add("SECOND", "World")
        myHT2.Add("THIRD", "!")

        ' Create a hash table using an IEqualityComparer that is based on
        ' the Turkish culture (tr-TR) where "I" is not the uppercase
        ' version of "i".
        Dim myCul As New CultureInfo("tr-TR")
        Dim myHT3 As New Hashtable(3, System.Convert.ToSingle(0.8), _
            New myCultureComparer(myCul))

        myHT3.Add("FIRST", "Hello")
        myHT3.Add("SECOND", "World")
        myHT3.Add("THIRD", "!")

        ' Search for a key in each hash table.
        Console.WriteLine("first is in myHT1: {0}", myHT1.ContainsKey("first"))
        Console.WriteLine("first is in myHT2: {0}", myHT2.ContainsKey("first"))
        Console.WriteLine("first is in myHT3: {0}", myHT3.ContainsKey("first"))

    End Sub

End Class


'This code produces the following output.
'Results vary depending on the system's culture settings.
'
'first is in myHT1: False
'first is in myHT2: True
'first is in myHT3: False

Açıklamalar

İlk kapasitenin belirtilmesi, nesneye öğe eklerken bir dizi yeniden boyutlandırma işlemi gerçekleştirme gereğini Hashtable ortadan kaldırır. Kapasite, yük faktörüne göre gerektiği gibi otomatik olarak artırılır.

Yük faktörü, öğelerin demetlere en yüksek oranıdır. Daha küçük bir yük faktörü, artan bellek tüketimi maliyetinde daha hızlı arama anlamına gelir. 1,0 yük faktörü, hız ve boyut arasındaki en iyi dengedir.

Gerçek yük faktörü belirtilen yük faktörüne ulaştığında, demet 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 yükseltilir.

IEqualityComparer nesnesi hem karma kod sağlayıcısını hem de karşılaştırıcıyı içerir. IEqualityComparer oluşturucuda Hashtable kullanılırsa, ve Object.Equals yöntemlerini geçersiz kılmak Object.GetHashCode için içinde Hashtable anahtar olarak kullanılan nesneler gerekli değildir.

Karma kod sağlayıcısı içindeki anahtarlar Hashtableiçin karma kodları dağıtır. Varsayılan karma kod sağlayıcısı anahtarın uygulamasıdır Object.GetHashCode.

Karşılaştırıcı, iki anahtarın eşit olup olmadığını belirler. içindeki Hashtable her anahtar benzersiz olmalıdır. Varsayılan karşılaştırıcı anahtarın uygulamasıdır Object.Equals.

, IEqualityComparer büyük/küçük harfe duyarlı olmayan dizelerle arama yapma gibi senaryoları etkinleştirir.

Bu oluşturucu, parametresi olan n bir O(n) işlemdircapacity.

Ayrıca bkz.

• IEqualityComparer

Hashtable(Int32, IHashCodeProvider, IComparer)

Kaynak:

Hashtable.cs

Dikkat

This constructor has been deprecated. Use Hashtable(int, IEqualityComparer) instead.

Belirtilen ilk kapasiteyi, karma kod sağlayıcısını, karşılaştırıcıyı Hashtable ve varsayılan yük faktörünü kullanarak sınıfın yeni, boş bir örneğini başlatır.

public:
 Hashtable(int capacity, System::Collections::IHashCodeProvider ^ hcp, System::Collections::IComparer ^ comparer);

[System.Obsolete("This constructor has been deprecated. Use Hashtable(int, IEqualityComparer) instead.")]
public Hashtable (int capacity, System.Collections.IHashCodeProvider? hcp, System.Collections.IComparer? comparer);

[<System.Obsolete("This constructor has been deprecated. Use Hashtable(int, IEqualityComparer) instead.")>]
new System.Collections.Hashtable : int * System.Collections.IHashCodeProvider * System.Collections.IComparer -> System.Collections.Hashtable

Public Sub New (capacity As Integer, hcp As IHashCodeProvider, comparer As IComparer)

Parametreler

capacity

Int32

Nesnenin Hashtable başlangıçta içerebileceği yaklaşık öğe sayısı.

hcp

IHashCodeProvider

içindeki IHashCodeProvider tüm anahtarlar Hashtableiçin karma kodları sağlayan nesne.

-veya-

null her anahtarın uygulaması olan varsayılan karma kod sağlayıcısını kullanmak için GetHashCode().

comparer

IComparer

İki anahtarın IComparer eşit olup olmadığını belirlemek için kullanılacak nesne.

-veya-

null her anahtarın uygulaması olan varsayılan karşılaştırıcıyı kullanmak için Equals(Object).

Öznitelikler

ObsoleteAttribute

Özel durumlar

ArgumentOutOfRangeException

capacity, sıfırdan küçüktür.

Örnekler

Aşağıdaki kod örneği, farklı Hashtable oluşturucular kullanarak karma tablolar oluşturur ve her biri aynı öğeleri içerse bile karma tabloların davranışındaki farkları gösterir.

using namespace System;
using namespace System::Collections;
using namespace System::Globalization;

ref class myCultureComparer : public IEqualityComparer
{
public:
    CaseInsensitiveComparer^ myComparer;

public:
    myCultureComparer()
    {
        myComparer = CaseInsensitiveComparer::DefaultInvariant;
    }

public:
    myCultureComparer(CultureInfo^ myCulture)
    {
        myComparer = gcnew CaseInsensitiveComparer(myCulture);
    }

public:
    virtual bool Equals(Object^ x, Object^ y)
    {
        if (myComparer->Compare(x, y) == 0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

public:
    virtual int GetHashCode(Object^ obj)
    {
        // Compare the hash code for the lowercase versions of the strings.
        return obj->ToString()->ToLower()->GetHashCode();
    }
};

public ref class SamplesHashtable
{

public:
    static void Main()
    {
        // Create a hash table using the default comparer.
        Hashtable^ myHT1 = gcnew Hashtable(3);
        myHT1->Add("FIRST", "Hello");
        myHT1->Add("SECOND", "World");
        myHT1->Add("THIRD", "!");

        // Create a hash table using the specified IEqualityComparer that uses
        // the CaseInsensitiveComparer.DefaultInvariant to determine equality.
        Hashtable^ myHT2 = gcnew Hashtable(3, gcnew myCultureComparer());
        myHT2->Add("FIRST", "Hello");
        myHT2->Add("SECOND", "World");
        myHT2->Add("THIRD", "!");

        // Create a hash table using an IEqualityComparer that is based on
        // the Turkish culture (tr-TR) where "I" is not the uppercase
        // version of "i".
        CultureInfo^ myCul = gcnew CultureInfo("tr-TR");
        Hashtable^ myHT3 = gcnew Hashtable(3, gcnew myCultureComparer(myCul));
        myHT3->Add("FIRST", "Hello");
        myHT3->Add("SECOND", "World");
        myHT3->Add("THIRD", "!");

        // Search for a key in each hash table.
        Console::WriteLine("first is in myHT1: {0}", myHT1->ContainsKey("first"));
        Console::WriteLine("first is in myHT2: {0}", myHT2->ContainsKey("first"));
        Console::WriteLine("first is in myHT3: {0}", myHT3->ContainsKey("first"));

    }
};

int main()
{
    SamplesHashtable::Main();
}

/* 
This code produces the following output.  Results vary depending on the system's culture settings.

first is in myHT1: False
first is in myHT2: True
first is in myHT3: False

*/

using System;
using System.Collections;
using System.Globalization;

class myCultureComparer : IEqualityComparer
{
    public CaseInsensitiveComparer myComparer;

    public myCultureComparer()
    {
        myComparer = CaseInsensitiveComparer.DefaultInvariant;
    }

    public myCultureComparer(CultureInfo myCulture)
    {
        myComparer = new CaseInsensitiveComparer(myCulture);
    }

    public new bool Equals(object x, object y)
    {
        if (myComparer.Compare(x, y) == 0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    public int GetHashCode(object obj)
    {
        // Compare the hash code for the lowercase versions of the strings.
        return obj.ToString().ToLower().GetHashCode();
    }
}

public class SamplesHashtable
{

    public static void Main()
    {

        // Create a hash table using the default comparer.
        Hashtable myHT1 = new Hashtable(3);
        myHT1.Add("FIRST", "Hello");
        myHT1.Add("SECOND", "World");
        myHT1.Add("THIRD", "!");

        // Create a hash table using the specified IEqualityComparer that uses
        // the CaseInsensitiveComparer.DefaultInvariant to determine equality.
        Hashtable myHT2 = new Hashtable(3, new myCultureComparer());
        myHT2.Add("FIRST", "Hello");
        myHT2.Add("SECOND", "World");
        myHT2.Add("THIRD", "!");

        // Create a hash table using an IEqualityComparer that is based on
        // the Turkish culture (tr-TR) where "I" is not the uppercase
        // version of "i".
        CultureInfo myCul = new CultureInfo("tr-TR");
        Hashtable myHT3 = new Hashtable(3, new myCultureComparer(myCul));
        myHT3.Add("FIRST", "Hello");
        myHT3.Add("SECOND", "World");
        myHT3.Add("THIRD", "!");

        // Search for a key in each hash table.
        Console.WriteLine("first is in myHT1: {0}", myHT1.ContainsKey("first"));
        Console.WriteLine("first is in myHT2: {0}", myHT2.ContainsKey("first"));
        Console.WriteLine("first is in myHT3: {0}", myHT3.ContainsKey("first"));
    }
}


/*
This code produces the following output.
Results vary depending on the system's culture settings.

first is in myHT1: False
first is in myHT2: True
first is in myHT3: False

*/

Imports System.Collections
Imports System.Globalization

Public Class myCultureComparer
    Implements IEqualityComparer

    Dim myComparer As CaseInsensitiveComparer

    Public Sub New()
        myComparer = CaseInsensitiveComparer.DefaultInvariant
    End Sub

    Public Sub New(ByVal myCulture As CultureInfo)
        myComparer = New CaseInsensitiveComparer(myCulture)
    End Sub

    Public Function Equals1(ByVal x As Object, ByVal y As Object) _
        As Boolean Implements IEqualityComparer.Equals

        If (myComparer.Compare(x, y) = 0) Then
            Return True
        Else
            Return False
        End If
    End Function

    Public Function GetHashCode1(ByVal obj As Object) _
        As Integer Implements IEqualityComparer.GetHashCode
        Return obj.ToString().ToLower().GetHashCode()
    End Function
End Class

Public Class SamplesHashtable   

   Public Shared Sub Main()

      ' Create a hash table using the default comparer.
      Dim myHT1 As New Hashtable(3)
      myHT1.Add("FIRST", "Hello")
      myHT1.Add("SECOND", "World")
      myHT1.Add("THIRD", "!")

      ' Create a hash table using the specified IEqualityComparer that uses
      ' the CaseInsensitiveComparer.DefaultInvariant to determine equality.
      Dim myHT2 As New Hashtable(3, New myCultureComparer())
      myHT2.Add("FIRST", "Hello")
      myHT2.Add("SECOND", "World")
      myHT2.Add("THIRD", "!")

      ' Create a hash table using an IEqualityComparer that is based on
      ' the Turkish culture (tr-TR) where "I" is not the uppercase
      ' version of "i".
      Dim myCul As New CultureInfo("tr-TR")
      Dim myHT3 As New Hashtable(3, New myCultureComparer(myCul))
      myHT3.Add("FIRST", "Hello")
      myHT3.Add("SECOND", "World")
      myHT3.Add("THIRD", "!")

      ' Search for a key in each hash table.
      Console.WriteLine("first is in myHT1: {0}", myHT1.ContainsKey("first"))
      Console.WriteLine("first is in myHT2: {0}", myHT2.ContainsKey("first"))
      Console.WriteLine("first is in myHT3: {0}", myHT3.ContainsKey("first"))

   End Sub

End Class


'This code produces the following output.
'Results vary depending on the system's culture settings.
'
'first is in myHT1: False
'first is in myHT2: True
'first is in myHT3: False

Açıklamalar

İlk kapasitenin belirtilmesi, nesneye öğe eklerken bir dizi yeniden boyutlandırma işlemi gerçekleştirme gereğini Hashtable ortadan kaldırır. Kapasite, yük faktörüne göre gerektiği gibi otomatik olarak artırılır.

Yük faktörü, öğelerin demetlere en yüksek oranıdır. Daha küçük bir yük faktörü, artan bellek tüketimi maliyetinde daha hızlı arama anlamına gelir.

Gerçek yük faktörü belirtilen yük faktörüne ulaştığında, demet 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 yükseltilir.

Karma kod sağlayıcısı içindeki anahtarlar Hashtableiçin karma kodları dağıtır. Varsayılan karma kod sağlayıcısı anahtarın uygulamasıdır Object.GetHashCode.

Karşılaştırıcı, iki anahtarın eşit olup olmadığını belirler. içindeki Hashtable her anahtar benzersiz olmalıdır. Varsayılan karşılaştırıcı anahtarın uygulamasıdır Object.Equals.

Özel karma kod sağlayıcısı ve özel karşılaştırıcı, büyük/küçük harfe duyarlı olmayan dizelerle arama yapma gibi senaryoları etkinleştirir.

Bu oluşturucu, parametresi olan n bir O(n) işlemdircapacity.

Ayrıca bkz.

• IHashCodeProvider
• IComparer
• GetHashCode()
• Equals(Object)

Hashtable(IDictionary, Single, IEqualityComparer)

Kaynak:

Hashtable.cs

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.

public:
 Hashtable(System::Collections::IDictionary ^ d, float loadFactor, System::Collections::IEqualityComparer ^ equalityComparer);

public Hashtable (System.Collections.IDictionary d, float loadFactor, System.Collections.IEqualityComparer? equalityComparer);

new System.Collections.Hashtable : System.Collections.IDictionary * single * System.Collections.IEqualityComparer -> System.Collections.Hashtable

Public Sub New (d As IDictionary, loadFactor As Single, equalityComparer As IEqualityComparer)

Parametreler

d

IDictionary

IDictionary Yeni Hashtable bir nesneye kopyalanacak nesne.

loadFactor

Single

0,1 ile 1,0 aralığındaki bir sayı, en iyi performansı sağlayan varsayılan değerle çarpılır. Sonuç, öğelerin demetlere en yüksek oranıdır.

equalityComparer

IEqualityComparer

IEqualityComparer karma kod sağlayıcısını ve ile Hashtablekullanılacak karşılaştırıcıyı tanımlayan nesne.

-veya-

null varsayılan karma kod sağlayıcısını ve varsayılan karşılaştırıcıyı kullanmak için. Varsayılan karma kod sağlayıcısı her anahtarın GetHashCode() uygulamasıdır ve varsayılan karşılaştırıcı her anahtarın Equals(Object)uygulamasıdır.

Özel durumlar

ArgumentNullException

d, null değeridir.

ArgumentOutOfRangeException

loadFactor 0,1'den küçüktür.

-veya-

loadFactor 1,0'dan büyük.

Örnekler

Aşağıdaki kod örneği, farklı Hashtable oluşturucular kullanarak karma tablolar oluşturur ve her biri aynı öğeleri içerse bile karma tabloların davranışındaki farkları gösterir.

using namespace System;
using namespace System::Collections;
using namespace System::Globalization;

ref class myCultureComparer : public IEqualityComparer
{
public:
    CaseInsensitiveComparer^ myComparer;

public:
    myCultureComparer()
    {
        myComparer = CaseInsensitiveComparer::DefaultInvariant;
    }

public:
    myCultureComparer(CultureInfo^ myCulture)
    {
        myComparer = gcnew CaseInsensitiveComparer(myCulture);
    }

public:
    virtual bool Equals(Object^ x, Object^ y)
    {
        if (myComparer->Compare(x, y) == 0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

public:
    virtual int GetHashCode(Object^ obj)
    {
        // Compare the hash code for the lowercase versions of the strings.
        return obj->ToString()->ToLower()->GetHashCode();
    }
};

public ref class SamplesHashtable
{

public:
    static void Main()
    {
       
       // Create the dictionary.
       SortedList^ mySL = gcnew SortedList;
       mySL->Add( "FIRST", "Hello" );
       mySL->Add( "SECOND", "World" );
       mySL->Add( "THIRD", "!" );
       
       // Create a hash table using the default hash code provider and the default comparer.
       Hashtable^ myHT1 = gcnew Hashtable( mySL, .8f );
       
       // Create a hash table using the specified case-insensitive hash code provider and case-insensitive comparer.
       Hashtable^ myHT2 = gcnew Hashtable( mySL, .8f, gcnew myCultureComparer() );
       
       // Create a hash table using the specified KeyComparer.
       // The KeyComparer uses a case-insensitive hash code provider and a case-insensitive comparer,
       // which are based on the Turkish culture (tr-TR), where "I" is not the uppercase version of "i".
       CultureInfo^ myCul = gcnew CultureInfo( "tr-TR" );
       Hashtable^ myHT3 = gcnew Hashtable( mySL, .8f, gcnew myCultureComparer( myCul ) );
       
       // Search for a key in each hash table.
       Console::WriteLine( "first is in myHT1: {0}", myHT1->ContainsKey( "first" ) );
       Console::WriteLine( "first is in myHT2: {0}", myHT2->ContainsKey( "first" ) );
       Console::WriteLine( "first is in myHT3: {0}", myHT3->ContainsKey( "first" ) );
    }
};

int main()
{
    SamplesHashtable::Main();
}

/* 
This code produces the following output.  Results vary depending on the system's culture settings.

first is in myHT1: False
first is in myHT2: True
first is in myHT3: False

*/

using System;
using System.Collections;
using System.Globalization;

class myCultureComparer : IEqualityComparer
{
    public CaseInsensitiveComparer myComparer;

    public myCultureComparer()
    {
        myComparer = CaseInsensitiveComparer.DefaultInvariant;
    }

    public myCultureComparer(CultureInfo myCulture)
    {
        myComparer = new CaseInsensitiveComparer(myCulture);
    }

    public new bool Equals(object x, object y)
    {
        if (myComparer.Compare(x, y) == 0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    public int GetHashCode(object obj)
    {
        // Compare the hash code for the lowercase versions of the strings.
        return obj.ToString().ToLower().GetHashCode();
    }
}

public class SamplesHashtable
{

    public static void Main()
    {

        // Create the dictionary.
        SortedList mySL = new SortedList();
        mySL.Add("FIRST", "Hello");
        mySL.Add("SECOND", "World");
        mySL.Add("THIRD", "!");

        // Create a hash table using the default comparer.
        Hashtable myHT1 = new Hashtable(mySL, .8f);

        // Create a hash table using the specified IEqualityComparer that uses
        // the CaseInsensitiveComparer.DefaultInvariant to determine equality.
        Hashtable myHT2 = new Hashtable(mySL, .8f,
            new myCultureComparer());

        // Create a hash table using an IEqualityComparer that is based on
        // the Turkish culture (tr-TR) where "I" is not the uppercase
        // version of "i".
        CultureInfo myCul = new CultureInfo("tr-TR");
        Hashtable myHT3 = new Hashtable(mySL, .8f, new myCultureComparer(myCul));

        // Search for a key in each hash table.
        Console.WriteLine("first is in myHT1: {0}", myHT1.ContainsKey("first"));
        Console.WriteLine("first is in myHT2: {0}", myHT2.ContainsKey("first"));
        Console.WriteLine("first is in myHT3: {0}", myHT3.ContainsKey("first"));
    }
}


/*
This code produces the following output.
Results vary depending on the system's culture settings.

first is in myHT1: False
first is in myHT2: True
first is in myHT3: False

*/

Imports System.Collections
Imports System.Globalization

Public Class myCultureComparer
    Implements IEqualityComparer

    Dim myComparer As CaseInsensitiveComparer

    Public Sub New()
        myComparer = CaseInsensitiveComparer.DefaultInvariant
    End Sub

    Public Sub New(ByVal myCulture As CultureInfo)
        myComparer = New CaseInsensitiveComparer(myCulture)
    End Sub

    Public Function Equals1(ByVal x As Object, ByVal y As Object) _
        As Boolean Implements IEqualityComparer.Equals

        If (myComparer.Compare(x, y) = 0) Then
            Return True
        Else
            Return False
        End If
    End Function

    Public Function GetHashCode1(ByVal obj As Object) _
        As Integer Implements IEqualityComparer.GetHashCode
        Return obj.ToString().ToLower().GetHashCode()
    End Function
End Class

Public Class SamplesHashtable   

   Public Shared Sub Main()

      ' Create the dictionary.
      Dim mySL As New SortedList()
      mySL.Add("FIRST", "Hello")
      mySL.Add("SECOND", "World")
      mySL.Add("THIRD", "!")

      ' Create a hash table using the default comparer.
      Dim myHT1 As New Hashtable(mySL, System.Convert.ToSingle(0.8))

      ' Create a hash table using the specified IEqualityComparer that uses
      ' the CaseInsensitiveComparer.DefaultInvariant to determine equality.
      Dim myHT2 As New Hashtable(mySL, System.Convert.ToSingle(0.8), _
        New myCultureComparer())

      ' Create a hash table using an IEqualityComparer that is based on
      ' the Turkish culture (tr-TR) where "I" is not the uppercase
      ' version of "i".
      Dim myCul As New CultureInfo("tr-TR")
      Dim myHT3 As New Hashtable(mySL, System.Convert.ToSingle(0.8), _
        New myCultureComparer(myCul))

      ' Search for a key in each hash table.
      Console.WriteLine("first is in myHT1: {0}", myHT1.ContainsKey("first"))
      Console.WriteLine("first is in myHT2: {0}", myHT2.ContainsKey("first"))
      Console.WriteLine("first is in myHT3: {0}", myHT3.ContainsKey("first"))

   End Sub

End Class


'This code produces the following output.
'Results vary depending on the system's culture settings.
'
'first is in myHT1: False
'first is in myHT2: True
'first is in myHT3: False

Açıklamalar

İlk kapasite, kaynak sözlükteki öğe sayısına ayarlanır. Kapasite, yük faktörüne göre gerektiği gibi otomatik olarak artırılır.

Yük faktörü, öğelerin demetlere en yüksek oranıdır. Daha küçük bir yük faktörü, artan bellek tüketimi maliyetinde daha hızlı arama anlamına gelir. 1,0 yük faktörü, hız ve boyut arasındaki en iyi dengedir.

Gerçek yük faktörü belirtilen yük faktörüne ulaştığında, demet 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 yükseltilir.

IEqualityComparer nesnesi hem karma kod sağlayıcısını hem de karşılaştırıcıyı içerir. IEqualityComparer oluşturucuda Hashtable kullanılırsa, nesnede Hashtable anahtar olarak kullanılan nesneler ve Object.Equals yöntemlerini geçersiz kılmak Object.GetHashCode için gerekli değildir.

Karma kod sağlayıcısı içindeki anahtarlar Hashtableiçin karma kodları dağıtır. Varsayılan karma kod sağlayıcısı anahtarın uygulamasıdır Object.GetHashCode.

Karşılaştırıcı, iki anahtarın eşit olup olmadığını belirler. içindeki Hashtable her anahtar benzersiz olmalıdır. Varsayılan karşılaştırıcı anahtarın uygulamasıdır Object.Equals.

, IEqualityComparer büyük/küçük harfe duyarlı olmayan dizelerle arama yapma gibi senaryoları etkinleştirir.

Yeni Hashtable öğesinin öğeleri, numaralandırıcının nesnede IDictionary yinelendiği aynı düzende sıralanır.

Bu oluşturucu, n parametresindeki d öğelerin sayısı olan bir O(n) işlemdir.

Ayrıca bkz.

• IEqualityComparer

Hashtable(IDictionary, IHashCodeProvider, IComparer)

Kaynak:

Hashtable.cs

Dikkat

This constructor has been deprecated. Use Hashtable(IDictionary, IEqualityComparer) instead.

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). .

public:
 Hashtable(System::Collections::IDictionary ^ d, System::Collections::IHashCodeProvider ^ hcp, System::Collections::IComparer ^ comparer);

[System.Obsolete("This constructor has been deprecated. Use Hashtable(IDictionary, IEqualityComparer) instead.")]
public Hashtable (System.Collections.IDictionary d, System.Collections.IHashCodeProvider? hcp, System.Collections.IComparer? comparer);

[<System.Obsolete("This constructor has been deprecated. Use Hashtable(IDictionary, IEqualityComparer) instead.")>]
new System.Collections.Hashtable : System.Collections.IDictionary * System.Collections.IHashCodeProvider * System.Collections.IComparer -> System.Collections.Hashtable

Public Sub New (d As IDictionary, hcp As IHashCodeProvider, comparer As IComparer)

Parametreler

d

IDictionary

IDictionary Yeni Hashtable bir nesneye kopyalanacak nesne.

hcp

IHashCodeProvider

içindeki IHashCodeProvider tüm anahtarlar Hashtableiçin karma kodları sağlayan nesnesi.

-veya-

null her anahtarın uygulaması olan varsayılan karma kod sağlayıcısını kullanmak için GetHashCode().

comparer

IComparer

İki anahtarın IComparer eşit olup olmadığını belirlemek için kullanılacak nesne.

-veya-

null her anahtarın uygulaması olan varsayılan karşılaştırıcıyı kullanmak için Equals(Object).

Öznitelikler

ObsoleteAttribute

Özel durumlar

ArgumentNullException

d, null değeridir.

Örnekler

Aşağıdaki kod örneği, farklı Hashtable oluşturucular kullanarak karma tablolar oluşturur ve her biri aynı öğeleri içerse bile karma tabloların davranışındaki farkları gösterir.

using namespace System;
using namespace System::Collections;
using namespace System::Globalization;

ref class myCultureComparer : public IEqualityComparer
{
public:
    CaseInsensitiveComparer^ myComparer;

public:
    myCultureComparer()
    {
        myComparer = CaseInsensitiveComparer::DefaultInvariant;
    }

public:
    myCultureComparer(CultureInfo^ myCulture)
    {
        myComparer = gcnew CaseInsensitiveComparer(myCulture);
    }

public:
    virtual bool Equals(Object^ x, Object^ y)
    {
        if (myComparer->Compare(x, y) == 0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

public:
    virtual int GetHashCode(Object^ obj)
    {
        // Compare the hash code for the lowercase versions of the strings.
        return obj->ToString()->ToLower()->GetHashCode();
    }
};

public ref class SamplesHashtable
{

public:
    static void Main()
    {
        // Create the dictionary.
        SortedList^ mySL = gcnew SortedList();
        mySL->Add("FIRST", "Hello");
        mySL->Add("SECOND", "World");
        mySL->Add("THIRD", "!");

        // Create a hash table using the default comparer.
        Hashtable^ myHT1 = gcnew Hashtable(mySL);

        // Create a hash table using the specified IEqualityComparer that uses
        // the CaseInsensitiveComparer.DefaultInvariant to determine equality.
        Hashtable^ myHT2 = gcnew Hashtable(mySL, gcnew myCultureComparer());

        // Create a hash table using an IEqualityComparer that is based on
        // the Turkish culture (tr-TR) where "I" is not the uppercase
        // version of "i".
        CultureInfo^ myCul = gcnew CultureInfo("tr-TR");
        Hashtable^ myHT3 = gcnew Hashtable(mySL, gcnew myCultureComparer(myCul));

        // Search for a key in each hash table.
        Console::WriteLine("first is in myHT1: {0}", myHT1->ContainsKey("first"));
        Console::WriteLine("first is in myHT2: {0}", myHT2->ContainsKey("first"));
        Console::WriteLine("first is in myHT3: {0}", myHT3->ContainsKey("first"));
    }
};

int main()
{
    SamplesHashtable::Main();
};

/* 
This code produces the following output. 
Results vary depending on the system's culture settings.

first is in myHT1: False
first is in myHT2: True
first is in myHT3: False

*/

using System;
using System.Collections;
using System.Globalization;

class myCultureComparer : IEqualityComparer
{
    public CaseInsensitiveComparer myComparer;

    public myCultureComparer()
    {
        myComparer = CaseInsensitiveComparer.DefaultInvariant;
    }

    public myCultureComparer(CultureInfo myCulture)
    {
        myComparer = new CaseInsensitiveComparer(myCulture);
    }

    public new bool Equals(object x, object y)
    {
        return myComparer.Compare(x, y) == 0;
    }

    public int GetHashCode(object obj)
    {
        // Compare the hash code for the lowercase versions of the strings.
        return obj.ToString().ToLower().GetHashCode();
    }
}

public class SamplesHashtable
{

    public static void Main()
    {

        // Create the dictionary.
        var mySL = new SortedList();
        mySL.Add("FIRST", "Hello");
        mySL.Add("SECOND", "World");
        mySL.Add("THIRD", "!");

        // Create a hash table using the default comparer.
        var myHT1 = new Hashtable(mySL);

        // Create a hash table using the specified IEqualityComparer that uses
        // the CaseInsensitiveComparer.DefaultInvariant to determine equality.
        var myHT2 = new Hashtable(mySL, new myCultureComparer());

        // Create a hash table using an IEqualityComparer that is based on
        // the Turkish culture (tr-TR) where "I" is not the uppercase
        // version of "i".
        var myCul = new CultureInfo("tr-TR");
        var myHT3 = new Hashtable(mySL, new myCultureComparer(myCul));

        // Search for a key in each hash table.
        Console.WriteLine($"first is in myHT1: {myHT1.ContainsKey("first")}");
        Console.WriteLine($"first is in myHT2: {myHT2.ContainsKey("first")}");
        Console.WriteLine($"first is in myHT3: {myHT3.ContainsKey("first")}");
    }
}


/*
This code produces the following output.
Results vary depending on the system's culture settings.

first is in myHT1: False
first is in myHT2: True
first is in myHT3: False

*/

Imports System.Collections
Imports System.Globalization

Public Class myCultureComparer
    Implements IEqualityComparer

    Dim myComparer As CaseInsensitiveComparer

    Public Sub New()
        myComparer = CaseInsensitiveComparer.DefaultInvariant
    End Sub

    Public Sub New(ByVal myCulture As CultureInfo)
        myComparer = New CaseInsensitiveComparer(myCulture)
    End Sub

    Public Function Equals1(ByVal x As Object, ByVal y As Object) _
        As Boolean Implements IEqualityComparer.Equals

        Return myComparer.Compare(x, y) = 0
    End Function

    Public Function GetHashCode1(ByVal obj As Object) _
        As Integer Implements IEqualityComparer.GetHashCode
        Return obj.ToString().ToLower().GetHashCode()
    End Function
End Class

Public Class SamplesHashtable   

   Public Shared Sub Main()

      ' Create the dictionary.
      Dim mySL As New SortedList()
      mySL.Add("FIRST", "Hello")
      mySL.Add("SECOND", "World")
      mySL.Add("THIRD", "!")

      ' Create a hash table using the default comparer.
      Dim myHT1 As New Hashtable(mySL)

      ' Create a hash table using the specified IEqualityComparer that uses
      ' the CaseInsensitiveComparer.DefaultInvariant to determine equality.
      Dim myHT2 As New Hashtable(mySL, New myCultureComparer())

      ' Create a hash table using an IEqualityComparer that is based on
      ' the Turkish culture (tr-TR) where "I" is not the uppercase
      ' version of "i".
      Dim myCul As New CultureInfo("tr-TR")
      Dim myHT3 As New Hashtable(mySL, New myCultureComparer(myCul))

      ' Search for a key in each hash table.
      Console.WriteLine($"first is in myHT1: {myHT1.ContainsKey("first")}")
      Console.WriteLine($"first is in myHT2: {myHT2.ContainsKey("first")}")
      Console.WriteLine($"first is in myHT3: {myHT3.ContainsKey("first")}")

   End Sub

End Class


'This code produces the following output.
'Results vary depending on the system's culture settings.
'
'first is in myHT1: False
'first is in myHT2: True
'first is in myHT3: False

Açıklamalar

İlk kapasite, kaynak sözlükteki öğe sayısına ayarlanır. Kapasite, yük faktörüne bağlı olarak gerektiğinde otomatik olarak artırılır.

Yük faktörü, öğelerin demetlere en yüksek oranıdır. Daha küçük bir yük faktörü, artan bellek tüketimi maliyetiyle daha hızlı arama anlamına gelir.

Gerçek yük faktörü belirtilen yük faktörüne ulaştığında, demet 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 yükseltilir.

Karma kod sağlayıcısı nesnedeki Hashtable anahtarlar için karma kodları dağıtır. Varsayılan karma kod sağlayıcısı anahtarın uygulamasıdır Object.GetHashCode.

Karşılaştırıcı, iki anahtarın eşit olup olmadığını belirler. içindeki Hashtable her anahtar benzersiz olmalıdır. Varsayılan karşılaştırıcı anahtarın uygulamasıdır Object.Equals.

Özel karma kod sağlayıcısı ve özel karşılaştırıcı, büyük/küçük harfe duyarlı olmayan dizelerle arama yapma gibi senaryoları etkinleştirir.

Yeni Hashtable öğesinin öğeleri, numaralandırıcının nesnede IDictionary yinelendiği aynı düzende sıralanır.

Bu oluşturucu, n parametresindeki d öğelerin sayısı olan bir O(n) işlemdir.

Ayrıca bkz.

• IDictionary
• IHashCodeProvider
• IComparer
• GetHashCode()
• Equals(Object)

Hashtable(Int32, Single)

Kaynak:

Hashtable.cs

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.

public:
 Hashtable(int capacity, float loadFactor);

public Hashtable (int capacity, float loadFactor);

new System.Collections.Hashtable : int * single -> System.Collections.Hashtable

Public Sub New (capacity As Integer, loadFactor As Single)

Parametreler

capacity

Int32

Nesnenin Hashtable başlangıçta içerebileceği yaklaşık öğe sayısı.

loadFactor

Single

0,1 ile 1,0 aralığındaki bir sayı, en iyi performansı sağlayan varsayılan değerle çarpılır. Sonuç, öğelerin demetlere en yüksek oranıdır.

Özel durumlar

ArgumentOutOfRangeException

capacity, sıfırdan küçüktür.

-veya-

loadFactor 0,1'den küçüktür.

-veya-

loadFactor 1,0'dan büyük.

ArgumentException

capacity taşmalara neden oluyor.

Örnekler

Aşağıdaki kod örneği, farklı Hashtable oluşturucular kullanarak karma tablolar oluşturur ve her biri aynı öğeleri içerse bile karma tabloların davranışındaki farkları gösterir.

using namespace System;
using namespace System::Collections;
using namespace System::Globalization;

ref class myCultureComparer : public IEqualityComparer
{
public:
    CaseInsensitiveComparer^ myComparer;

public:
    myCultureComparer()
    {
        myComparer = CaseInsensitiveComparer::DefaultInvariant;
    }

public:
    myCultureComparer(CultureInfo^ myCulture)
    {
        myComparer = gcnew CaseInsensitiveComparer(myCulture);
    }

public:
    virtual bool Equals(Object^ x, Object^ y)
    {
        if (myComparer->Compare(x, y) == 0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

public:
    virtual int GetHashCode(Object^ obj)
    {
        // Compare the hash code for the lowercase versions of the strings.
        return obj->ToString()->ToLower()->GetHashCode();
    }
};

public ref class SamplesHashtable
{

public:
    static void Main()
    {
        // Create a hash table using the default comparer.
        Hashtable^ myHT1 = gcnew Hashtable(3, .8f);
        myHT1->Add("FIRST", "Hello");
        myHT1->Add("SECOND", "World");
        myHT1->Add("THIRD", "!");

        // Create a hash table using the specified IEqualityComparer that uses
        // the CaseInsensitiveComparer.DefaultInvariant to determine equality.
        Hashtable^ myHT2 = gcnew Hashtable(3, .8f, gcnew myCultureComparer());
        myHT2->Add("FIRST", "Hello");
        myHT2->Add("SECOND", "World");
        myHT2->Add("THIRD", "!");

        // Create a hash table using an IEqualityComparer that is based on
        // the Turkish culture (tr-TR) where "I" is not the uppercase
        // version of "i".
        CultureInfo^ myCul = gcnew CultureInfo("tr-TR");
        Hashtable^ myHT3 = gcnew Hashtable(3, .8f, gcnew myCultureComparer(myCul));
        myHT3->Add("FIRST", "Hello");
        myHT3->Add("SECOND", "World");
        myHT3->Add("THIRD", "!");

        // Search for a key in each hash table.
        Console::WriteLine("first is in myHT1: {0}", myHT1->ContainsKey("first"));
        Console::WriteLine("first is in myHT2: {0}", myHT2->ContainsKey("first"));
        Console::WriteLine("first is in myHT3: {0}", myHT3->ContainsKey("first"));

    }
};

int main()
{
    SamplesHashtable::Main();
}

/* 
This code produces the following output.  Results vary depending on the system's culture settings.

first is in myHT1: False
first is in myHT2: True
first is in myHT3: False

*/

using System;
using System.Collections;
using System.Globalization;

class myCultureComparer : IEqualityComparer
{
    public CaseInsensitiveComparer myComparer;

    public myCultureComparer()
    {
        myComparer = CaseInsensitiveComparer.DefaultInvariant;
    }

    public myCultureComparer(CultureInfo myCulture)
    {
        myComparer = new CaseInsensitiveComparer(myCulture);
    }

    public new bool Equals(object x, object y)
    {
        if (myComparer.Compare(x, y) == 0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    public int GetHashCode(object obj)
    {
        // Compare the hash code for the lowercase versions of the strings.
        return obj.ToString().ToLower().GetHashCode();
    }
}

public class SamplesHashtable
{

    public static void Main()
    {

        // Create a hash table using the default comparer.
        Hashtable myHT1 = new Hashtable(3, .8f);
        myHT1.Add("FIRST", "Hello");
        myHT1.Add("SECOND", "World");
        myHT1.Add("THIRD", "!");

        // Create a hash table using the specified IEqualityComparer that uses
        // the CaseInsensitiveComparer.DefaultInvariant to determine equality.
        Hashtable myHT2 = new Hashtable(3, .8f, new myCultureComparer());
        myHT2.Add("FIRST", "Hello");
        myHT2.Add("SECOND", "World");
        myHT2.Add("THIRD", "!");

        // Create a hash table using an IEqualityComparer that is based on
        // the Turkish culture (tr-TR) where "I" is not the uppercase
        // version of "i".
        CultureInfo myCul = new CultureInfo("tr-TR");
        Hashtable myHT3 = new Hashtable(3, .8f, new myCultureComparer(myCul));

        myHT3.Add("FIRST", "Hello");
        myHT3.Add("SECOND", "World");
        myHT3.Add("THIRD", "!");

        // Search for a key in each hash table.
        Console.WriteLine("first is in myHT1: {0}", myHT1.ContainsKey("first"));
        Console.WriteLine("first is in myHT2: {0}", myHT2.ContainsKey("first"));
        Console.WriteLine("first is in myHT3: {0}", myHT3.ContainsKey("first"));
    }
}


/*
This code produces the following output.
Results vary depending on the system's culture settings.

first is in myHT1: False
first is in myHT2: True
first is in myHT3: False

*/

Imports System.Collections
Imports System.Globalization

Public Class myCultureComparer
    Implements IEqualityComparer

    Dim myComparer As CaseInsensitiveComparer

    Public Sub New()
        myComparer = CaseInsensitiveComparer.DefaultInvariant
    End Sub

    Public Sub New(ByVal myCulture As CultureInfo)
        myComparer = New CaseInsensitiveComparer(myCulture)
    End Sub

    Public Function Equals1(ByVal x As Object, ByVal y As Object) _
        As Boolean Implements IEqualityComparer.Equals

        If (myComparer.Compare(x, y) = 0) Then
            Return True
        Else
            Return False
        End If
    End Function

    Public Function GetHashCode1(ByVal obj As Object) _
        As Integer Implements IEqualityComparer.GetHashCode
        Return obj.ToString().ToLower().GetHashCode()
    End Function
End Class

Public Class SamplesHashtable

    Public Shared Sub Main()

        ' Create a hash table using the default comparer.
        Dim myHT1 As New Hashtable(3, System.Convert.ToSingle(0.8))
        myHT1.Add("FIRST", "Hello")
        myHT1.Add("SECOND", "World")
        myHT1.Add("THIRD", "!")

        ' Create a hash table using the specified IEqualityComparer that uses
        ' the CaseInsensitiveComparer.DefaultInvariant to determine equality.
        Dim myHT2 As New Hashtable(3, System.Convert.ToSingle(0.8), _
            New myCultureComparer())

        myHT2.Add("FIRST", "Hello")
        myHT2.Add("SECOND", "World")
        myHT2.Add("THIRD", "!")

        ' Create a hash table using an IEqualityComparer that is based on
        ' the Turkish culture (tr-TR) where "I" is not the uppercase
        ' version of "i".
        Dim myCul As New CultureInfo("tr-TR")
        Dim myHT3 As New Hashtable(3, System.Convert.ToSingle(0.8), _
            New myCultureComparer(myCul))

        myHT3.Add("FIRST", "Hello")
        myHT3.Add("SECOND", "World")
        myHT3.Add("THIRD", "!")

        ' Search for a key in each hash table.
        Console.WriteLine("first is in myHT1: {0}", myHT1.ContainsKey("first"))
        Console.WriteLine("first is in myHT2: {0}", myHT2.ContainsKey("first"))
        Console.WriteLine("first is in myHT3: {0}", myHT3.ContainsKey("first"))

    End Sub

End Class


'This code produces the following output.
'Results vary depending on the system's culture settings.
'
'first is in myHT1: False
'first is in myHT2: True
'first is in myHT3: False

Açıklamalar

İlk kapasitenin belirtilmesi, nesneye öğe eklerken bir dizi yeniden boyutlandırma işlemi gerçekleştirme gereksinimini Hashtable ortadan kaldırır. Kapasite, yük faktörüne bağlı olarak gerektiğinde otomatik olarak artırılır.

Yük faktörü, öğelerin demetlere en yüksek oranıdır. Daha küçük bir yük faktörü, artan bellek tüketimi maliyetiyle daha hızlı arama anlamına gelir. 1,0 yük faktörü, hız ve boyut arasındaki en iyi dengedir.

Gerçek yük faktörü belirtilen yük faktörüne ulaştığında, demet 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 yükseltilir.

Karma kod sağlayıcısı içindeki anahtarlar Hashtableiçin karma kodları dağıtır. Varsayılan karma kod sağlayıcısı anahtarın uygulamasıdır Object.GetHashCode.

Karşılaştırıcı, iki anahtarın eşit olup olmadığını belirler. içindeki Hashtable her anahtar benzersiz olmalıdır. Varsayılan karşılaştırıcı anahtarın uygulamasıdır Object.Equals.

Bu oluşturucu, n parametresi olan bir O(n) işlemdircapacity.

Ayrıca bkz.

• GetHashCode()
• Equals(Object)

Hashtable(SerializationInfo, StreamingContext)

Kaynak:

Hashtable.cs

Dikkat

This API supports obsolete formatter-based serialization. It should not be called or extended by application code.

Belirtilen SerializationInfo ve nesnelerini kullanarak sınıfının seri hale getirilebilen yeni, StreamingContext boş bir örneğini Hashtable başlatır.

protected:
 Hashtable(System::Runtime::Serialization::SerializationInfo ^ info, System::Runtime::Serialization::StreamingContext context);

[System.Obsolete("This API supports obsolete formatter-based serialization. It should not be called or extended by application code.", DiagnosticId="SYSLIB0051", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
protected Hashtable (System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context);

[<System.Obsolete("This API supports obsolete formatter-based serialization. It should not be called or extended by application code.", DiagnosticId="SYSLIB0051", UrlFormat="https://aka.ms/dotnet-warnings/{0}")>]
new System.Collections.Hashtable : System.Runtime.Serialization.SerializationInfo * System.Runtime.Serialization.StreamingContext -> System.Collections.Hashtable

Protected Sub New (info As SerializationInfo, context As StreamingContext)

Parametreler

info

SerializationInfo

SerializationInfo Nesneyi serileştirmek Hashtable için gereken bilgileri içeren bir nesne.

context

StreamingContext

StreamingContext ile ilişkili serileştirilmiş akışın kaynağını ve hedefini Hashtableiçeren bir nesne.

Öznitelikler

ObsoleteAttribute

Özel durumlar

ArgumentNullException

info, null değeridir.

Açıklamalar

Karma tablosunun kapasitesi, yük faktörüne göre en uygun karma tablo demet sayısını hesaplamak için kullanılır. Kapasite gerektiğinde otomatik olarak artırılır.

Yük faktörü, öğelerin demetlere en yüksek oranıdır. Daha küçük bir yük faktörü, artan bellek tüketimi maliyetiyle daha hızlı arama anlamına gelir.

Gerçek yük faktörü belirtilen yük faktörüne ulaştığında, demet 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 yükseltilir.

Karma kod sağlayıcısı nesnedeki Hashtable anahtarlar için karma kodları dağıtır. Varsayılan karma kod sağlayıcısı anahtarın uygulamasıdır Object.GetHashCode.

Karşılaştırıcı, iki anahtarın eşit olup olmadığını belirler. içindeki Hashtable her anahtar benzersiz olmalıdır. Varsayılan karşılaştırıcı anahtarın uygulamasıdır Object.Equals.

Bu oluşturucu bir O(n) işlemdir ve burada n değeridir Count.

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.

Ayrıca bkz.

• ISerializable
• SerializationInfo
• StreamingContext
• OnDeserialization(Object)
• GetHashCode()
• Equals(Object)

Hashtable(IHashCodeProvider, IComparer)

Kaynak:

Hashtable.cs

Dikkat

This constructor has been deprecated. Use Hashtable(IEqualityComparer) instead.

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.

public:
 Hashtable(System::Collections::IHashCodeProvider ^ hcp, System::Collections::IComparer ^ comparer);

[System.Obsolete("This constructor has been deprecated. Use Hashtable(IEqualityComparer) instead.")]
public Hashtable (System.Collections.IHashCodeProvider? hcp, System.Collections.IComparer? comparer);

[<System.Obsolete("This constructor has been deprecated. Use Hashtable(IEqualityComparer) instead.")>]
new System.Collections.Hashtable : System.Collections.IHashCodeProvider * System.Collections.IComparer -> System.Collections.Hashtable

Public Sub New (hcp As IHashCodeProvider, comparer As IComparer)

Parametreler

hcp

IHashCodeProvider

Nesnedeki IHashCodeProvider tüm anahtarlar Hashtable için karma kodları sağlayan nesne.

-veya-

null her anahtarın uygulaması olan varsayılan karma kod sağlayıcısını kullanmak için GetHashCode().

comparer

IComparer

İki anahtarın IComparer eşit olup olmadığını belirlemek için kullanılacak nesne.

-veya-

null her anahtarın uygulaması olan varsayılan karşılaştırıcıyı kullanmak için Equals(Object).

Öznitelikler

ObsoleteAttribute

Örnekler

Aşağıdaki kod örneği, farklı Hashtable oluşturucular kullanarak karma tablolar oluşturur ve her biri aynı öğeleri içerse bile karma tabloların davranışındaki farkları gösterir.

using namespace System;
using namespace System::Collections;
using namespace System::Globalization;

ref class myComparer : IEqualityComparer
{
public:
    virtual bool Equals(Object^ x, Object^ y) 
    {
        return x->Equals(y);
    }

    virtual int GetHashCode(Object^ obj)
    {
        return obj->ToString()->ToLower()->GetHashCode();
    }
};

ref class myCultureComparer : IEqualityComparer
{
private:
    CaseInsensitiveComparer^ myComparer;

public:
    myCultureComparer()
    {
        myComparer = CaseInsensitiveComparer::DefaultInvariant;
    }

    myCultureComparer(CultureInfo^ myCulture)
    {
        myComparer = gcnew CaseInsensitiveComparer(myCulture);
    }

    virtual bool Equals(Object^ x, Object^ y) 
    {
        if (myComparer->Compare(x, y) == 0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    virtual int GetHashCode(Object^ obj)
    {
        return obj->ToString()->ToLower()->GetHashCode();
    }
};

int main()
{
   
   // Create a hash table using the default hash code provider and the default comparer.
   Hashtable^ myHT1 = gcnew Hashtable((IEqualityComparer^)nullptr);
   myHT1->Add( "FIRST", "Hello" );
   myHT1->Add( "SECOND", "World" );
   myHT1->Add( "THIRD", "!" );
   
   // Create a hash table using the specified IEqualityComparer that uses
   // the default Object.Equals to determine equality.
   Hashtable^ myHT2 = gcnew Hashtable(gcnew myComparer());
   myHT2->Add( "FIRST", "Hello" );
   myHT2->Add( "SECOND", "World" );
   myHT2->Add( "THIRD", "!" );
   
   // Create a hash table using a case-insensitive hash code provider and
   // case-insensitive comparer based on the InvariantCulture.
   Hashtable^ myHT3 = gcnew Hashtable(
            CaseInsensitiveHashCodeProvider::DefaultInvariant,
            CaseInsensitiveComparer::DefaultInvariant);
   myHT3->Add( "FIRST", "Hello" );
   myHT3->Add( "SECOND", "World" );
   myHT3->Add( "THIRD", "!" );
   
   // Create a hash table using an IEqualityComparer that is based on
   // the Turkish culture (tr-TR) where "I" is not the uppercase
   // version of "i".
   CultureInfo^ myCul = gcnew CultureInfo("tr-TR");
   Hashtable^ myHT4 = gcnew Hashtable( gcnew myCultureComparer(myCul) );
   myHT4->Add( "FIRST", "Hello" );
   myHT4->Add( "SECOND", "World" );
   myHT4->Add( "THIRD", "!" );
   
   // Search for a key in each hash table.
   Console::WriteLine( "first is in myHT1: {0}", myHT1->ContainsKey( "first" ) );
   Console::WriteLine( "first is in myHT2: {0}", myHT2->ContainsKey( "first" ) );
   Console::WriteLine( "first is in myHT3: {0}", myHT3->ContainsKey( "first" ) );
   Console::WriteLine( "first is in myHT4: {0}", myHT4->ContainsKey( "first" ) );
}

/* 
This code produces the following output.  Results vary depending on the system's culture settings.

first is in myHT1: False
first is in myHT2: False
first is in myHT3: True
first is in myHT4: False

*/

using System;
using System.Collections;
using System.Globalization;

class myComparer : IEqualityComparer
{
    public new bool Equals(object x, object y)
    {
        return x.Equals(y);
    }

    public int GetHashCode(object obj)
    {
        return obj.ToString().ToLower().GetHashCode();
    }
}

class myCultureComparer : IEqualityComparer
{
    public CaseInsensitiveComparer myComparer;

    public myCultureComparer()
    {
        myComparer = CaseInsensitiveComparer.DefaultInvariant;
    }

    public myCultureComparer(CultureInfo myCulture)
    {
        myComparer = new CaseInsensitiveComparer(myCulture);
    }

    public new bool Equals(object x, object y)
    {
        return myComparer.Compare(x, y) == 0;
    }

    public int GetHashCode(object obj)
    {
        return obj.ToString().ToLower().GetHashCode();
    }
}

public class SamplesHashtable
{

    public static void Main()
    {

        // Create a hash table using the default comparer.
        var myHT1 = new Hashtable();
        myHT1.Add("FIRST", "Hello");
        myHT1.Add("SECOND", "World");
        myHT1.Add("THIRD", "!");

        // Create a hash table using the specified IEqualityComparer that uses
        // the default Object.Equals to determine equality.
        var myHT2 = new Hashtable(new myComparer());
        myHT2.Add("FIRST", "Hello");
        myHT2.Add("SECOND", "World");
        myHT2.Add("THIRD", "!");

        // Create a hash table using a case-insensitive hash code provider and
        // case-insensitive comparer based on the InvariantCulture.
        Hashtable myHT3 = new Hashtable(
            CaseInsensitiveHashCodeProvider.DefaultInvariant,
            CaseInsensitiveComparer.DefaultInvariant);
        myHT3.Add("FIRST", "Hello");
        myHT3.Add("SECOND", "World");
        myHT3.Add("THIRD", "!");

        // Create a hash table using an IEqualityComparer that is based on
        // the Turkish culture (tr-TR) where "I" is not the uppercase
        // version of "i".
        var myCul = new CultureInfo("tr-TR");
        var myHT4 = new Hashtable(new myCultureComparer(myCul));
        myHT4.Add("FIRST", "Hello");
        myHT4.Add("SECOND", "World");
        myHT4.Add("THIRD", "!");

        // Search for a key in each hash table.
        Console.WriteLine($"first is in myHT1: {myHT1.ContainsKey("first")}");
        Console.WriteLine($"first is in myHT2: {myHT2.ContainsKey("first")}");
        Console.WriteLine($"first is in myHT3: {myHT3.ContainsKey("first")}");
        Console.WriteLine($"first is in myHT4: {myHT4.ContainsKey("first")}");
    }
}


/*
This code produces the following output.
Results vary depending on the system's culture settings.

first is in myHT1: False
first is in myHT2: False
first is in myHT3: True
first is in myHT4: False

*/

Imports System.Collections
Imports System.Globalization

Public Class myComparer
    Implements IEqualityComparer
    Public Function Equals1(ByVal x As Object, ByVal y As Object) _
        As Boolean Implements IEqualityComparer.Equals

        Return x.Equals(y)
    End Function

    Public Function GetHashCode1(ByVal obj As Object) _
        As Integer Implements IEqualityComparer.GetHashCode

        Return obj.ToString().ToLower().GetHashCode()
    End Function

End Class

Public Class myCultureComparer
    Implements IEqualityComparer

    Dim myComparer As CaseInsensitiveComparer

    Public Sub New()
        myComparer = CaseInsensitiveComparer.DefaultInvariant
    End Sub

    Public Sub New(ByVal myCulture As CultureInfo)
        myComparer = New CaseInsensitiveComparer(myCulture)
    End Sub

    Public Function Equals1(ByVal x As Object, ByVal y As Object) _
        As Boolean Implements IEqualityComparer.Equals

        Return myComparer.Compare(x, y) = 0
    End Function

    Public Function GetHashCode1(ByVal obj As Object) _
        As Integer Implements IEqualityComparer.GetHashCode
        Return obj.ToString().ToLower().GetHashCode()
    End Function
End Class

Public Class SamplesHashtable

    Public Shared Sub Main()

        ' Create a hash table using the default comparer.
        Dim myHT1 As New Hashtable()
        myHT1.Add("FIRST", "Hello")
        myHT1.Add("SECOND", "World")
        myHT1.Add("THIRD", "!")

        ' Create a hash table using the specified IEqualityComparer that uses
        ' the default Object.Equals to determine equality.
        Dim myHT2 As New Hashtable(New myComparer())
        myHT2.Add("FIRST", "Hello")
        myHT2.Add("SECOND", "World")
        myHT2.Add("THIRD", "!")

        ' Create a hash table using a case-insensitive hash code provider and
        ' case-insensitive comparer based on the InvariantCulture.
        Dim myHT3 As New Hashtable( _
            CaseInsensitiveHashCodeProvider.DefaultInvariant, _
            CaseInsensitiveComparer.DefaultInvariant)
        myHT3.Add("FIRST", "Hello")
        myHT3.Add("SECOND", "World")
        myHT3.Add("THIRD", "!")

        ' Create a hash table using an IEqualityComparer that is based on
        ' the Turkish culture (tr-TR) where "I" is not the uppercase
        ' version of "i".
        Dim myCul As New CultureInfo("tr-TR")
        Dim myHT4 As New Hashtable(New myCultureComparer(myCul))
        myHT4.Add("FIRST", "Hello")
        myHT4.Add("SECOND", "World")
        myHT4.Add("THIRD", "!")

        ' Search for a key in each hash table.
        Console.WriteLine($"first is in myHT1: {myHT1.ContainsKey("first")}")
        Console.WriteLine($"first is in myHT2: {myHT2.ContainsKey("first")}")
        Console.WriteLine($"first is in myHT3: {myHT3.ContainsKey("first")}")
        Console.WriteLine($"first is in myHT4: {myHT4.ContainsKey("first")}")

    End Sub

End Class

'This code produces the following output.
'Results vary depending on the system's culture settings.

'first is in myHT1: False
'first is in myHT2: False
'first is in myHT3: True
'first is in myHT4: False

Açıklamalar

Karma tablosunun kapasitesi, yük faktörüne göre en uygun karma tablo demet sayısını hesaplamak için kullanılır. Kapasite gerektiğinde otomatik olarak artırılır.

Yük faktörü, öğelerin demetlere en yüksek oranıdır. Daha küçük bir yük faktörü, artan bellek tüketimi maliyetiyle daha hızlı arama anlamına gelir.

Gerçek yük faktörü belirtilen yük faktörüne ulaştığında, demet 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 yükseltilir.

Karma kod sağlayıcısı nesnedeki Hashtable anahtarlar için karma kodları dağıtır. Varsayılan karma kod sağlayıcısı anahtarın uygulamasıdır Object.GetHashCode.

Karşılaştırıcı, iki anahtarın eşit olup olmadığını belirler. içindeki Hashtable her anahtar benzersiz olmalıdır. Varsayılan karşılaştırıcı anahtarın uygulamasıdır Object.Equals.

Özel karma kod sağlayıcısı ve özel karşılaştırıcı, büyük/küçük harfe duyarlı olmayan dizelerle arama yapma gibi senaryoları etkinleştirir.

Bu oluşturucu bir O(1) işlemdir.

Ayrıca bkz.

• IHashCodeProvider
• IComparer
• GetHashCode()
• Equals(Object)

Hashtable(IDictionary, Single)

Kaynak:

Hashtable.cs

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.

public:
 Hashtable(System::Collections::IDictionary ^ d, float loadFactor);

public Hashtable (System.Collections.IDictionary d, float loadFactor);

new System.Collections.Hashtable : System.Collections.IDictionary * single -> System.Collections.Hashtable

Public Sub New (d As IDictionary, loadFactor As Single)

Parametreler

d

IDictionary

IDictionary Yeni Hashtable bir nesneye kopyalanacak nesne.

loadFactor

Single

0,1 ile 1,0 aralığındaki bir sayı, en iyi performansı sağlayan varsayılan değerle çarpılır. Sonuç, öğelerin demetlere en yüksek oranıdır.

Özel durumlar

ArgumentNullException

d, null değeridir.

ArgumentOutOfRangeException

loadFactor 0,1'den küçüktür.

-veya-

loadFactor 1,0'dan büyük.

Örnekler

Aşağıdaki kod örneği, farklı Hashtable oluşturucular kullanarak karma tablolar oluşturur ve her biri aynı öğeleri içerse bile karma tabloların davranışındaki farkları gösterir.

using namespace System;
using namespace System::Collections;
using namespace System::Globalization;

ref class myCultureComparer : public IEqualityComparer
{
public:
    CaseInsensitiveComparer^ myComparer;

public:
    myCultureComparer()
    {
        myComparer = CaseInsensitiveComparer::DefaultInvariant;
    }

public:
    myCultureComparer(CultureInfo^ myCulture)
    {
        myComparer = gcnew CaseInsensitiveComparer(myCulture);
    }

public:
    virtual bool Equals(Object^ x, Object^ y)
    {
        if (myComparer->Compare(x, y) == 0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

public:
    virtual int GetHashCode(Object^ obj)
    {
        // Compare the hash code for the lowercase versions of the strings.
        return obj->ToString()->ToLower()->GetHashCode();
    }
};

public ref class SamplesHashtable
{

public:
    static void Main()
    {
       
       // Create the dictionary.
       SortedList^ mySL = gcnew SortedList;
       mySL->Add( "FIRST", "Hello" );
       mySL->Add( "SECOND", "World" );
       mySL->Add( "THIRD", "!" );
       
       // Create a hash table using the default hash code provider and the default comparer.
       Hashtable^ myHT1 = gcnew Hashtable( mySL, .8f );
       
       // Create a hash table using the specified case-insensitive hash code provider and case-insensitive comparer.
       Hashtable^ myHT2 = gcnew Hashtable( mySL, .8f, gcnew myCultureComparer() );
       
       // Create a hash table using the specified KeyComparer.
       // The KeyComparer uses a case-insensitive hash code provider and a case-insensitive comparer,
       // which are based on the Turkish culture (tr-TR), where "I" is not the uppercase version of "i".
       CultureInfo^ myCul = gcnew CultureInfo( "tr-TR" );
       Hashtable^ myHT3 = gcnew Hashtable( mySL, .8f, gcnew myCultureComparer( myCul ) );
       
       // Search for a key in each hash table.
       Console::WriteLine( "first is in myHT1: {0}", myHT1->ContainsKey( "first" ) );
       Console::WriteLine( "first is in myHT2: {0}", myHT2->ContainsKey( "first" ) );
       Console::WriteLine( "first is in myHT3: {0}", myHT3->ContainsKey( "first" ) );
    }
};

int main()
{
    SamplesHashtable::Main();
}

/* 
This code produces the following output.  Results vary depending on the system's culture settings.

first is in myHT1: False
first is in myHT2: True
first is in myHT3: False

*/

using System;
using System.Collections;
using System.Globalization;

class myCultureComparer : IEqualityComparer
{
    public CaseInsensitiveComparer myComparer;

    public myCultureComparer()
    {
        myComparer = CaseInsensitiveComparer.DefaultInvariant;
    }

    public myCultureComparer(CultureInfo myCulture)
    {
        myComparer = new CaseInsensitiveComparer(myCulture);
    }

    public new bool Equals(object x, object y)
    {
        if (myComparer.Compare(x, y) == 0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    public int GetHashCode(object obj)
    {
        // Compare the hash code for the lowercase versions of the strings.
        return obj.ToString().ToLower().GetHashCode();
    }
}

public class SamplesHashtable
{

    public static void Main()
    {

        // Create the dictionary.
        SortedList mySL = new SortedList();
        mySL.Add("FIRST", "Hello");
        mySL.Add("SECOND", "World");
        mySL.Add("THIRD", "!");

        // Create a hash table using the default comparer.
        Hashtable myHT1 = new Hashtable(mySL, .8f);

        // Create a hash table using the specified IEqualityComparer that uses
        // the CaseInsensitiveComparer.DefaultInvariant to determine equality.
        Hashtable myHT2 = new Hashtable(mySL, .8f,
            new myCultureComparer());

        // Create a hash table using an IEqualityComparer that is based on
        // the Turkish culture (tr-TR) where "I" is not the uppercase
        // version of "i".
        CultureInfo myCul = new CultureInfo("tr-TR");
        Hashtable myHT3 = new Hashtable(mySL, .8f, new myCultureComparer(myCul));

        // Search for a key in each hash table.
        Console.WriteLine("first is in myHT1: {0}", myHT1.ContainsKey("first"));
        Console.WriteLine("first is in myHT2: {0}", myHT2.ContainsKey("first"));
        Console.WriteLine("first is in myHT3: {0}", myHT3.ContainsKey("first"));
    }
}


/*
This code produces the following output.
Results vary depending on the system's culture settings.

first is in myHT1: False
first is in myHT2: True
first is in myHT3: False

*/

Imports System.Collections
Imports System.Globalization

Public Class myCultureComparer
    Implements IEqualityComparer

    Dim myComparer As CaseInsensitiveComparer

    Public Sub New()
        myComparer = CaseInsensitiveComparer.DefaultInvariant
    End Sub

    Public Sub New(ByVal myCulture As CultureInfo)
        myComparer = New CaseInsensitiveComparer(myCulture)
    End Sub

    Public Function Equals1(ByVal x As Object, ByVal y As Object) _
        As Boolean Implements IEqualityComparer.Equals

        If (myComparer.Compare(x, y) = 0) Then
            Return True
        Else
            Return False
        End If
    End Function

    Public Function GetHashCode1(ByVal obj As Object) _
        As Integer Implements IEqualityComparer.GetHashCode
        Return obj.ToString().ToLower().GetHashCode()
    End Function
End Class

Public Class SamplesHashtable   

   Public Shared Sub Main()

      ' Create the dictionary.
      Dim mySL As New SortedList()
      mySL.Add("FIRST", "Hello")
      mySL.Add("SECOND", "World")
      mySL.Add("THIRD", "!")

      ' Create a hash table using the default comparer.
      Dim myHT1 As New Hashtable(mySL, System.Convert.ToSingle(0.8))

      ' Create a hash table using the specified IEqualityComparer that uses
      ' the CaseInsensitiveComparer.DefaultInvariant to determine equality.
      Dim myHT2 As New Hashtable(mySL, System.Convert.ToSingle(0.8), _
        New myCultureComparer())

      ' Create a hash table using an IEqualityComparer that is based on
      ' the Turkish culture (tr-TR) where "I" is not the uppercase
      ' version of "i".
      Dim myCul As New CultureInfo("tr-TR")
      Dim myHT3 As New Hashtable(mySL, System.Convert.ToSingle(0.8), _
        New myCultureComparer(myCul))

      ' Search for a key in each hash table.
      Console.WriteLine("first is in myHT1: {0}", myHT1.ContainsKey("first"))
      Console.WriteLine("first is in myHT2: {0}", myHT2.ContainsKey("first"))
      Console.WriteLine("first is in myHT3: {0}", myHT3.ContainsKey("first"))

   End Sub

End Class


'This code produces the following output.
'Results vary depending on the system's culture settings.
'
'first is in myHT1: False
'first is in myHT2: True
'first is in myHT3: False

Açıklamalar

İlk kapasite, kaynak sözlükteki öğe sayısına ayarlanır. Kapasite, yük faktörüne bağlı olarak gerektiğinde otomatik olarak artırılır.

Yük faktörü, öğelerin demetlere en yüksek oranıdır. Daha küçük bir yük faktörü, artan bellek tüketimi maliyetiyle daha hızlı arama anlamına gelir. 1,0 yük faktörü, hız ve boyut arasındaki en iyi dengedir.

Gerçek yük faktörü belirtilen yük faktörüne ulaştığında, demet 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 yükseltilir.

Karma kod sağlayıcısı nesnedeki Hashtable anahtarlar için karma kodları dağıtır. Varsayılan karma kod sağlayıcısı anahtarın uygulamasıdır Object.GetHashCode.

Karşılaştırıcı, iki anahtarın eşit olup olmadığını belirler. içindeki Hashtable her anahtar benzersiz olmalıdır. Varsayılan karşılaştırıcı anahtarın uygulamasıdır Object.Equals.

Yeni Hashtable öğesinin öğeleri, numaralandırıcının nesnede IDictionary yinelendiği aynı düzende sıralanır.

Bu oluşturucu, n parametresindeki d öğelerin sayısı olan bir O(n) işlemdir.

Ayrıca bkz.

• IDictionary
• GetHashCode()
• Equals(Object)

Hashtable(IDictionary, IEqualityComparer)

Kaynak:

Hashtable.cs

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.

public:
 Hashtable(System::Collections::IDictionary ^ d, System::Collections::IEqualityComparer ^ equalityComparer);

public Hashtable (System.Collections.IDictionary d, System.Collections.IEqualityComparer? equalityComparer);

new System.Collections.Hashtable : System.Collections.IDictionary * System.Collections.IEqualityComparer -> System.Collections.Hashtable

Public Sub New (d As IDictionary, equalityComparer As IEqualityComparer)

Parametreler

d

IDictionary

IDictionary Yeni Hashtable bir nesneye kopyalanacak nesne.

equalityComparer

IEqualityComparer

IEqualityComparer Karma kod sağlayıcısını ve ile Hashtablekullanılacak karşılaştırıcıyı tanımlayan nesne.

-veya-

null varsayılan karma kod sağlayıcısını ve varsayılan karşılaştırıcıyı kullanmak için. Varsayılan karma kod sağlayıcısı her anahtarın GetHashCode() uygulamasıdır ve varsayılan karşılaştırıcı her anahtarın Equals(Object)uygulamasıdır.

Özel durumlar

ArgumentNullException

d, null değeridir.

Örnekler

Aşağıdaki kod örneği, farklı Hashtable oluşturucular kullanarak karma tablolar oluşturur ve her biri aynı öğeleri içerse bile karma tabloların davranışındaki farkları gösterir.

using namespace System;
using namespace System::Collections;
using namespace System::Globalization;

ref class myCultureComparer : public IEqualityComparer
{
public:
    CaseInsensitiveComparer^ myComparer;

public:
    myCultureComparer()
    {
        myComparer = CaseInsensitiveComparer::DefaultInvariant;
    }

public:
    myCultureComparer(CultureInfo^ myCulture)
    {
        myComparer = gcnew CaseInsensitiveComparer(myCulture);
    }

public:
    virtual bool Equals(Object^ x, Object^ y)
    {
        if (myComparer->Compare(x, y) == 0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

public:
    virtual int GetHashCode(Object^ obj)
    {
        // Compare the hash code for the lowercase versions of the strings.
        return obj->ToString()->ToLower()->GetHashCode();
    }
};

public ref class SamplesHashtable
{

public:
    static void Main()
    {
        // Create the dictionary.
        SortedList^ mySL = gcnew SortedList();
        mySL->Add("FIRST", "Hello");
        mySL->Add("SECOND", "World");
        mySL->Add("THIRD", "!");

        // Create a hash table using the default comparer.
        Hashtable^ myHT1 = gcnew Hashtable(mySL);

        // Create a hash table using the specified IEqualityComparer that uses
        // the CaseInsensitiveComparer.DefaultInvariant to determine equality.
        Hashtable^ myHT2 = gcnew Hashtable(mySL, gcnew myCultureComparer());

        // Create a hash table using an IEqualityComparer that is based on
        // the Turkish culture (tr-TR) where "I" is not the uppercase
        // version of "i".
        CultureInfo^ myCul = gcnew CultureInfo("tr-TR");
        Hashtable^ myHT3 = gcnew Hashtable(mySL, gcnew myCultureComparer(myCul));

        // Search for a key in each hash table.
        Console::WriteLine("first is in myHT1: {0}", myHT1->ContainsKey("first"));
        Console::WriteLine("first is in myHT2: {0}", myHT2->ContainsKey("first"));
        Console::WriteLine("first is in myHT3: {0}", myHT3->ContainsKey("first"));
    }
};

int main()
{
    SamplesHashtable::Main();
};

/* 
This code produces the following output. 
Results vary depending on the system's culture settings.

first is in myHT1: False
first is in myHT2: True
first is in myHT3: False

*/

using System;
using System.Collections;
using System.Globalization;

class myCultureComparer : IEqualityComparer
{
    public CaseInsensitiveComparer myComparer;

    public myCultureComparer()
    {
        myComparer = CaseInsensitiveComparer.DefaultInvariant;
    }

    public myCultureComparer(CultureInfo myCulture)
    {
        myComparer = new CaseInsensitiveComparer(myCulture);
    }

    public new bool Equals(object x, object y)
    {
        return myComparer.Compare(x, y) == 0;
    }

    public int GetHashCode(object obj)
    {
        // Compare the hash code for the lowercase versions of the strings.
        return obj.ToString().ToLower().GetHashCode();
    }
}

public class SamplesHashtable
{

    public static void Main()
    {

        // Create the dictionary.
        var mySL = new SortedList();
        mySL.Add("FIRST", "Hello");
        mySL.Add("SECOND", "World");
        mySL.Add("THIRD", "!");

        // Create a hash table using the default comparer.
        var myHT1 = new Hashtable(mySL);

        // Create a hash table using the specified IEqualityComparer that uses
        // the CaseInsensitiveComparer.DefaultInvariant to determine equality.
        var myHT2 = new Hashtable(mySL, new myCultureComparer());

        // Create a hash table using an IEqualityComparer that is based on
        // the Turkish culture (tr-TR) where "I" is not the uppercase
        // version of "i".
        var myCul = new CultureInfo("tr-TR");
        var myHT3 = new Hashtable(mySL, new myCultureComparer(myCul));

        // Search for a key in each hash table.
        Console.WriteLine($"first is in myHT1: {myHT1.ContainsKey("first")}");
        Console.WriteLine($"first is in myHT2: {myHT2.ContainsKey("first")}");
        Console.WriteLine($"first is in myHT3: {myHT3.ContainsKey("first")}");
    }
}


/*
This code produces the following output.
Results vary depending on the system's culture settings.

first is in myHT1: False
first is in myHT2: True
first is in myHT3: False

*/

Imports System.Collections
Imports System.Globalization

Public Class myCultureComparer
    Implements IEqualityComparer

    Dim myComparer As CaseInsensitiveComparer

    Public Sub New()
        myComparer = CaseInsensitiveComparer.DefaultInvariant
    End Sub

    Public Sub New(ByVal myCulture As CultureInfo)
        myComparer = New CaseInsensitiveComparer(myCulture)
    End Sub

    Public Function Equals1(ByVal x As Object, ByVal y As Object) _
        As Boolean Implements IEqualityComparer.Equals

        Return myComparer.Compare(x, y) = 0
    End Function

    Public Function GetHashCode1(ByVal obj As Object) _
        As Integer Implements IEqualityComparer.GetHashCode
        Return obj.ToString().ToLower().GetHashCode()
    End Function
End Class

Public Class SamplesHashtable   

   Public Shared Sub Main()

      ' Create the dictionary.
      Dim mySL As New SortedList()
      mySL.Add("FIRST", "Hello")
      mySL.Add("SECOND", "World")
      mySL.Add("THIRD", "!")

      ' Create a hash table using the default comparer.
      Dim myHT1 As New Hashtable(mySL)

      ' Create a hash table using the specified IEqualityComparer that uses
      ' the CaseInsensitiveComparer.DefaultInvariant to determine equality.
      Dim myHT2 As New Hashtable(mySL, New myCultureComparer())

      ' Create a hash table using an IEqualityComparer that is based on
      ' the Turkish culture (tr-TR) where "I" is not the uppercase
      ' version of "i".
      Dim myCul As New CultureInfo("tr-TR")
      Dim myHT3 As New Hashtable(mySL, New myCultureComparer(myCul))

      ' Search for a key in each hash table.
      Console.WriteLine($"first is in myHT1: {myHT1.ContainsKey("first")}")
      Console.WriteLine($"first is in myHT2: {myHT2.ContainsKey("first")}")
      Console.WriteLine($"first is in myHT3: {myHT3.ContainsKey("first")}")

   End Sub

End Class


'This code produces the following output.
'Results vary depending on the system's culture settings.
'
'first is in myHT1: False
'first is in myHT2: True
'first is in myHT3: False

Açıklamalar

İlk kapasite, kaynak sözlükteki öğe sayısına ayarlanır. Kapasite, yük faktörüne bağlı olarak gerektiğinde otomatik olarak artırılır.

Yük faktörü, öğelerin demetlere en yüksek oranıdır. Daha küçük bir yük faktörü, artan bellek tüketimi maliyetiyle daha hızlı arama anlamına gelir.

Gerçek yük faktörü belirtilen yük faktörüne ulaştığında, demet 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 yükseltilir.

IEqualityComparer nesnesi hem karma kod sağlayıcısını hem de karşılaştırıcıyı içerir. oluşturucuda bir IEqualityComparer kullanılırsa, nesnede Hashtable anahtar olarak kullanılan nesnelerin ve Object.Equals yöntemlerini geçersiz kılmak Object.GetHashCode için gerekli Hashtable değildir.

Karma kod sağlayıcısı içindeki anahtarlar Hashtableiçin karma kodları dağıtır. Varsayılan karma kod sağlayıcısı anahtarın uygulamasıdır Object.GetHashCode.

Karşılaştırıcı, iki anahtarın eşit olup olmadığını belirler. içindeki Hashtable her anahtar benzersiz olmalıdır. Varsayılan karşılaştırıcı anahtarın uygulamasıdır Object.Equals.

, IEqualityComparer büyük/küçük harfe duyarlı olmayan dizelerle arama yapma gibi senaryoları etkinleştirir.

Yeni Hashtable öğesinin öğeleri, numaralandırıcının nesnede IDictionary yinelendiği aynı düzende sıralanır.

Bu oluşturucu, n parametresindeki d öğelerin sayısı olan bir O(n) işlemdir.

Ayrıca bkz.

• IDictionary
• IEqualityComparer

Hashtable(Int32)

Kaynak:

Hashtable.cs

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.

public:
 Hashtable(int capacity);

public Hashtable (int capacity);

new System.Collections.Hashtable : int -> System.Collections.Hashtable

Public Sub New (capacity As Integer)

Parametreler

capacity

Int32

Nesnenin Hashtable başlangıçta içerebileceği yaklaşık öğe sayısı.

Özel durumlar

ArgumentOutOfRangeException

capacity, sıfırdan küçüktür.

Örnekler

Aşağıdaki kod örneği, farklı Hashtable oluşturucular kullanarak karma tablolar oluşturur ve her biri aynı öğeleri içerse bile karma tabloların davranışındaki farkları gösterir.

using namespace System;
using namespace System::Collections;
using namespace System::Globalization;

ref class myCultureComparer : public IEqualityComparer
{
public:
    CaseInsensitiveComparer^ myComparer;

public:
    myCultureComparer()
    {
        myComparer = CaseInsensitiveComparer::DefaultInvariant;
    }

public:
    myCultureComparer(CultureInfo^ myCulture)
    {
        myComparer = gcnew CaseInsensitiveComparer(myCulture);
    }

public:
    virtual bool Equals(Object^ x, Object^ y)
    {
        if (myComparer->Compare(x, y) == 0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

public:
    virtual int GetHashCode(Object^ obj)
    {
        // Compare the hash code for the lowercase versions of the strings.
        return obj->ToString()->ToLower()->GetHashCode();
    }
};

public ref class SamplesHashtable
{

public:
    static void Main()
    {
        // Create a hash table using the default comparer.
        Hashtable^ myHT1 = gcnew Hashtable(3);
        myHT1->Add("FIRST", "Hello");
        myHT1->Add("SECOND", "World");
        myHT1->Add("THIRD", "!");

        // Create a hash table using the specified IEqualityComparer that uses
        // the CaseInsensitiveComparer.DefaultInvariant to determine equality.
        Hashtable^ myHT2 = gcnew Hashtable(3, gcnew myCultureComparer());
        myHT2->Add("FIRST", "Hello");
        myHT2->Add("SECOND", "World");
        myHT2->Add("THIRD", "!");

        // Create a hash table using an IEqualityComparer that is based on
        // the Turkish culture (tr-TR) where "I" is not the uppercase
        // version of "i".
        CultureInfo^ myCul = gcnew CultureInfo("tr-TR");
        Hashtable^ myHT3 = gcnew Hashtable(3, gcnew myCultureComparer(myCul));
        myHT3->Add("FIRST", "Hello");
        myHT3->Add("SECOND", "World");
        myHT3->Add("THIRD", "!");

        // Search for a key in each hash table.
        Console::WriteLine("first is in myHT1: {0}", myHT1->ContainsKey("first"));
        Console::WriteLine("first is in myHT2: {0}", myHT2->ContainsKey("first"));
        Console::WriteLine("first is in myHT3: {0}", myHT3->ContainsKey("first"));

    }
};

int main()
{
    SamplesHashtable::Main();
}

/* 
This code produces the following output.  Results vary depending on the system's culture settings.

first is in myHT1: False
first is in myHT2: True
first is in myHT3: False

*/

using System;
using System.Collections;
using System.Globalization;

class myCultureComparer : IEqualityComparer
{
    public CaseInsensitiveComparer myComparer;

    public myCultureComparer()
    {
        myComparer = CaseInsensitiveComparer.DefaultInvariant;
    }

    public myCultureComparer(CultureInfo myCulture)
    {
        myComparer = new CaseInsensitiveComparer(myCulture);
    }

    public new bool Equals(object x, object y)
    {
        if (myComparer.Compare(x, y) == 0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    public int GetHashCode(object obj)
    {
        // Compare the hash code for the lowercase versions of the strings.
        return obj.ToString().ToLower().GetHashCode();
    }
}

public class SamplesHashtable
{

    public static void Main()
    {

        // Create a hash table using the default comparer.
        Hashtable myHT1 = new Hashtable(3);
        myHT1.Add("FIRST", "Hello");
        myHT1.Add("SECOND", "World");
        myHT1.Add("THIRD", "!");

        // Create a hash table using the specified IEqualityComparer that uses
        // the CaseInsensitiveComparer.DefaultInvariant to determine equality.
        Hashtable myHT2 = new Hashtable(3, new myCultureComparer());
        myHT2.Add("FIRST", "Hello");
        myHT2.Add("SECOND", "World");
        myHT2.Add("THIRD", "!");

        // Create a hash table using an IEqualityComparer that is based on
        // the Turkish culture (tr-TR) where "I" is not the uppercase
        // version of "i".
        CultureInfo myCul = new CultureInfo("tr-TR");
        Hashtable myHT3 = new Hashtable(3, new myCultureComparer(myCul));
        myHT3.Add("FIRST", "Hello");
        myHT3.Add("SECOND", "World");
        myHT3.Add("THIRD", "!");

        // Search for a key in each hash table.
        Console.WriteLine("first is in myHT1: {0}", myHT1.ContainsKey("first"));
        Console.WriteLine("first is in myHT2: {0}", myHT2.ContainsKey("first"));
        Console.WriteLine("first is in myHT3: {0}", myHT3.ContainsKey("first"));
    }
}


/*
This code produces the following output.
Results vary depending on the system's culture settings.

first is in myHT1: False
first is in myHT2: True
first is in myHT3: False

*/

Imports System.Collections
Imports System.Globalization

Public Class myCultureComparer
    Implements IEqualityComparer

    Dim myComparer As CaseInsensitiveComparer

    Public Sub New()
        myComparer = CaseInsensitiveComparer.DefaultInvariant
    End Sub

    Public Sub New(ByVal myCulture As CultureInfo)
        myComparer = New CaseInsensitiveComparer(myCulture)
    End Sub

    Public Function Equals1(ByVal x As Object, ByVal y As Object) _
        As Boolean Implements IEqualityComparer.Equals

        If (myComparer.Compare(x, y) = 0) Then
            Return True
        Else
            Return False
        End If
    End Function

    Public Function GetHashCode1(ByVal obj As Object) _
        As Integer Implements IEqualityComparer.GetHashCode
        Return obj.ToString().ToLower().GetHashCode()
    End Function
End Class

Public Class SamplesHashtable   

   Public Shared Sub Main()

      ' Create a hash table using the default comparer.
      Dim myHT1 As New Hashtable(3)
      myHT1.Add("FIRST", "Hello")
      myHT1.Add("SECOND", "World")
      myHT1.Add("THIRD", "!")

      ' Create a hash table using the specified IEqualityComparer that uses
      ' the CaseInsensitiveComparer.DefaultInvariant to determine equality.
      Dim myHT2 As New Hashtable(3, New myCultureComparer())
      myHT2.Add("FIRST", "Hello")
      myHT2.Add("SECOND", "World")
      myHT2.Add("THIRD", "!")

      ' Create a hash table using an IEqualityComparer that is based on
      ' the Turkish culture (tr-TR) where "I" is not the uppercase
      ' version of "i".
      Dim myCul As New CultureInfo("tr-TR")
      Dim myHT3 As New Hashtable(3, New myCultureComparer(myCul))
      myHT3.Add("FIRST", "Hello")
      myHT3.Add("SECOND", "World")
      myHT3.Add("THIRD", "!")

      ' Search for a key in each hash table.
      Console.WriteLine("first is in myHT1: {0}", myHT1.ContainsKey("first"))
      Console.WriteLine("first is in myHT2: {0}", myHT2.ContainsKey("first"))
      Console.WriteLine("first is in myHT3: {0}", myHT3.ContainsKey("first"))

   End Sub

End Class


'This code produces the following output.
'Results vary depending on the system's culture settings.
'
'first is in myHT1: False
'first is in myHT2: True
'first is in myHT3: False

Açıklamalar

İlk kapasitenin belirtilmesi, nesneye öğe eklerken bir dizi yeniden boyutlandırma işlemi gerçekleştirme gereksinimini Hashtable ortadan kaldırır. Kapasite, yük faktörüne bağlı olarak gerektiğinde otomatik olarak artırılır.

Yük faktörü, öğelerin demetlere en yüksek oranıdır. Daha küçük bir yük faktörü, artan bellek tüketimi maliyetiyle daha hızlı arama anlamına gelir.

Gerçek yük faktörü belirtilen yük faktörüne ulaştığında, demet 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 yükseltilir.

Karma kod sağlayıcısı içindeki anahtarlar Hashtableiçin karma kodları dağıtır. Varsayılan karma kod sağlayıcısı anahtarın uygulamasıdır Object.GetHashCode.

Karşılaştırıcı, iki anahtarın eşit olup olmadığını belirler. içindeki Hashtable her anahtar benzersiz olmalıdır. Varsayılan karşılaştırıcı anahtarın uygulamasıdır Object.Equals.

Bu oluşturucu bir O(n) işlemdir ve burada n değeridir capacity.

Ayrıca bkz.

• GetHashCode()
• Equals(Object)

Hashtable(IEqualityComparer)

Kaynak:

Hashtable.cs

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.

public:
 Hashtable(System::Collections::IEqualityComparer ^ equalityComparer);

public Hashtable (System.Collections.IEqualityComparer? equalityComparer);

new System.Collections.Hashtable : System.Collections.IEqualityComparer -> System.Collections.Hashtable

Public Sub New (equalityComparer As IEqualityComparer)

Parametreler

equalityComparer

IEqualityComparer

IEqualityComparer Karma kod sağlayıcısını ve nesnesiyle kullanılacak karşılaştırıcıyı Hashtable tanımlayan nesne.

-veya-

null varsayılan karma kod sağlayıcısını ve varsayılan karşılaştırıcıyı kullanmak için. Varsayılan karma kod sağlayıcısı her anahtarın GetHashCode() uygulamasıdır ve varsayılan karşılaştırıcı her anahtarın Equals(Object)uygulamasıdır.

Örnekler

Aşağıdaki kod örneği, farklı Hashtable oluşturucular kullanarak karma tablolar oluşturur ve her biri aynı öğeleri içerse bile karma tabloların davranışındaki farkları gösterir.

using namespace System;
using namespace System::Collections;
using namespace System::Globalization;

ref class myComparer : IEqualityComparer
{
public:
    virtual bool Equals(Object^ x, Object^ y) 
    {
        return x->Equals(y);
    }

    virtual int GetHashCode(Object^ obj)
    {
        return obj->ToString()->ToLower()->GetHashCode();
    }
};

ref class myCultureComparer : IEqualityComparer
{
private:
    CaseInsensitiveComparer^ myComparer;

public:
    myCultureComparer()
    {
        myComparer = CaseInsensitiveComparer::DefaultInvariant;
    }

    myCultureComparer(CultureInfo^ myCulture)
    {
        myComparer = gcnew CaseInsensitiveComparer(myCulture);
    }

    virtual bool Equals(Object^ x, Object^ y) 
    {
        if (myComparer->Compare(x, y) == 0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    virtual int GetHashCode(Object^ obj)
    {
        return obj->ToString()->ToLower()->GetHashCode();
    }
};

int main()
{
   
   // Create a hash table using the default hash code provider and the default comparer.
   Hashtable^ myHT1 = gcnew Hashtable((IEqualityComparer^)nullptr);
   myHT1->Add( "FIRST", "Hello" );
   myHT1->Add( "SECOND", "World" );
   myHT1->Add( "THIRD", "!" );
   
   // Create a hash table using the specified IEqualityComparer that uses
   // the default Object.Equals to determine equality.
   Hashtable^ myHT2 = gcnew Hashtable(gcnew myComparer());
   myHT2->Add( "FIRST", "Hello" );
   myHT2->Add( "SECOND", "World" );
   myHT2->Add( "THIRD", "!" );
   
   // Create a hash table using a case-insensitive hash code provider and
   // case-insensitive comparer based on the InvariantCulture.
   Hashtable^ myHT3 = gcnew Hashtable(
            CaseInsensitiveHashCodeProvider::DefaultInvariant,
            CaseInsensitiveComparer::DefaultInvariant);
   myHT3->Add( "FIRST", "Hello" );
   myHT3->Add( "SECOND", "World" );
   myHT3->Add( "THIRD", "!" );
   
   // Create a hash table using an IEqualityComparer that is based on
   // the Turkish culture (tr-TR) where "I" is not the uppercase
   // version of "i".
   CultureInfo^ myCul = gcnew CultureInfo("tr-TR");
   Hashtable^ myHT4 = gcnew Hashtable( gcnew myCultureComparer(myCul) );
   myHT4->Add( "FIRST", "Hello" );
   myHT4->Add( "SECOND", "World" );
   myHT4->Add( "THIRD", "!" );
   
   // Search for a key in each hash table.
   Console::WriteLine( "first is in myHT1: {0}", myHT1->ContainsKey( "first" ) );
   Console::WriteLine( "first is in myHT2: {0}", myHT2->ContainsKey( "first" ) );
   Console::WriteLine( "first is in myHT3: {0}", myHT3->ContainsKey( "first" ) );
   Console::WriteLine( "first is in myHT4: {0}", myHT4->ContainsKey( "first" ) );
}

/* 
This code produces the following output.  Results vary depending on the system's culture settings.

first is in myHT1: False
first is in myHT2: False
first is in myHT3: True
first is in myHT4: False

*/

using System;
using System.Collections;
using System.Globalization;

class myComparer : IEqualityComparer
{
    public new bool Equals(object x, object y)
    {
        return x.Equals(y);
    }

    public int GetHashCode(object obj)
    {
        return obj.ToString().ToLower().GetHashCode();
    }
}

class myCultureComparer : IEqualityComparer
{
    public CaseInsensitiveComparer myComparer;

    public myCultureComparer()
    {
        myComparer = CaseInsensitiveComparer.DefaultInvariant;
    }

    public myCultureComparer(CultureInfo myCulture)
    {
        myComparer = new CaseInsensitiveComparer(myCulture);
    }

    public new bool Equals(object x, object y)
    {
        return myComparer.Compare(x, y) == 0;
    }

    public int GetHashCode(object obj)
    {
        return obj.ToString().ToLower().GetHashCode();
    }
}

public class SamplesHashtable
{

    public static void Main()
    {

        // Create a hash table using the default comparer.
        var myHT1 = new Hashtable();
        myHT1.Add("FIRST", "Hello");
        myHT1.Add("SECOND", "World");
        myHT1.Add("THIRD", "!");

        // Create a hash table using the specified IEqualityComparer that uses
        // the default Object.Equals to determine equality.
        var myHT2 = new Hashtable(new myComparer());
        myHT2.Add("FIRST", "Hello");
        myHT2.Add("SECOND", "World");
        myHT2.Add("THIRD", "!");

        // Create a hash table using a case-insensitive hash code provider and
        // case-insensitive comparer based on the InvariantCulture.
        Hashtable myHT3 = new Hashtable(
            CaseInsensitiveHashCodeProvider.DefaultInvariant,
            CaseInsensitiveComparer.DefaultInvariant);
        myHT3.Add("FIRST", "Hello");
        myHT3.Add("SECOND", "World");
        myHT3.Add("THIRD", "!");

        // Create a hash table using an IEqualityComparer that is based on
        // the Turkish culture (tr-TR) where "I" is not the uppercase
        // version of "i".
        var myCul = new CultureInfo("tr-TR");
        var myHT4 = new Hashtable(new myCultureComparer(myCul));
        myHT4.Add("FIRST", "Hello");
        myHT4.Add("SECOND", "World");
        myHT4.Add("THIRD", "!");

        // Search for a key in each hash table.
        Console.WriteLine($"first is in myHT1: {myHT1.ContainsKey("first")}");
        Console.WriteLine($"first is in myHT2: {myHT2.ContainsKey("first")}");
        Console.WriteLine($"first is in myHT3: {myHT3.ContainsKey("first")}");
        Console.WriteLine($"first is in myHT4: {myHT4.ContainsKey("first")}");
    }
}


/*
This code produces the following output.
Results vary depending on the system's culture settings.

first is in myHT1: False
first is in myHT2: False
first is in myHT3: True
first is in myHT4: False

*/

Imports System.Collections
Imports System.Globalization

Public Class myComparer
    Implements IEqualityComparer
    Public Function Equals1(ByVal x As Object, ByVal y As Object) _
        As Boolean Implements IEqualityComparer.Equals

        Return x.Equals(y)
    End Function

    Public Function GetHashCode1(ByVal obj As Object) _
        As Integer Implements IEqualityComparer.GetHashCode

        Return obj.ToString().ToLower().GetHashCode()
    End Function

End Class

Public Class myCultureComparer
    Implements IEqualityComparer

    Dim myComparer As CaseInsensitiveComparer

    Public Sub New()
        myComparer = CaseInsensitiveComparer.DefaultInvariant
    End Sub

    Public Sub New(ByVal myCulture As CultureInfo)
        myComparer = New CaseInsensitiveComparer(myCulture)
    End Sub

    Public Function Equals1(ByVal x As Object, ByVal y As Object) _
        As Boolean Implements IEqualityComparer.Equals

        Return myComparer.Compare(x, y) = 0
    End Function

    Public Function GetHashCode1(ByVal obj As Object) _
        As Integer Implements IEqualityComparer.GetHashCode
        Return obj.ToString().ToLower().GetHashCode()
    End Function
End Class

Public Class SamplesHashtable

    Public Shared Sub Main()

        ' Create a hash table using the default comparer.
        Dim myHT1 As New Hashtable()
        myHT1.Add("FIRST", "Hello")
        myHT1.Add("SECOND", "World")
        myHT1.Add("THIRD", "!")

        ' Create a hash table using the specified IEqualityComparer that uses
        ' the default Object.Equals to determine equality.
        Dim myHT2 As New Hashtable(New myComparer())
        myHT2.Add("FIRST", "Hello")
        myHT2.Add("SECOND", "World")
        myHT2.Add("THIRD", "!")

        ' Create a hash table using a case-insensitive hash code provider and
        ' case-insensitive comparer based on the InvariantCulture.
        Dim myHT3 As New Hashtable( _
            CaseInsensitiveHashCodeProvider.DefaultInvariant, _
            CaseInsensitiveComparer.DefaultInvariant)
        myHT3.Add("FIRST", "Hello")
        myHT3.Add("SECOND", "World")
        myHT3.Add("THIRD", "!")

        ' Create a hash table using an IEqualityComparer that is based on
        ' the Turkish culture (tr-TR) where "I" is not the uppercase
        ' version of "i".
        Dim myCul As New CultureInfo("tr-TR")
        Dim myHT4 As New Hashtable(New myCultureComparer(myCul))
        myHT4.Add("FIRST", "Hello")
        myHT4.Add("SECOND", "World")
        myHT4.Add("THIRD", "!")

        ' Search for a key in each hash table.
        Console.WriteLine($"first is in myHT1: {myHT1.ContainsKey("first")}")
        Console.WriteLine($"first is in myHT2: {myHT2.ContainsKey("first")}")
        Console.WriteLine($"first is in myHT3: {myHT3.ContainsKey("first")}")
        Console.WriteLine($"first is in myHT4: {myHT4.ContainsKey("first")}")

    End Sub

End Class

'This code produces the following output.
'Results vary depending on the system's culture settings.

'first is in myHT1: False
'first is in myHT2: False
'first is in myHT3: True
'first is in myHT4: False

Açıklamalar

Karma tablosunun kapasitesi, yük faktörüne göre en uygun karma tablo demet sayısını hesaplamak için kullanılır. Kapasite gerektiğinde otomatik olarak artırılır.

Yük faktörü, öğelerin demetlere en yüksek oranıdır. Daha küçük bir yük faktörü, artan bellek tüketimi maliyetiyle daha hızlı arama anlamına gelir.

Gerçek yük faktörü belirtilen yük faktörüne ulaştığında, demet 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 yükseltilir.

IEqualityComparer nesnesi hem karma kod sağlayıcısını hem de karşılaştırıcıyı içerir. oluşturucuda bir IEqualityComparer kullanılırsa, nesnede Hashtable anahtar olarak kullanılan nesnelerin ve Object.Equals yöntemlerini geçersiz kılmak Object.GetHashCode için gerekli Hashtable değildir.

Karma kod sağlayıcısı içindeki anahtarlar Hashtableiçin karma kodları dağıtır. Varsayılan karma kod sağlayıcısı anahtarın uygulamasıdır Object.GetHashCode.

Karşılaştırıcı, iki anahtarın eşit olup olmadığını belirler. içindeki Hashtable her anahtar benzersiz olmalıdır. Varsayılan karşılaştırıcı anahtarın uygulamasıdır Object.Equals.

, IEqualityComparer büyük/küçük harfe duyarlı olmayan dizelerle arama yapma gibi senaryoları etkinleştirir.

Bu oluşturucu bir O(1) işlemdir.

Ayrıca bkz.

• IEqualityComparer

Hashtable(IDictionary)

Kaynak:

Hashtable.cs

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.

public:
 Hashtable(System::Collections::IDictionary ^ d);

public Hashtable (System.Collections.IDictionary d);

new System.Collections.Hashtable : System.Collections.IDictionary -> System.Collections.Hashtable

Public Sub New (d As IDictionary)

Parametreler

d

IDictionary

IDictionary Yeni Hashtable bir nesneye kopyalanacak nesne.

Özel durumlar

ArgumentNullException

d, null değeridir.

Örnekler

Aşağıdaki kod örneği, farklı Hashtable oluşturucular kullanarak karma tablolar oluşturur ve her biri aynı öğeleri içerse bile karma tabloların davranışındaki farkları gösterir.

using namespace System;
using namespace System::Collections;
using namespace System::Globalization;

ref class myCultureComparer : public IEqualityComparer
{
public:
    CaseInsensitiveComparer^ myComparer;

public:
    myCultureComparer()
    {
        myComparer = CaseInsensitiveComparer::DefaultInvariant;
    }

public:
    myCultureComparer(CultureInfo^ myCulture)
    {
        myComparer = gcnew CaseInsensitiveComparer(myCulture);
    }

public:
    virtual bool Equals(Object^ x, Object^ y)
    {
        if (myComparer->Compare(x, y) == 0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

public:
    virtual int GetHashCode(Object^ obj)
    {
        // Compare the hash code for the lowercase versions of the strings.
        return obj->ToString()->ToLower()->GetHashCode();
    }
};

public ref class SamplesHashtable
{

public:
    static void Main()
    {
        // Create the dictionary.
        SortedList^ mySL = gcnew SortedList();
        mySL->Add("FIRST", "Hello");
        mySL->Add("SECOND", "World");
        mySL->Add("THIRD", "!");

        // Create a hash table using the default comparer.
        Hashtable^ myHT1 = gcnew Hashtable(mySL);

        // Create a hash table using the specified IEqualityComparer that uses
        // the CaseInsensitiveComparer.DefaultInvariant to determine equality.
        Hashtable^ myHT2 = gcnew Hashtable(mySL, gcnew myCultureComparer());

        // Create a hash table using an IEqualityComparer that is based on
        // the Turkish culture (tr-TR) where "I" is not the uppercase
        // version of "i".
        CultureInfo^ myCul = gcnew CultureInfo("tr-TR");
        Hashtable^ myHT3 = gcnew Hashtable(mySL, gcnew myCultureComparer(myCul));

        // Search for a key in each hash table.
        Console::WriteLine("first is in myHT1: {0}", myHT1->ContainsKey("first"));
        Console::WriteLine("first is in myHT2: {0}", myHT2->ContainsKey("first"));
        Console::WriteLine("first is in myHT3: {0}", myHT3->ContainsKey("first"));
    }
};

int main()
{
    SamplesHashtable::Main();
};

/* 
This code produces the following output. 
Results vary depending on the system's culture settings.

first is in myHT1: False
first is in myHT2: True
first is in myHT3: False

*/

using System;
using System.Collections;
using System.Globalization;

class myCultureComparer : IEqualityComparer
{
    public CaseInsensitiveComparer myComparer;

    public myCultureComparer()
    {
        myComparer = CaseInsensitiveComparer.DefaultInvariant;
    }

    public myCultureComparer(CultureInfo myCulture)
    {
        myComparer = new CaseInsensitiveComparer(myCulture);
    }

    public new bool Equals(object x, object y)
    {
        return myComparer.Compare(x, y) == 0;
    }

    public int GetHashCode(object obj)
    {
        // Compare the hash code for the lowercase versions of the strings.
        return obj.ToString().ToLower().GetHashCode();
    }
}

public class SamplesHashtable
{

    public static void Main()
    {

        // Create the dictionary.
        var mySL = new SortedList();
        mySL.Add("FIRST", "Hello");
        mySL.Add("SECOND", "World");
        mySL.Add("THIRD", "!");

        // Create a hash table using the default comparer.
        var myHT1 = new Hashtable(mySL);

        // Create a hash table using the specified IEqualityComparer that uses
        // the CaseInsensitiveComparer.DefaultInvariant to determine equality.
        var myHT2 = new Hashtable(mySL, new myCultureComparer());

        // Create a hash table using an IEqualityComparer that is based on
        // the Turkish culture (tr-TR) where "I" is not the uppercase
        // version of "i".
        var myCul = new CultureInfo("tr-TR");
        var myHT3 = new Hashtable(mySL, new myCultureComparer(myCul));

        // Search for a key in each hash table.
        Console.WriteLine($"first is in myHT1: {myHT1.ContainsKey("first")}");
        Console.WriteLine($"first is in myHT2: {myHT2.ContainsKey("first")}");
        Console.WriteLine($"first is in myHT3: {myHT3.ContainsKey("first")}");
    }
}


/*
This code produces the following output.
Results vary depending on the system's culture settings.

first is in myHT1: False
first is in myHT2: True
first is in myHT3: False

*/

Imports System.Collections
Imports System.Globalization

Public Class myCultureComparer
    Implements IEqualityComparer

    Dim myComparer As CaseInsensitiveComparer

    Public Sub New()
        myComparer = CaseInsensitiveComparer.DefaultInvariant
    End Sub

    Public Sub New(ByVal myCulture As CultureInfo)
        myComparer = New CaseInsensitiveComparer(myCulture)
    End Sub

    Public Function Equals1(ByVal x As Object, ByVal y As Object) _
        As Boolean Implements IEqualityComparer.Equals

        Return myComparer.Compare(x, y) = 0
    End Function

    Public Function GetHashCode1(ByVal obj As Object) _
        As Integer Implements IEqualityComparer.GetHashCode
        Return obj.ToString().ToLower().GetHashCode()
    End Function
End Class

Public Class SamplesHashtable   

   Public Shared Sub Main()

      ' Create the dictionary.
      Dim mySL As New SortedList()
      mySL.Add("FIRST", "Hello")
      mySL.Add("SECOND", "World")
      mySL.Add("THIRD", "!")

      ' Create a hash table using the default comparer.
      Dim myHT1 As New Hashtable(mySL)

      ' Create a hash table using the specified IEqualityComparer that uses
      ' the CaseInsensitiveComparer.DefaultInvariant to determine equality.
      Dim myHT2 As New Hashtable(mySL, New myCultureComparer())

      ' Create a hash table using an IEqualityComparer that is based on
      ' the Turkish culture (tr-TR) where "I" is not the uppercase
      ' version of "i".
      Dim myCul As New CultureInfo("tr-TR")
      Dim myHT3 As New Hashtable(mySL, New myCultureComparer(myCul))

      ' Search for a key in each hash table.
      Console.WriteLine($"first is in myHT1: {myHT1.ContainsKey("first")}")
      Console.WriteLine($"first is in myHT2: {myHT2.ContainsKey("first")}")
      Console.WriteLine($"first is in myHT3: {myHT3.ContainsKey("first")}")

   End Sub

End Class


'This code produces the following output.
'Results vary depending on the system's culture settings.
'
'first is in myHT1: False
'first is in myHT2: True
'first is in myHT3: False

Açıklamalar

İlk kapasite, kaynak sözlükteki öğe sayısına ayarlanır. Kapasite, yük faktörüne bağlı olarak gerektiğinde otomatik olarak artırılır.

Yük faktörü, öğelerin demetlere en yüksek oranıdır. Daha küçük bir yük faktörü, artan bellek tüketimi maliyetiyle daha hızlı arama anlamına gelir.

Gerçek yük faktörü belirtilen yük faktörüne ulaştığında, demet 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 yükseltilir.

Karma kod sağlayıcısı nesnedeki Hashtable anahtarlar için karma kodları dağıtır. Varsayılan karma kod sağlayıcısı anahtarın uygulamasıdır Object.GetHashCode.

Karşılaştırıcı, iki anahtarın eşit olup olmadığını belirler. içindeki Hashtable her anahtar benzersiz olmalıdır. Varsayılan karşılaştırıcı anahtarın uygulamasıdır Object.Equals.

Yeni Hashtable öğesinin öğeleri, numaralandırıcının nesnede IDictionary yinelendiği aynı düzende sıralanır.

Bu oluşturucu, n parametresindeki d öğelerin sayısı olan bir O(n) işlemdir.

Ayrıca bkz.

• IDictionary
• GetHashCode()
• Equals(Object)

Hashtable(Int32, IEqualityComparer)

Kaynak:

Hashtable.cs

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.

public:
 Hashtable(int capacity, System::Collections::IEqualityComparer ^ equalityComparer);

public Hashtable (int capacity, System.Collections.IEqualityComparer? equalityComparer);

new System.Collections.Hashtable : int * System.Collections.IEqualityComparer -> System.Collections.Hashtable

Public Sub New (capacity As Integer, equalityComparer As IEqualityComparer)

Parametreler

capacity

Int32

Nesnenin Hashtable başlangıçta içerebileceği yaklaşık öğe sayısı.

equalityComparer

IEqualityComparer

IEqualityComparer Karma kod sağlayıcısını ve ile Hashtablekullanılacak karşılaştırıcıyı tanımlayan nesne.

-veya-

null varsayılan karma kod sağlayıcısını ve varsayılan karşılaştırıcıyı kullanmak için. Varsayılan karma kod sağlayıcısı her anahtarın GetHashCode() uygulamasıdır ve varsayılan karşılaştırıcı her anahtarın Equals(Object)uygulamasıdır.

Özel durumlar

ArgumentOutOfRangeException

capacity, sıfırdan küçüktür.

Örnekler

Aşağıdaki kod örneği, farklı Hashtable oluşturucular kullanarak karma tablolar oluşturur ve her biri aynı öğeleri içerse bile karma tabloların davranışındaki farkları gösterir.

using namespace System;
using namespace System::Collections;
using namespace System::Globalization;

ref class myCultureComparer : public IEqualityComparer
{
public:
    CaseInsensitiveComparer^ myComparer;

public:
    myCultureComparer()
    {
        myComparer = CaseInsensitiveComparer::DefaultInvariant;
    }

public:
    myCultureComparer(CultureInfo^ myCulture)
    {
        myComparer = gcnew CaseInsensitiveComparer(myCulture);
    }

public:
    virtual bool Equals(Object^ x, Object^ y)
    {
        if (myComparer->Compare(x, y) == 0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

public:
    virtual int GetHashCode(Object^ obj)
    {
        // Compare the hash code for the lowercase versions of the strings.
        return obj->ToString()->ToLower()->GetHashCode();
    }
};

public ref class SamplesHashtable
{

public:
    static void Main()
    {
        // Create a hash table using the default comparer.
        Hashtable^ myHT1 = gcnew Hashtable(3);
        myHT1->Add("FIRST", "Hello");
        myHT1->Add("SECOND", "World");
        myHT1->Add("THIRD", "!");

        // Create a hash table using the specified IEqualityComparer that uses
        // the CaseInsensitiveComparer.DefaultInvariant to determine equality.
        Hashtable^ myHT2 = gcnew Hashtable(3, gcnew myCultureComparer());
        myHT2->Add("FIRST", "Hello");
        myHT2->Add("SECOND", "World");
        myHT2->Add("THIRD", "!");

        // Create a hash table using an IEqualityComparer that is based on
        // the Turkish culture (tr-TR) where "I" is not the uppercase
        // version of "i".
        CultureInfo^ myCul = gcnew CultureInfo("tr-TR");
        Hashtable^ myHT3 = gcnew Hashtable(3, gcnew myCultureComparer(myCul));
        myHT3->Add("FIRST", "Hello");
        myHT3->Add("SECOND", "World");
        myHT3->Add("THIRD", "!");

        // Search for a key in each hash table.
        Console::WriteLine("first is in myHT1: {0}", myHT1->ContainsKey("first"));
        Console::WriteLine("first is in myHT2: {0}", myHT2->ContainsKey("first"));
        Console::WriteLine("first is in myHT3: {0}", myHT3->ContainsKey("first"));

    }
};

int main()
{
    SamplesHashtable::Main();
}

/* 
This code produces the following output.  Results vary depending on the system's culture settings.

first is in myHT1: False
first is in myHT2: True
first is in myHT3: False

*/

using System;
using System.Collections;
using System.Globalization;

class myCultureComparer : IEqualityComparer
{
    public CaseInsensitiveComparer myComparer;

    public myCultureComparer()
    {
        myComparer = CaseInsensitiveComparer.DefaultInvariant;
    }

    public myCultureComparer(CultureInfo myCulture)
    {
        myComparer = new CaseInsensitiveComparer(myCulture);
    }

    public new bool Equals(object x, object y)
    {
        if (myComparer.Compare(x, y) == 0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    public int GetHashCode(object obj)
    {
        // Compare the hash code for the lowercase versions of the strings.
        return obj.ToString().ToLower().GetHashCode();
    }
}

public class SamplesHashtable
{

    public static void Main()
    {

        // Create a hash table using the default comparer.
        Hashtable myHT1 = new Hashtable(3);
        myHT1.Add("FIRST", "Hello");
        myHT1.Add("SECOND", "World");
        myHT1.Add("THIRD", "!");

        // Create a hash table using the specified IEqualityComparer that uses
        // the CaseInsensitiveComparer.DefaultInvariant to determine equality.
        Hashtable myHT2 = new Hashtable(3, new myCultureComparer());
        myHT2.Add("FIRST", "Hello");
        myHT2.Add("SECOND", "World");
        myHT2.Add("THIRD", "!");

        // Create a hash table using an IEqualityComparer that is based on
        // the Turkish culture (tr-TR) where "I" is not the uppercase
        // version of "i".
        CultureInfo myCul = new CultureInfo("tr-TR");
        Hashtable myHT3 = new Hashtable(3, new myCultureComparer(myCul));
        myHT3.Add("FIRST", "Hello");
        myHT3.Add("SECOND", "World");
        myHT3.Add("THIRD", "!");

        // Search for a key in each hash table.
        Console.WriteLine("first is in myHT1: {0}", myHT1.ContainsKey("first"));
        Console.WriteLine("first is in myHT2: {0}", myHT2.ContainsKey("first"));
        Console.WriteLine("first is in myHT3: {0}", myHT3.ContainsKey("first"));
    }
}


/*
This code produces the following output.
Results vary depending on the system's culture settings.

first is in myHT1: False
first is in myHT2: True
first is in myHT3: False

*/

Imports System.Collections
Imports System.Globalization

Public Class myCultureComparer
    Implements IEqualityComparer

    Dim myComparer As CaseInsensitiveComparer

    Public Sub New()
        myComparer = CaseInsensitiveComparer.DefaultInvariant
    End Sub

    Public Sub New(ByVal myCulture As CultureInfo)
        myComparer = New CaseInsensitiveComparer(myCulture)
    End Sub

    Public Function Equals1(ByVal x As Object, ByVal y As Object) _
        As Boolean Implements IEqualityComparer.Equals

        If (myComparer.Compare(x, y) = 0) Then
            Return True
        Else
            Return False
        End If
    End Function

    Public Function GetHashCode1(ByVal obj As Object) _
        As Integer Implements IEqualityComparer.GetHashCode
        Return obj.ToString().ToLower().GetHashCode()
    End Function
End Class

Public Class SamplesHashtable   

   Public Shared Sub Main()

      ' Create a hash table using the default comparer.
      Dim myHT1 As New Hashtable(3)
      myHT1.Add("FIRST", "Hello")
      myHT1.Add("SECOND", "World")
      myHT1.Add("THIRD", "!")

      ' Create a hash table using the specified IEqualityComparer that uses
      ' the CaseInsensitiveComparer.DefaultInvariant to determine equality.
      Dim myHT2 As New Hashtable(3, New myCultureComparer())
      myHT2.Add("FIRST", "Hello")
      myHT2.Add("SECOND", "World")
      myHT2.Add("THIRD", "!")

      ' Create a hash table using an IEqualityComparer that is based on
      ' the Turkish culture (tr-TR) where "I" is not the uppercase
      ' version of "i".
      Dim myCul As New CultureInfo("tr-TR")
      Dim myHT3 As New Hashtable(3, New myCultureComparer(myCul))
      myHT3.Add("FIRST", "Hello")
      myHT3.Add("SECOND", "World")
      myHT3.Add("THIRD", "!")

      ' Search for a key in each hash table.
      Console.WriteLine("first is in myHT1: {0}", myHT1.ContainsKey("first"))
      Console.WriteLine("first is in myHT2: {0}", myHT2.ContainsKey("first"))
      Console.WriteLine("first is in myHT3: {0}", myHT3.ContainsKey("first"))

   End Sub

End Class


'This code produces the following output.
'Results vary depending on the system's culture settings.
'
'first is in myHT1: False
'first is in myHT2: True
'first is in myHT3: False

Açıklamalar

İlk kapasitenin belirtilmesi, nesneye öğe eklerken bir dizi yeniden boyutlandırma işlemi gerçekleştirme gereksinimini Hashtable ortadan kaldırır. Kapasite, yük faktörüne bağlı olarak gerektiğinde otomatik olarak artırılır.

Yük faktörü, öğelerin demetlere en yüksek oranıdır. Daha küçük bir yük faktörü, artan bellek tüketimi maliyetinde daha hızlı arama anlamına gelir.

Gerçek yük faktörü belirtilen yük faktörüne ulaştığında, demet 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 yükseltilir.

IEqualityComparer nesnesi hem karma kod sağlayıcısını hem de karşılaştırıcıyı içerir. IEqualityComparer oluşturucuda Hashtable kullanılırsa, ve Object.Equals yöntemlerini geçersiz kılmak Object.GetHashCode için içinde Hashtable anahtar olarak kullanılan nesneler gerekli değildir.

Karma kod sağlayıcısı içindeki anahtarlar Hashtableiçin karma kodları dağıtır. Varsayılan karma kod sağlayıcısı anahtarın uygulamasıdır Object.GetHashCode.

Karşılaştırıcı, iki anahtarın eşit olup olmadığını belirler. içindeki Hashtable her anahtar benzersiz olmalıdır. Varsayılan karşılaştırıcı anahtarın uygulamasıdır Object.Equals.

, IEqualityComparer büyük/küçük harfe duyarlı olmayan dizelerle arama yapma gibi senaryoları etkinleştirir.

Bu oluşturucu, parametresi olan n bir O(n) işlemdircapacity.

Ayrıca bkz.

• IEqualityComparer