Hashtable Konstruktory

Definicja

Inicjuje nowe wystąpienie klasy Hashtable.Initializes a new instance of the Hashtable class.

Przeciążenia

Hashtable()

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

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

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

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

Inicjuje nowe wystąpienie Hashtable klasy przez skopiowanie elementów z określonego słownika do nowego Hashtable obiektu.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. Nowy Hashtable obiekt ma początkową pojemność równą liczbie skopiowanych elementów i używa określonego współczynnika obciążenia, dostawcy kodu skrótu i programu porównującego.The new Hashtable object has an initial capacity equal to the number of elements copied, and uses the specified load factor, hash code provider, and comparer.

Hashtable(Int32, Single, IEqualityComparer)

Inicjuje nowe, puste wystąpienie Hashtable klasy przy użyciu określonej początkowej pojemności, współczynnika obciążenia i IEqualityComparer obiektu.Initializes a new, empty instance of the Hashtable class using the specified initial capacity, load factor, and IEqualityComparer object.

Hashtable(Int32, IHashCodeProvider, IComparer)
Nieaktualne.

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

Hashtable(IDictionary, Single, IEqualityComparer)

Inicjuje nowe wystąpienie Hashtable klasy przez skopiowanie elementów z określonego słownika do nowego Hashtable obiektu.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. Nowy Hashtable obiekt ma początkową pojemność równą liczbie skopiowanych elementów i używa określonego współczynnika obciążenia i IEqualityComparer obiektu.The new Hashtable object has an initial capacity equal to the number of elements copied, and uses the specified load factor and IEqualityComparer object.

Hashtable(IDictionary, IHashCodeProvider, IComparer)
Nieaktualne.

Inicjuje nowe wystąpienie Hashtable klasy przez skopiowanie elementów z określonego słownika do nowego Hashtable obiektu.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. Nowy Hashtable obiekt ma początkową pojemność równą liczbie skopiowanych elementów i używa domyślnego współczynnika obciążenia oraz określonego dostawcy kodu skrótu i modułu porównującego.The new Hashtable object has an initial capacity equal to the number of elements copied, and uses the default load factor, and the specified hash code provider and comparer. Ten interfejs API jest nieaktualny.This API is obsolete. Aby zapoznać się z alternatywnym, zobacz Hashtable(IDictionary, IEqualityComparer) .For an alternative, see Hashtable(IDictionary, IEqualityComparer).

Hashtable(Int32, Single)

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

Hashtable(SerializationInfo, StreamingContext)

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

Hashtable(IHashCodeProvider, IComparer)
Nieaktualne.

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

Hashtable(IDictionary, Single)

Inicjuje nowe wystąpienie Hashtable klasy przez skopiowanie elementów z określonego słownika do nowego Hashtable obiektu.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. Nowy Hashtable obiekt ma początkową pojemność równą liczbie skopiowanych elementów i używa określonego współczynnika obciążenia oraz domyślnego dostawcy kodu skrótu i programu porównującego.The new Hashtable object has an initial capacity equal to the number of elements copied, and uses the specified load factor, and the default hash code provider and comparer.

Hashtable(IDictionary, IEqualityComparer)

Inicjuje nowe wystąpienie Hashtable klasy przez skopiowanie elementów z określonego słownika do nowego Hashtable obiektu.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to a new Hashtable object. Nowy Hashtable obiekt ma początkową pojemność równą liczbie skopiowanych elementów i używa domyślnego współczynnika obciążenia i określonego IEqualityComparer obiektu.The new Hashtable object has an initial capacity equal to the number of elements copied, and uses the default load factor and the specified IEqualityComparer object.

Hashtable(Int32)

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

Hashtable(IEqualityComparer)

Inicjuje nowe, puste wystąpienie Hashtable klasy przy użyciu domyślnej początkowej pojemności i współczynnika obciążenia oraz określonego IEqualityComparer obiektu.Initializes a new, empty instance of the Hashtable class using the default initial capacity and load factor, and the specified IEqualityComparer object.

Hashtable(IDictionary)

Inicjuje nowe wystąpienie Hashtable klasy przez skopiowanie elementów z określonego słownika do nowego Hashtable obiektu.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. Nowy Hashtable obiekt ma początkową pojemność równą liczbie skopiowanych elementów i używa domyślnego współczynnika ładowania, dostawcy kodu skrótu i programu porównującego.The new Hashtable object has an initial capacity equal to the number of elements copied, and uses the default load factor, hash code provider, and comparer.

Hashtable(Int32, IEqualityComparer)

Inicjuje nowe, puste wystąpienie Hashtable klasy przy użyciu określonej początkowej pojemności i IEqualityComparer i domyślnego współczynnika obciążenia.Initializes a new, empty instance of the Hashtable class using the specified initial capacity and IEqualityComparer, and the default load factor.

Hashtable()

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

public:
 Hashtable();
public Hashtable ();
Public Sub New ()

Przykłady

Poniższy przykład kodu tworzy tabele skrótów przy użyciu różnych Hashtable konstruktorów i pokazuje różnice w zachowaniu tabel skrótów, nawet jeśli każda z nich zawiera te same elementy.The following code example creates hash tables using different Hashtable constructors and demonstrates the differences in the behavior of the hash tables, even if each one contains the same elements.

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

Uwagi

Wydajność tabeli skrótów służy do obliczania optymalnej liczby zasobników tabeli skrótów na podstawie współczynnika obciążenia.A hash table's capacity is used to calculate the optimal number of hash table buckets based on the load factor. Pojemność jest automatycznie zwiększana odpowiednio do potrzeb.Capacity is automatically increased as required.

Współczynnik obciążenia to maksymalny stosunek elementów do zasobników.The load factor is the maximum ratio of elements to buckets. Mniejszy współczynnik obciążenia oznacza szybsze wyszukiwanie przy kosztach zwiększonego zużycia pamięci.A smaller load factor means faster lookup at the cost of increased memory consumption.

Gdy rzeczywisty współczynnik obciążenia osiągnie określony współczynnik obciążenia, liczba przedziałów zostanie automatycznie zwiększona do najmniejszej liczby, która jest większa niż dwukrotnie bieżąca liczba zasobników.When the actual load factor reaches the specified load factor, the number of buckets is automatically increased to the smallest prime number that is larger than twice the current number of buckets.

Dostawca kodu skrótu ma kody skrótów dla kluczy w Hashtable obiekcie.The hash code provider dispenses hash codes for keys in the Hashtable object. Domyślnym dostawcą kodu skrótu jest implementacja klucza Object.GetHashCode .The default hash code provider is the key's implementation of Object.GetHashCode.

Funkcja porównująca określa, czy dwa klucze są równe.The comparer determines whether two keys are equal. Każdy klucz w a Hashtable musi być unikatowy.Every key in a Hashtable must be unique. Domyślna funkcja porównująca jest implementacją klucza Object.Equals .The default comparer is the key's implementation of Object.Equals.

Ten konstruktor jest O(1) operacją.This constructor is an O(1) operation.

Zobacz też

Dotyczy

Produkt Introduced

Hashtable(Int32, Single, IHashCodeProvider, IComparer)

Przestroga

Please use Hashtable(int, float, IEqualityComparer) instead.

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

public:
 Hashtable(int capacity, float loadFactor, System::Collections::IHashCodeProvider ^ hcp, System::Collections::IComparer ^ comparer);
public Hashtable (int capacity, float loadFactor, System.Collections.IHashCodeProvider hcp, System.Collections.IComparer comparer);
[System.Obsolete("Please use Hashtable(int, float, IEqualityComparer) instead.")]
public Hashtable (int capacity, float loadFactor, System.Collections.IHashCodeProvider hcp, System.Collections.IComparer comparer);
new System.Collections.Hashtable : int * single * System.Collections.IHashCodeProvider * System.Collections.IComparer -> System.Collections.Hashtable
[<System.Obsolete("Please 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)

Parametry

capacity
Int32

Przybliżona liczba elementów, które Hashtable obiekt może początkowo zawierać.The approximate number of elements that the Hashtable object can initially contain.

loadFactor
Single

Liczba z zakresu od 0,1 do 1,0, pomnożona przez wartość domyślną, która zapewnia najlepszą wydajność.A number in the range from 0.1 through 1.0 that is multiplied by the default value which provides the best performance. Wynikiem jest maksymalny stosunek elementów do zasobników.The result is the maximum ratio of elements to buckets.

hcp
IHashCodeProvider

IHashCodeProviderObiekt, który dostarcza kody skrótów dla wszystkich kluczy w Hashtable .The IHashCodeProvider object that supplies the hash codes for all keys in the Hashtable.

-lub--or- nullAby użyć domyślnego dostawcy kodu skrótu, który jest implementacją każdego klucza GetHashCode() .null to use the default hash code provider, which is each key's implementation of GetHashCode().

comparer
IComparer

IComparerObiekt, który ma zostać użyty do określenia, czy dwa klucze są równe.The IComparer object to use to determine whether two keys are equal.

-lub--or- nullAby użyć domyślnej wartości porównującej, która jest implementacją każdego klucza Equals(Object) .null to use the default comparer, which is each key's implementation of Equals(Object).

Atrybuty

Wyjątki

Parametr capacity ma wartość niższą niż zero.capacity is less than zero.

-lub--or- loadFactorjest mniejsza niż 0,1.loadFactor is less than 0.1.

-lub--or- loadFactorjest większa niż 1,0.loadFactor is greater than 1.0.

Przykłady

Poniższy przykład kodu tworzy tabele skrótów przy użyciu różnych Hashtable konstruktorów i pokazuje różnice w zachowaniu tabel skrótów, nawet jeśli każda z nich zawiera te same elementy.The following code example creates hash tables using different Hashtable constructors and demonstrates the differences in the behavior of the hash tables, even if each one contains the same elements.

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

Uwagi

Określenie początkowej pojemności eliminuje konieczność wykonywania wielu operacji zmiany rozmiarów podczas dodawania elementów do Hashtable obiektu.Specifying the initial capacity eliminates the need to perform a number of resizing operations while adding elements to the Hashtable object. Pojemność jest automatycznie zwiększana zgodnie z wymaganiami w zależności od współczynnika obciążenia.Capacity is automatically increased as required based on the load factor.

Współczynnik obciążenia to maksymalny stosunek elementów do zasobników.The load factor is the maximum ratio of elements to buckets. Mniejszy współczynnik obciążenia oznacza szybsze wyszukiwanie przy kosztach zwiększonego zużycia pamięci.A smaller load factor means faster lookup at the cost of increased memory consumption. Współczynnik obciążenia 1,0 to Najlepsza równowaga między szybkością i rozmiarem.A load factor of 1.0 is the best balance between speed and size.

Gdy rzeczywisty współczynnik obciążenia osiągnie określony współczynnik obciążenia, liczba przedziałów zostanie automatycznie zwiększona do najmniejszej liczby, która jest większa niż dwukrotnie bieżąca liczba zasobników.When the actual load factor reaches the specified load factor, the number of buckets is automatically increased to the smallest prime number that is larger than twice the current number of buckets.

Dostawca kodu skrótu ma kody skrótów dla kluczy w Hashtable .The hash code provider dispenses hash codes for keys in the Hashtable. Domyślnym dostawcą kodu skrótu jest implementacja klucza Object.GetHashCode .The default hash code provider is the key's implementation of Object.GetHashCode.

Funkcja porównująca określa, czy dwa klucze są równe.The comparer determines whether two keys are equal. Każdy klucz w a Hashtable musi być unikatowy.Every key in a Hashtable must be unique. Domyślna funkcja porównująca jest implementacją klucza Object.Equals .The default comparer is the key's implementation of Object.Equals.

Niestandardowy dostawca kodu skrótu i niestandardowa funkcja porównująca umożliwiają tworzenie scenariuszy, takich jak wyszukiwanie za pomocą ciągów bez uwzględniania wielkości liter.The custom hash code provider and the custom comparer enable scenarios such as doing lookups with case-insensitive strings.

Ten konstruktor jest O(n) operacją, gdzie n jest capacity parametrem.This constructor is an O(n) operation, where n is the capacity parameter.

Zobacz też

Dotyczy

Produkt Introduced

Hashtable(IDictionary, Single, IHashCodeProvider, IComparer)

Przestroga

Please use Hashtable(IDictionary, float, IEqualityComparer) instead.

Inicjuje nowe wystąpienie Hashtable klasy przez skopiowanie elementów z określonego słownika do nowego Hashtable obiektu.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. Nowy Hashtable obiekt ma początkową pojemność równą liczbie skopiowanych elementów i używa określonego współczynnika obciążenia, dostawcy kodu skrótu i programu porównującego.The new Hashtable object has an initial capacity equal to the number of elements copied, and uses the specified load factor, hash code provider, and comparer.

public:
 Hashtable(System::Collections::IDictionary ^ d, float loadFactor, System::Collections::IHashCodeProvider ^ hcp, System::Collections::IComparer ^ comparer);
public Hashtable (System.Collections.IDictionary? d, float loadFactor, System.Collections.IHashCodeProvider hcp, System.Collections.IComparer comparer);
[System.Obsolete("Please use Hashtable(IDictionary, float, IEqualityComparer) instead.")]
public Hashtable (System.Collections.IDictionary d, float loadFactor, System.Collections.IHashCodeProvider hcp, System.Collections.IComparer comparer);
[System.Obsolete("Please use Hashtable(IDictionary, float, IEqualityComparer) instead.")]
public Hashtable (System.Collections.IDictionary? d, float loadFactor, System.Collections.IHashCodeProvider hcp, System.Collections.IComparer comparer);
public Hashtable (System.Collections.IDictionary d, float loadFactor, System.Collections.IHashCodeProvider hcp, System.Collections.IComparer comparer);
new System.Collections.Hashtable : System.Collections.IDictionary * single * System.Collections.IHashCodeProvider * System.Collections.IComparer -> System.Collections.Hashtable
[<System.Obsolete("Please 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)

Parametry

d
IDictionary

IDictionaryObiekt, który ma zostać skopiowany do nowego Hashtable obiektu.The IDictionary object to copy to a new Hashtable object.

loadFactor
Single

Liczba z zakresu od 0,1 do 1,0, pomnożona przez wartość domyślną, która zapewnia najlepszą wydajność.A number in the range from 0.1 through 1.0 that is multiplied by the default value which provides the best performance. Wynikiem jest maksymalny stosunek elementów do zasobników.The result is the maximum ratio of elements to buckets.

hcp
IHashCodeProvider

IHashCodeProviderObiekt, który dostarcza kody skrótów dla wszystkich kluczy w Hashtable .The IHashCodeProvider object that supplies the hash codes for all keys in the Hashtable.

-lub--or- nullAby użyć domyślnego dostawcy kodu skrótu, który jest implementacją każdego klucza GetHashCode() .null to use the default hash code provider, which is each key's implementation of GetHashCode().

comparer
IComparer

IComparerObiekt, który ma zostać użyty do określenia, czy dwa klucze są równe.The IComparer object to use to determine whether two keys are equal.

-lub--or- nullAby użyć domyślnej wartości porównującej, która jest implementacją każdego klucza Equals(Object) .null to use the default comparer, which is each key's implementation of Equals(Object).

Atrybuty

Wyjątki

d to null.d is null.

loadFactorjest mniejsza niż 0,1.loadFactor is less than 0.1.

-lub--or- loadFactorjest większa niż 1,0.loadFactor is greater than 1.0.

Przykłady

Poniższy przykład kodu tworzy tabele skrótów przy użyciu różnych Hashtable konstruktorów i pokazuje różnice w zachowaniu tabel skrótów, nawet jeśli każda z nich zawiera te same elementy.The following code example creates hash tables using different Hashtable constructors and demonstrates the differences in the behavior of the hash tables, even if each one contains the same elements.

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

Uwagi

Początkowa pojemność jest ustawiona na liczbę elementów w słowniku źródłowym.The initial capacity is set to the number of elements in the source dictionary. Pojemność jest automatycznie zwiększana zgodnie z wymaganiami w zależności od współczynnika obciążenia.Capacity is automatically increased as required based on the load factor.

Współczynnik obciążenia to maksymalny stosunek elementów do zasobników.The load factor is the maximum ratio of elements to buckets. Mniejszy współczynnik obciążenia oznacza szybsze wyszukiwanie przy kosztach zwiększonego zużycia pamięci.A smaller load factor means faster lookup at the cost of increased memory consumption. Współczynnik obciążenia 1,0 to Najlepsza równowaga między szybkością i rozmiarem.A load factor of 1.0 is the best balance between speed and size.

Gdy rzeczywisty współczynnik obciążenia osiągnie określony współczynnik obciążenia, liczba przedziałów zostanie automatycznie zwiększona do najmniejszej liczby, która jest większa niż dwukrotnie bieżąca liczba zasobników.When the actual load factor reaches the specified load factor, the number of buckets is automatically increased to the smallest prime number that is larger than twice the current number of buckets.

Dostawca kodu skrótu ma kody skrótów dla kluczy w Hashtable obiekcie.The hash code provider dispenses hash codes for keys in the Hashtable object. Domyślnym dostawcą kodu skrótu jest implementacja klucza Object.GetHashCode .The default hash code provider is the key's implementation of Object.GetHashCode.

Funkcja porównująca określa, czy dwa klucze są równe.The comparer determines whether two keys are equal. Każdy klucz w a Hashtable musi być unikatowy.Every key in a Hashtable must be unique. Domyślna funkcja porównująca jest implementacją klucza Object.Equals .The default comparer is the key's implementation of Object.Equals.

Niestandardowy dostawca kodu skrótu i niestandardowa funkcja porównująca umożliwiają tworzenie scenariuszy, takich jak wyszukiwanie za pomocą ciągów bez uwzględniania wielkości liter.The custom hash code provider and the custom comparer enable scenarios such as doing lookups with case-insensitive strings.

Elementy nowego Hashtable są sortowane w tej samej kolejności, w której moduł wyliczający iteruje przez IDictionary obiekt.The elements of the new Hashtable are sorted in the same order in which the enumerator iterates through the IDictionary object.

Ten konstruktor jest O(n) operacją, gdzie n jest liczbą elementów w d parametrze.This constructor is an O(n) operation, where n is the number of elements in the d parameter.

Dotyczy

Produkt Introduced

Hashtable(Int32, Single, IEqualityComparer)

Inicjuje nowe, puste wystąpienie Hashtable klasy przy użyciu określonej początkowej pojemności, współczynnika obciążenia i IEqualityComparer obiektu.Initializes a new, empty instance of the Hashtable class using the specified initial capacity, load factor, and IEqualityComparer object.

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)

Parametry

capacity
Int32

Przybliżona liczba elementów, które Hashtable obiekt może początkowo zawierać.The approximate number of elements that the Hashtable object can initially contain.

loadFactor
Single

Liczba z zakresu od 0,1 do 1,0, pomnożona przez wartość domyślną, która zapewnia najlepszą wydajność.A number in the range from 0.1 through 1.0 that is multiplied by the default value which provides the best performance. Wynikiem jest maksymalny stosunek elementów do zasobników.The result is the maximum ratio of elements to buckets.

equalityComparer
IEqualityComparer

IEqualityComparerObiekt, który definiuje dostawcę kodu skrótu i moduł porównujący do użycia z Hashtable .The IEqualityComparer object that defines the hash code provider and the comparer to use with the Hashtable.

-lub--or- nullAby użyć domyślnego dostawcy kodu skrótu i domyślnej wartości porównującej.null to use the default hash code provider and the default comparer. Domyślny dostawca kodu skrótu jest implementacją każdego klucza GetHashCode() i domyślną wartością porównującą jest implementacja każdego klucza Equals(Object) .The default hash code provider is each key's implementation of GetHashCode() and the default comparer is each key's implementation of Equals(Object).

Wyjątki

Parametr capacity ma wartość niższą niż zero.capacity is less than zero.

-lub--or- loadFactorjest mniejsza niż 0,1.loadFactor is less than 0.1.

-lub--or- loadFactorjest większa niż 1,0.loadFactor is greater than 1.0.

Przykłady

Poniższy przykład kodu tworzy tabele skrótów przy użyciu różnych Hashtable konstruktorów i pokazuje różnice w zachowaniu tabel skrótów, nawet jeśli każda z nich zawiera te same elementy.The following code example creates hash tables using different Hashtable constructors and demonstrates the differences in the behavior of the hash tables, even if each one contains the same elements.

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

Uwagi

Określenie początkowej pojemności eliminuje konieczność wykonywania wielu operacji zmiany rozmiarów podczas dodawania elementów do Hashtable obiektu.Specifying the initial capacity eliminates the need to perform a number of resizing operations while adding elements to the Hashtable object. Pojemność jest automatycznie zwiększana zgodnie z wymaganiami w zależności od współczynnika obciążenia.Capacity is automatically increased as required based on the load factor.

Współczynnik obciążenia to maksymalny stosunek elementów do zasobników.The load factor is the maximum ratio of elements to buckets. Mniejszy współczynnik obciążenia oznacza szybsze wyszukiwanie przy kosztach zwiększonego zużycia pamięci.A smaller load factor means faster lookup at the cost of increased memory consumption. Współczynnik obciążenia 1,0 to Najlepsza równowaga między szybkością i rozmiarem.A load factor of 1.0 is the best balance between speed and size.

Gdy rzeczywisty współczynnik obciążenia osiągnie określony współczynnik obciążenia, liczba przedziałów zostanie automatycznie zwiększona do najmniejszej liczby, która jest większa niż dwukrotnie bieżąca liczba zasobników.When the actual load factor reaches the specified load factor, the number of buckets is automatically increased to the smallest prime number that is larger than twice the current number of buckets.

IEqualityComparerObiekt zawiera zarówno dostawcę kodu skrótu, jak i funkcję porównującą.The IEqualityComparer object includes both the hash code provider and the comparer. Jeśli IEqualityComparer jest używana w Hashtable konstruktorze, obiekty używane jako klucze w Hashtable nie są wymagane do przesłania Object.GetHashCode Object.Equals metod i.If an IEqualityComparer is used in the Hashtable constructor, the objects used as keys in the Hashtable are not required to override the Object.GetHashCode and Object.Equals methods.

Dostawca kodu skrótu ma kody skrótów dla kluczy w Hashtable .The hash code provider dispenses hash codes for keys in the Hashtable. Domyślnym dostawcą kodu skrótu jest implementacja klucza Object.GetHashCode .The default hash code provider is the key's implementation of Object.GetHashCode.

Funkcja porównująca określa, czy dwa klucze są równe.The comparer determines whether two keys are equal. Każdy klucz w a Hashtable musi być unikatowy.Every key in a Hashtable must be unique. Domyślna funkcja porównująca jest implementacją klucza Object.Equals .The default comparer is the key's implementation of Object.Equals.

IEqualityComparerUmożliwia wykonywanie takich scenariuszy, jak wyszukiwanie za pomocą ciągów bez uwzględniania wielkości liter.The IEqualityComparer enables scenarios such as doing lookups with case-insensitive strings.

Ten konstruktor jest O(n) operacją, gdzie n jest capacity parametrem.This constructor is an O(n) operation, where n is the capacity parameter.

Zobacz też

Dotyczy

Produkt Introduced

Hashtable(Int32, IHashCodeProvider, IComparer)

Przestroga

Please use Hashtable(int, IEqualityComparer) instead.

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

public:
 Hashtable(int capacity, System::Collections::IHashCodeProvider ^ hcp, System::Collections::IComparer ^ comparer);
public Hashtable (int capacity, System.Collections.IHashCodeProvider hcp, System.Collections.IComparer comparer);
[System.Obsolete("Please use Hashtable(int, IEqualityComparer) instead.")]
public Hashtable (int capacity, System.Collections.IHashCodeProvider hcp, System.Collections.IComparer comparer);
new System.Collections.Hashtable : int * System.Collections.IHashCodeProvider * System.Collections.IComparer -> System.Collections.Hashtable
[<System.Obsolete("Please 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)

Parametry

capacity
Int32

Przybliżona liczba elementów, które Hashtable obiekt może początkowo zawierać.The approximate number of elements that the Hashtable object can initially contain.

hcp
IHashCodeProvider

IHashCodeProviderObiekt, który dostarcza kody skrótów dla wszystkich kluczy w Hashtable .The IHashCodeProvider object that supplies the hash codes for all keys in the Hashtable.

-lub--or- nullAby użyć domyślnego dostawcy kodu skrótu, który jest implementacją każdego klucza GetHashCode() .null to use the default hash code provider, which is each key's implementation of GetHashCode().

comparer
IComparer

IComparerObiekt, który ma zostać użyty do określenia, czy dwa klucze są równe.The IComparer object to use to determine whether two keys are equal.

-lub--or- nullAby użyć domyślnej wartości porównującej, która jest implementacją każdego klucza Equals(Object) .null to use the default comparer, which is each key's implementation of Equals(Object).

Atrybuty

Wyjątki

Parametr capacity ma wartość niższą niż zero.capacity is less than zero.

Przykłady

Poniższy przykład kodu tworzy tabele skrótów przy użyciu różnych Hashtable konstruktorów i pokazuje różnice w zachowaniu tabel skrótów, nawet jeśli każda z nich zawiera te same elementy.The following code example creates hash tables using different Hashtable constructors and demonstrates the differences in the behavior of the hash tables, even if each one contains the same elements.

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

Uwagi

Określenie początkowej pojemności eliminuje konieczność wykonywania wielu operacji zmiany rozmiarów podczas dodawania elementów do Hashtable obiektu.Specifying the initial capacity eliminates the need to perform a number of resizing operations while adding elements to the Hashtable object. Pojemność jest automatycznie zwiększana zgodnie z wymaganiami w zależności od współczynnika obciążenia.Capacity is automatically increased as required based on the load factor.

Współczynnik obciążenia to maksymalny stosunek elementów do zasobników.The load factor is the maximum ratio of elements to buckets. Mniejszy współczynnik obciążenia oznacza szybsze wyszukiwanie przy kosztach zwiększonego zużycia pamięci.A smaller load factor means faster lookup at the cost of increased memory consumption.

Gdy rzeczywisty współczynnik obciążenia osiągnie określony współczynnik obciążenia, liczba przedziałów zostanie automatycznie zwiększona do najmniejszej liczby, która jest większa niż dwukrotnie bieżąca liczba zasobników.When the actual load factor reaches the specified load factor, the number of buckets is automatically increased to the smallest prime number that is larger than twice the current number of buckets.

Dostawca kodu skrótu ma kody skrótów dla kluczy w Hashtable .The hash code provider dispenses hash codes for keys in the Hashtable. Domyślnym dostawcą kodu skrótu jest implementacja klucza Object.GetHashCode .The default hash code provider is the key's implementation of Object.GetHashCode.

Funkcja porównująca określa, czy dwa klucze są równe.The comparer determines whether two keys are equal. Każdy klucz w a Hashtable musi być unikatowy.Every key in a Hashtable must be unique. Domyślna funkcja porównująca jest implementacją klucza Object.Equals .The default comparer is the key's implementation of Object.Equals.

Niestandardowy dostawca kodu skrótu i niestandardowa funkcja porównująca umożliwiają tworzenie scenariuszy, takich jak wyszukiwanie za pomocą ciągów bez uwzględniania wielkości liter.The custom hash code provider and the custom comparer enable scenarios such as doing lookups with case-insensitive strings.

Ten konstruktor jest O(n) operacją, gdzie n jest capacity parametrem.This constructor is an O(n) operation, where n is the capacity parameter.

Zobacz też

Dotyczy

Produkt Introduced

Hashtable(IDictionary, Single, IEqualityComparer)

Inicjuje nowe wystąpienie Hashtable klasy przez skopiowanie elementów z określonego słownika do nowego Hashtable obiektu.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. Nowy Hashtable obiekt ma początkową pojemność równą liczbie skopiowanych elementów i używa określonego współczynnika obciążenia i IEqualityComparer obiektu.The new Hashtable object has an initial capacity equal to the number of elements copied, and uses the specified load factor and IEqualityComparer object.

public:
 Hashtable(System::Collections::IDictionary ^ d, float loadFactor, System::Collections::IEqualityComparer ^ equalityComparer);
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)

Parametry

d
IDictionary

IDictionaryObiekt, który ma zostać skopiowany do nowego Hashtable obiektu.The IDictionary object to copy to a new Hashtable object.

loadFactor
Single

Liczba z zakresu od 0,1 do 1,0, pomnożona przez wartość domyślną, która zapewnia najlepszą wydajność.A number in the range from 0.1 through 1.0 that is multiplied by the default value which provides the best performance. Wynikiem jest maksymalny stosunek elementów do zasobników.The result is the maximum ratio of elements to buckets.

equalityComparer
IEqualityComparer

IEqualityComparerObiekt, który definiuje dostawcę kodu skrótu i moduł porównujący do użycia z Hashtable .The IEqualityComparer object that defines the hash code provider and the comparer to use with the Hashtable.

-lub--or- nullAby użyć domyślnego dostawcy kodu skrótu i domyślnej wartości porównującej.null to use the default hash code provider and the default comparer. Domyślny dostawca kodu skrótu jest implementacją każdego klucza GetHashCode() i domyślną wartością porównującą jest implementacja każdego klucza Equals(Object) .The default hash code provider is each key's implementation of GetHashCode() and the default comparer is each key's implementation of Equals(Object).

Wyjątki

d to null.d is null.

loadFactorjest mniejsza niż 0,1.loadFactor is less than 0.1.

-lub--or- loadFactorjest większa niż 1,0.loadFactor is greater than 1.0.

Przykłady

Poniższy przykład kodu tworzy tabele skrótów przy użyciu różnych Hashtable konstruktorów i pokazuje różnice w zachowaniu tabel skrótów, nawet jeśli każda z nich zawiera te same elementy.The following code example creates hash tables using different Hashtable constructors and demonstrates the differences in the behavior of the hash tables, even if each one contains the same elements.

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

Uwagi

Początkowa pojemność jest ustawiona na liczbę elementów w słowniku źródłowym.The initial capacity is set to the number of elements in the source dictionary. Pojemność jest automatycznie zwiększana zgodnie z wymaganiami w zależności od współczynnika obciążenia.Capacity is automatically increased as required based on the load factor.

Współczynnik obciążenia to maksymalny stosunek elementów do zasobników.The load factor is the maximum ratio of elements to buckets. Mniejszy współczynnik obciążenia oznacza szybsze wyszukiwanie przy kosztach zwiększonego zużycia pamięci.A smaller load factor means faster lookup at the cost of increased memory consumption. Współczynnik obciążenia 1,0 to Najlepsza równowaga między szybkością i rozmiarem.A load factor of 1.0 is the best balance between speed and size.

Gdy rzeczywisty współczynnik obciążenia osiągnie określony współczynnik obciążenia, liczba przedziałów zostanie automatycznie zwiększona do najmniejszej liczby, która jest większa niż dwukrotnie bieżąca liczba zasobników.When the actual load factor reaches the specified load factor, the number of buckets is automatically increased to the smallest prime number that is larger than twice the current number of buckets.

IEqualityComparerObiekt zawiera zarówno dostawcę kodu skrótu, jak i funkcję porównującą.The IEqualityComparer object includes both the hash code provider and the comparer. Jeśli IEqualityComparer jest używana w Hashtable konstruktorze, obiekty używane jako klucze w Hashtable obiekcie nie są wymagane do przesłania Object.GetHashCode Object.Equals metod i.If an IEqualityComparer is used in the Hashtable constructor, the objects used as keys in the Hashtable object are not required to override the Object.GetHashCode and Object.Equals methods.

Dostawca kodu skrótu ma kody skrótów dla kluczy w Hashtable .The hash code provider dispenses hash codes for keys in the Hashtable. Domyślnym dostawcą kodu skrótu jest implementacja klucza Object.GetHashCode .The default hash code provider is the key's implementation of Object.GetHashCode.

Funkcja porównująca określa, czy dwa klucze są równe.The comparer determines whether two keys are equal. Każdy klucz w a Hashtable musi być unikatowy.Every key in a Hashtable must be unique. Domyślna funkcja porównująca jest implementacją klucza Object.Equals .The default comparer is the key's implementation of Object.Equals.

IEqualityComparerUmożliwia wykonywanie takich scenariuszy, jak wyszukiwanie za pomocą ciągów bez uwzględniania wielkości liter.The IEqualityComparer enables scenarios such as doing lookups with case-insensitive strings.

Elementy nowego Hashtable są sortowane w tej samej kolejności, w której moduł wyliczający iteruje przez IDictionary obiekt.The elements of the new Hashtable are sorted in the same order in which the enumerator iterates through the IDictionary object.

Ten konstruktor jest O(n) operacją, gdzie n jest liczbą elementów w d parametrze.This constructor is an O(n) operation, where n is the number of elements in the d parameter.

Zobacz też

Dotyczy

Produkt Introduced

Hashtable(IDictionary, IHashCodeProvider, IComparer)

Przestroga

Please use Hashtable(IDictionary, IEqualityComparer) instead.

Inicjuje nowe wystąpienie Hashtable klasy przez skopiowanie elementów z określonego słownika do nowego Hashtable obiektu.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. Nowy Hashtable obiekt ma początkową pojemność równą liczbie skopiowanych elementów i używa domyślnego współczynnika obciążenia oraz określonego dostawcy kodu skrótu i modułu porównującego.The new Hashtable object has an initial capacity equal to the number of elements copied, and uses the default load factor, and the specified hash code provider and comparer. Ten interfejs API jest nieaktualny.This API is obsolete. Aby zapoznać się z alternatywnym, zobacz Hashtable(IDictionary, IEqualityComparer) .For an alternative, see Hashtable(IDictionary, IEqualityComparer).

public:
 Hashtable(System::Collections::IDictionary ^ d, System::Collections::IHashCodeProvider ^ hcp, System::Collections::IComparer ^ comparer);
public Hashtable (System.Collections.IDictionary? d, System.Collections.IHashCodeProvider hcp, System.Collections.IComparer comparer);
[System.Obsolete("Please use Hashtable(IDictionary, IEqualityComparer) instead.")]
public Hashtable (System.Collections.IDictionary d, System.Collections.IHashCodeProvider hcp, System.Collections.IComparer comparer);
[System.Obsolete("Please use Hashtable(IDictionary, IEqualityComparer) instead.")]
public Hashtable (System.Collections.IDictionary? d, System.Collections.IHashCodeProvider hcp, System.Collections.IComparer comparer);
public Hashtable (System.Collections.IDictionary d, System.Collections.IHashCodeProvider hcp, System.Collections.IComparer comparer);
new System.Collections.Hashtable : System.Collections.IDictionary * System.Collections.IHashCodeProvider * System.Collections.IComparer -> System.Collections.Hashtable
[<System.Obsolete("Please 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)

Parametry

d
IDictionary

IDictionaryObiekt, który ma zostać skopiowany do nowego Hashtable obiektu.The IDictionary object to copy to a new Hashtable object.

hcp
IHashCodeProvider

IHashCodeProviderObiekt, który dostarcza kody skrótów dla wszystkich kluczy w Hashtable .The IHashCodeProvider object that supplies the hash codes for all keys in the Hashtable.

-lub--or- nullAby użyć domyślnego dostawcy kodu skrótu, który jest implementacją każdego klucza GetHashCode() .null to use the default hash code provider, which is each key's implementation of GetHashCode().

comparer
IComparer

IComparerObiekt, który ma zostać użyty do określenia, czy dwa klucze są równe.The IComparer object to use to determine whether two keys are equal.

-lub--or- nullAby użyć domyślnej wartości porównującej, która jest implementacją każdego klucza Equals(Object) .null to use the default comparer, which is each key's implementation of Equals(Object).

Atrybuty

Wyjątki

d to null.d is null.

Przykłady

Poniższy przykład kodu tworzy tabele skrótów przy użyciu różnych Hashtable konstruktorów i pokazuje różnice w zachowaniu tabel skrótów, nawet jeśli każda z nich zawiera te same elementy.The following code example creates hash tables using different Hashtable constructors and demonstrates the differences in the behavior of the hash tables, even if each one contains the same elements.

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

Uwagi

Początkowa pojemność jest ustawiona na liczbę elementów w słowniku źródłowym.The initial capacity is set to the number of elements in the source dictionary. Pojemność jest automatycznie zwiększana zgodnie z wymaganiami w zależności od współczynnika obciążenia.Capacity is automatically increased as required based on the load factor.

Współczynnik obciążenia to maksymalny stosunek elementów do zasobników.The load factor is the maximum ratio of elements to buckets. Mniejszy współczynnik obciążenia oznacza szybsze wyszukiwanie przy kosztach zwiększonego zużycia pamięci.A smaller load factor means faster lookup at the cost of increased memory consumption.

Gdy rzeczywisty współczynnik obciążenia osiągnie określony współczynnik obciążenia, liczba przedziałów zostanie automatycznie zwiększona do najmniejszej liczby, która jest większa niż dwukrotnie bieżąca liczba zasobników.When the actual load factor reaches the specified load factor, the number of buckets is automatically increased to the smallest prime number that is larger than twice the current number of buckets.

Dostawca kodu skrótu ma kody skrótów dla kluczy w Hashtable obiekcie.The hash code provider dispenses hash codes for keys in the Hashtable object. Domyślnym dostawcą kodu skrótu jest implementacja klucza Object.GetHashCode .The default hash code provider is the key's implementation of Object.GetHashCode.

Funkcja porównująca określa, czy dwa klucze są równe.The comparer determines whether two keys are equal. Każdy klucz w a Hashtable musi być unikatowy.Every key in a Hashtable must be unique. Domyślna funkcja porównująca jest implementacją klucza Object.Equals .The default comparer is the key's implementation of Object.Equals.

Niestandardowy dostawca kodu skrótu i niestandardowa funkcja porównująca umożliwiają tworzenie scenariuszy, takich jak wyszukiwanie za pomocą ciągów bez uwzględniania wielkości liter.The custom hash code provider and the custom comparer enable scenarios such as doing lookups with case-insensitive strings.

Elementy nowego Hashtable są sortowane w tej samej kolejności, w której moduł wyliczający iteruje przez IDictionary obiekt.The elements of the new Hashtable are sorted in the same order in which the enumerator iterates through the IDictionary object.

Ten konstruktor jest O(n) operacją, gdzie n jest liczbą elementów w d parametrze.This constructor is an O(n) operation, where n is the number of elements in the d parameter.

Zobacz też

Dotyczy

Produkt Introduced

Hashtable(Int32, Single)

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

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)

Parametry

capacity
Int32

Przybliżona liczba elementów, które Hashtable obiekt może początkowo zawierać.The approximate number of elements that the Hashtable object can initially contain.

loadFactor
Single

Liczba z zakresu od 0,1 do 1,0, pomnożona przez wartość domyślną, która zapewnia najlepszą wydajność.A number in the range from 0.1 through 1.0 that is multiplied by the default value which provides the best performance. Wynikiem jest maksymalny stosunek elementów do zasobników.The result is the maximum ratio of elements to buckets.

Wyjątki

Parametr capacity ma wartość niższą niż zero.capacity is less than zero.

-lub--or- loadFactorjest mniejsza niż 0,1.loadFactor is less than 0.1.

-lub--or- loadFactorjest większa niż 1,0.loadFactor is greater than 1.0.

capacitypowoduje przepełnienie.capacity is causing an overflow.

Przykłady

Poniższy przykład kodu tworzy tabele skrótów przy użyciu różnych Hashtable konstruktorów i pokazuje różnice w zachowaniu tabel skrótów, nawet jeśli każda z nich zawiera te same elementy.The following code example creates hash tables using different Hashtable constructors and demonstrates the differences in the behavior of the hash tables, even if each one contains the same elements.

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

Uwagi

Określenie początkowej pojemności eliminuje konieczność wykonywania wielu operacji zmiany rozmiarów podczas dodawania elementów do Hashtable obiektu.Specifying the initial capacity eliminates the need to perform a number of resizing operations while adding elements to the Hashtable object. Pojemność jest automatycznie zwiększana zgodnie z wymaganiami w zależności od współczynnika obciążenia.Capacity is automatically increased as required based on the load factor.

Współczynnik obciążenia to maksymalny stosunek elementów do zasobników.The load factor is the maximum ratio of elements to buckets. Mniejszy współczynnik obciążenia oznacza szybsze wyszukiwanie przy kosztach zwiększonego zużycia pamięci.A smaller load factor means faster lookup at the cost of increased memory consumption. Współczynnik obciążenia 1,0 to Najlepsza równowaga między szybkością i rozmiarem.A load factor of 1.0 is the best balance between speed and size.

Gdy rzeczywisty współczynnik obciążenia osiągnie określony współczynnik obciążenia, liczba przedziałów zostanie automatycznie zwiększona do najmniejszej liczby, która jest większa niż dwukrotnie bieżąca liczba zasobników.When the actual load factor reaches the specified load factor, the number of buckets is automatically increased to the smallest prime number that is larger than twice the current number of buckets.

Dostawca kodu skrótu ma kody skrótów dla kluczy w Hashtable .The hash code provider dispenses hash codes for keys in the Hashtable. Domyślnym dostawcą kodu skrótu jest implementacja klucza Object.GetHashCode .The default hash code provider is the key's implementation of Object.GetHashCode.

Funkcja porównująca określa, czy dwa klucze są równe.The comparer determines whether two keys are equal. Każdy klucz w a Hashtable musi być unikatowy.Every key in a Hashtable must be unique. Domyślna funkcja porównująca jest implementacją klucza Object.Equals .The default comparer is the key's implementation of Object.Equals.

Ten konstruktor jest O(n) operacją, gdzie n jest capacity parametrem.This constructor is an O(n) operation, where n is the capacity parameter.

Zobacz też

Dotyczy

Produkt Introduced

Hashtable(SerializationInfo, StreamingContext)

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

protected:
 Hashtable(System::Runtime::Serialization::SerializationInfo ^ info, System::Runtime::Serialization::StreamingContext context);
protected Hashtable (System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context);
new System.Collections.Hashtable : System.Runtime.Serialization.SerializationInfo * System.Runtime.Serialization.StreamingContext -> System.Collections.Hashtable
Protected Sub New (info As SerializationInfo, context As StreamingContext)

Parametry

info
SerializationInfo

SerializationInfoObiekt zawierający informacje wymagane do serializacji Hashtable obiektu.A SerializationInfo object containing the information required to serialize the Hashtable object.

context
StreamingContext

StreamingContextObiekt zawierający źródło i miejsce docelowe serializowanego strumienia skojarzonego z Hashtable .A StreamingContext object containing the source and destination of the serialized stream associated with the Hashtable.

Wyjątki

info to null.info is null.

Uwagi

Wydajność tabeli skrótów służy do obliczania optymalnej liczby zasobników tabeli skrótów na podstawie współczynnika obciążenia.A hash table's capacity is used to calculate the optimal number of hash table buckets based on the load factor. Pojemność jest automatycznie zwiększana odpowiednio do potrzeb.Capacity is automatically increased as required.

Współczynnik obciążenia to maksymalny stosunek elementów do zasobników.The load factor is the maximum ratio of elements to buckets. Mniejszy współczynnik obciążenia oznacza szybsze wyszukiwanie przy kosztach zwiększonego zużycia pamięci.A smaller load factor means faster lookup at the cost of increased memory consumption.

Gdy rzeczywisty współczynnik obciążenia osiągnie określony współczynnik obciążenia, liczba przedziałów zostanie automatycznie zwiększona do najmniejszej liczby, która jest większa niż dwukrotnie bieżąca liczba zasobników.When the actual load factor reaches the specified load factor, the number of buckets is automatically increased to the smallest prime number that is larger than twice the current number of buckets.

Dostawca kodu skrótu ma kody skrótów dla kluczy w Hashtable obiekcie.The hash code provider dispenses hash codes for keys in the Hashtable object. Domyślnym dostawcą kodu skrótu jest implementacja klucza Object.GetHashCode .The default hash code provider is the key's implementation of Object.GetHashCode.

Funkcja porównująca określa, czy dwa klucze są równe.The comparer determines whether two keys are equal. Każdy klucz w a Hashtable musi być unikatowy.Every key in a Hashtable must be unique. Domyślna funkcja porównująca jest implementacją klucza Object.Equals .The default comparer is the key's implementation of Object.Equals.

Ten konstruktor jest O(n) operacją, gdzie n is Count .This constructor is an O(n) operation, where n is Count.

Ponieważ Serializacja i deserializacja modułu wyliczającego dla elementu Hashtable może spowodować zmianę kolejności elementów, nie można kontynuować wyliczania bez wywoływania Reset metody.Because serializing and deserializing an enumerator for a Hashtable can cause the elements to become reordered, it is not possible to continue enumeration without calling the Reset method.

Zobacz też

Dotyczy

Produkt Introduced

Hashtable(IHashCodeProvider, IComparer)

Przestroga

Please use Hashtable(IEqualityComparer) instead.

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

public:
 Hashtable(System::Collections::IHashCodeProvider ^ hcp, System::Collections::IComparer ^ comparer);
public Hashtable (System.Collections.IHashCodeProvider hcp, System.Collections.IComparer comparer);
[System.Obsolete("Please use Hashtable(IEqualityComparer) instead.")]
public Hashtable (System.Collections.IHashCodeProvider hcp, System.Collections.IComparer comparer);
new System.Collections.Hashtable : System.Collections.IHashCodeProvider * System.Collections.IComparer -> System.Collections.Hashtable
[<System.Obsolete("Please 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)

Parametry

hcp
IHashCodeProvider

IHashCodeProviderObiekt, który dostarcza kody skrótów dla wszystkich kluczy w Hashtable obiekcie.The IHashCodeProvider object that supplies the hash codes for all keys in the Hashtable object.

-lub--or- nullAby użyć domyślnego dostawcy kodu skrótu, który jest implementacją każdego klucza GetHashCode() .null to use the default hash code provider, which is each key's implementation of GetHashCode().

comparer
IComparer

IComparerObiekt, który ma zostać użyty do określenia, czy dwa klucze są równe.The IComparer object to use to determine whether two keys are equal.

-lub--or- nullAby użyć domyślnej wartości porównującej, która jest implementacją każdego klucza Equals(Object) .null to use the default comparer, which is each key's implementation of Equals(Object).

Atrybuty

Przykłady

Poniższy przykład kodu tworzy tabele skrótów przy użyciu różnych Hashtable konstruktorów i pokazuje różnice w zachowaniu tabel skrótów, nawet jeśli każda z nich zawiera te same elementy.The following code example creates hash tables using different Hashtable constructors and demonstrates the differences in the behavior of the hash tables, even if each one contains the same elements.

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

Uwagi

Wydajność tabeli skrótów służy do obliczania optymalnej liczby zasobników tabeli skrótów na podstawie współczynnika obciążenia.A hash table's capacity is used to calculate the optimal number of hash table buckets based on the load factor. Pojemność jest automatycznie zwiększana odpowiednio do potrzeb.Capacity is automatically increased as required.

Współczynnik obciążenia to maksymalny stosunek elementów do zasobników.The load factor is the maximum ratio of elements to buckets. Mniejszy współczynnik obciążenia oznacza szybsze wyszukiwanie przy kosztach zwiększonego zużycia pamięci.A smaller load factor means faster lookup at the cost of increased memory consumption.

Gdy rzeczywisty współczynnik obciążenia osiągnie określony współczynnik obciążenia, liczba przedziałów zostanie automatycznie zwiększona do najmniejszej liczby, która jest większa niż dwukrotnie bieżąca liczba zasobników.When the actual load factor reaches the specified load factor, the number of buckets is automatically increased to the smallest prime number that is larger than twice the current number of buckets.

Dostawca kodu skrótu ma kody skrótów dla kluczy w Hashtable obiekcie.The hash code provider dispenses hash codes for keys in the Hashtable object. Domyślnym dostawcą kodu skrótu jest implementacja klucza Object.GetHashCode .The default hash code provider is the key's implementation of Object.GetHashCode.

Funkcja porównująca określa, czy dwa klucze są równe.The comparer determines whether two keys are equal. Każdy klucz w a Hashtable musi być unikatowy.Every key in a Hashtable must be unique. Domyślna funkcja porównująca jest implementacją klucza Object.Equals .The default comparer is the key's implementation of Object.Equals.

Niestandardowy dostawca kodu skrótu i niestandardowa funkcja porównująca umożliwiają tworzenie scenariuszy, takich jak wyszukiwanie za pomocą ciągów bez uwzględniania wielkości liter.The custom hash code provider and the custom comparer enable scenarios such as doing lookups with case-insensitive strings.

Ten konstruktor jest O(1) operacją.This constructor is an O(1) operation.

Zobacz też

Dotyczy

Produkt Introduced

Hashtable(IDictionary, Single)

Inicjuje nowe wystąpienie Hashtable klasy przez skopiowanie elementów z określonego słownika do nowego Hashtable obiektu.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. Nowy Hashtable obiekt ma początkową pojemność równą liczbie skopiowanych elementów i używa określonego współczynnika obciążenia oraz domyślnego dostawcy kodu skrótu i programu porównującego.The new Hashtable object has an initial capacity equal to the number of elements copied, and uses the specified load factor, and the default hash code provider and comparer.

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)

Parametry

d
IDictionary

IDictionaryObiekt, który ma zostać skopiowany do nowego Hashtable obiektu.The IDictionary object to copy to a new Hashtable object.

loadFactor
Single

Liczba z zakresu od 0,1 do 1,0, pomnożona przez wartość domyślną, która zapewnia najlepszą wydajność.A number in the range from 0.1 through 1.0 that is multiplied by the default value which provides the best performance. Wynikiem jest maksymalny stosunek elementów do zasobników.The result is the maximum ratio of elements to buckets.

Wyjątki

d to null.d is null.

loadFactorjest mniejsza niż 0,1.loadFactor is less than 0.1.

-lub--or- loadFactorjest większa niż 1,0.loadFactor is greater than 1.0.

Przykłady

Poniższy przykład kodu tworzy tabele skrótów przy użyciu różnych Hashtable konstruktorów i pokazuje różnice w zachowaniu tabel skrótów, nawet jeśli każda z nich zawiera te same elementy.The following code example creates hash tables using different Hashtable constructors and demonstrates the differences in the behavior of the hash tables, even if each one contains the same elements.

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

Uwagi

Początkowa pojemność jest ustawiona na liczbę elementów w słowniku źródłowym.The initial capacity is set to the number of elements in the source dictionary. Pojemność jest automatycznie zwiększana zgodnie z wymaganiami w zależności od współczynnika obciążenia.Capacity is automatically increased as required based on the load factor.

Współczynnik obciążenia to maksymalny stosunek elementów do zasobników.The load factor is the maximum ratio of elements to buckets. Mniejszy współczynnik obciążenia oznacza szybsze wyszukiwanie przy kosztach zwiększonego zużycia pamięci.A smaller load factor means faster lookup at the cost of increased memory consumption. Współczynnik obciążenia 1,0 to Najlepsza równowaga między szybkością i rozmiarem.A load factor of 1.0 is the best balance between speed and size.

Gdy rzeczywisty współczynnik obciążenia osiągnie określony współczynnik obciążenia, liczba przedziałów zostanie automatycznie zwiększona do najmniejszej liczby, która jest większa niż dwukrotnie bieżąca liczba zasobników.When the actual load factor reaches the specified load factor, the number of buckets is automatically increased to the smallest prime number that is larger than twice the current number of buckets.

Dostawca kodu skrótu ma kody skrótów dla kluczy w Hashtable obiekcie.The hash code provider dispenses hash codes for keys in the Hashtable object. Domyślnym dostawcą kodu skrótu jest implementacja klucza Object.GetHashCode .The default hash code provider is the key's implementation of Object.GetHashCode.

Funkcja porównująca określa, czy dwa klucze są równe.The comparer determines whether two keys are equal. Każdy klucz w a Hashtable musi być unikatowy.Every key in a Hashtable must be unique. Domyślna funkcja porównująca jest implementacją klucza Object.Equals .The default comparer is the key's implementation of Object.Equals.

Elementy nowego Hashtable są sortowane w tej samej kolejności, w której moduł wyliczający iteruje przez IDictionary obiekt.The elements of the new Hashtable are sorted in the same order in which the enumerator iterates through the IDictionary object.

Ten konstruktor jest O(n) operacją, gdzie n jest liczbą elementów w d parametrze.This constructor is an O(n) operation, where n is the number of elements in the d parameter.

Zobacz też

Dotyczy

Produkt Introduced

Hashtable(IDictionary, IEqualityComparer)

Inicjuje nowe wystąpienie Hashtable klasy przez skopiowanie elementów z określonego słownika do nowego Hashtable obiektu.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to a new Hashtable object. Nowy Hashtable obiekt ma początkową pojemność równą liczbie skopiowanych elementów i używa domyślnego współczynnika obciążenia i określonego IEqualityComparer obiektu.The new Hashtable object has an initial capacity equal to the number of elements copied, and uses the default load factor and the specified IEqualityComparer object.

public:
 Hashtable(System::Collections::IDictionary ^ d, System::Collections::IEqualityComparer ^ equalityComparer);
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)

Parametry

d
IDictionary

IDictionaryObiekt, który ma zostać skopiowany do nowego Hashtable obiektu.The IDictionary object to copy to a new Hashtable object.

equalityComparer
IEqualityComparer

IEqualityComparerObiekt, który definiuje dostawcę kodu skrótu i moduł porównujący do użycia z Hashtable .The IEqualityComparer object that defines the hash code provider and the comparer to use with the Hashtable.

-lub--or- nullAby użyć domyślnego dostawcy kodu skrótu i domyślnej wartości porównującej.null to use the default hash code provider and the default comparer. Domyślny dostawca kodu skrótu jest implementacją każdego klucza GetHashCode() i domyślną wartością porównującą jest implementacja każdego klucza Equals(Object) .The default hash code provider is each key's implementation of GetHashCode() and the default comparer is each key's implementation of Equals(Object).

Wyjątki

d to null.d is null.

Przykłady

Poniższy przykład kodu tworzy tabele skrótów przy użyciu różnych Hashtable konstruktorów i pokazuje różnice w zachowaniu tabel skrótów, nawet jeśli każda z nich zawiera te same elementy.The following code example creates hash tables using different Hashtable constructors and demonstrates the differences in the behavior of the hash tables, even if each one contains the same elements.

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

Uwagi

Początkowa pojemność jest ustawiona na liczbę elementów w słowniku źródłowym.The initial capacity is set to the number of elements in the source dictionary. Pojemność jest automatycznie zwiększana zgodnie z wymaganiami w zależności od współczynnika obciążenia.Capacity is automatically increased as required based on the load factor.

Współczynnik obciążenia to maksymalny stosunek elementów do zasobników.The load factor is the maximum ratio of elements to buckets. Mniejszy współczynnik obciążenia oznacza szybsze wyszukiwanie przy kosztach zwiększonego zużycia pamięci.A smaller load factor means faster lookup at the cost of increased memory consumption.

Gdy rzeczywisty współczynnik obciążenia osiągnie określony współczynnik obciążenia, liczba przedziałów zostanie automatycznie zwiększona do najmniejszej liczby, która jest większa niż dwukrotnie bieżąca liczba zasobników.When the actual load factor reaches the specified load factor, the number of buckets is automatically increased to the smallest prime number that is larger than twice the current number of buckets.

IEqualityComparerObiekt zawiera zarówno dostawcę kodu skrótu, jak i funkcję porównującą.The IEqualityComparer object includes both the hash code provider and the comparer. Jeśli IEqualityComparer jest używana w Hashtable konstruktorze, obiekty używane jako klucze w Hashtable obiekcie nie są wymagane do przesłania Object.GetHashCode Object.Equals metod i.If an IEqualityComparer is used in the Hashtable constructor, the objects used as keys in the Hashtable object are not required to override the Object.GetHashCode and Object.Equals methods.

Dostawca kodu skrótu ma kody skrótów dla kluczy w Hashtable .The hash code provider dispenses hash codes for keys in the Hashtable. Domyślnym dostawcą kodu skrótu jest implementacja klucza Object.GetHashCode .The default hash code provider is the key's implementation of Object.GetHashCode.

Funkcja porównująca określa, czy dwa klucze są równe.The comparer determines whether two keys are equal. Każdy klucz w a Hashtable musi być unikatowy.Every key in a Hashtable must be unique. Domyślna funkcja porównująca jest implementacją klucza Object.Equals .The default comparer is the key's implementation of Object.Equals.

IEqualityComparerUmożliwia wykonywanie takich scenariuszy, jak wyszukiwanie za pomocą ciągów bez uwzględniania wielkości liter.The IEqualityComparer enables scenarios such as doing lookups with case-insensitive strings.

Elementy nowego Hashtable są sortowane w tej samej kolejności, w której moduł wyliczający iteruje przez IDictionary obiekt.The elements of the new Hashtable are sorted in the same order in which the enumerator iterates through the IDictionary object.

Ten konstruktor jest O(n) operacją, gdzie n jest liczbą elementów w d parametrze.This constructor is an O(n) operation, where n is the number of elements in the d parameter.

Zobacz też

Dotyczy

Produkt Introduced

Hashtable(Int32)

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

public:
 Hashtable(int capacity);
public Hashtable (int capacity);
new System.Collections.Hashtable : int -> System.Collections.Hashtable
Public Sub New (capacity As Integer)

Parametry

capacity
Int32

Przybliżona liczba elementów, które Hashtable obiekt może początkowo zawierać.The approximate number of elements that the Hashtable object can initially contain.

Wyjątki

Parametr capacity ma wartość niższą niż zero.capacity is less than zero.

Przykłady

Poniższy przykład kodu tworzy tabele skrótów przy użyciu różnych Hashtable konstruktorów i pokazuje różnice w zachowaniu tabel skrótów, nawet jeśli każda z nich zawiera te same elementy.The following code example creates hash tables using different Hashtable constructors and demonstrates the differences in the behavior of the hash tables, even if each one contains the same elements.

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

Uwagi

Określenie początkowej pojemności eliminuje konieczność wykonywania wielu operacji zmiany rozmiarów podczas dodawania elementów do Hashtable obiektu.Specifying the initial capacity eliminates the need to perform a number of resizing operations while adding elements to the Hashtable object. Pojemność jest automatycznie zwiększana zgodnie z wymaganiami w zależności od współczynnika obciążenia.Capacity is automatically increased as required based on the load factor.

Współczynnik obciążenia to maksymalny stosunek elementów do zasobników.The load factor is the maximum ratio of elements to buckets. Mniejszy współczynnik obciążenia oznacza szybsze wyszukiwanie przy kosztach zwiększonego zużycia pamięci.A smaller load factor means faster lookup at the cost of increased memory consumption.

Gdy rzeczywisty współczynnik obciążenia osiągnie określony współczynnik obciążenia, liczba przedziałów zostanie automatycznie zwiększona do najmniejszej liczby, która jest większa niż dwukrotnie bieżąca liczba zasobników.When the actual load factor reaches the specified load factor, the number of buckets is automatically increased to the smallest prime number that is larger than twice the current number of buckets.

Dostawca kodu skrótu ma kody skrótów dla kluczy w Hashtable .The hash code provider dispenses hash codes for keys in the Hashtable. Domyślnym dostawcą kodu skrótu jest implementacja klucza Object.GetHashCode .The default hash code provider is the key's implementation of Object.GetHashCode.

Funkcja porównująca określa, czy dwa klucze są równe.The comparer determines whether two keys are equal. Każdy klucz w a Hashtable musi być unikatowy.Every key in a Hashtable must be unique. Domyślna funkcja porównująca jest implementacją klucza Object.Equals .The default comparer is the key's implementation of Object.Equals.

Ten konstruktor jest O(n) operacją, gdzie n is capacity .This constructor is an O(n) operation, where n is capacity.

Zobacz też

Dotyczy

Produkt Introduced

Hashtable(IEqualityComparer)

Inicjuje nowe, puste wystąpienie Hashtable klasy przy użyciu domyślnej początkowej pojemności i współczynnika obciążenia oraz określonego IEqualityComparer obiektu.Initializes a new, empty instance of the Hashtable class using the default initial capacity and load factor, and the specified IEqualityComparer object.

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)

Parametry

equalityComparer
IEqualityComparer

IEqualityComparerObiekt, który definiuje dostawcę kodu skrótu i moduł porównujący, który ma być używany z Hashtable obiektem.The IEqualityComparer object that defines the hash code provider and the comparer to use with the Hashtable object.

-lub--or- nullAby użyć domyślnego dostawcy kodu skrótu i domyślnej wartości porównującej.null to use the default hash code provider and the default comparer. Domyślny dostawca kodu skrótu jest implementacją każdego klucza GetHashCode() i domyślną wartością porównującą jest implementacja każdego klucza Equals(Object) .The default hash code provider is each key's implementation of GetHashCode() and the default comparer is each key's implementation of Equals(Object).

Przykłady

Poniższy przykład kodu tworzy tabele skrótów przy użyciu różnych Hashtable konstruktorów i pokazuje różnice w zachowaniu tabel skrótów, nawet jeśli każda z nich zawiera te same elementy.The following code example creates hash tables using different Hashtable constructors and demonstrates the differences in the behavior of the hash tables, even if each one contains the same elements.

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

Uwagi

Wydajność tabeli skrótów służy do obliczania optymalnej liczby zasobników tabeli skrótów na podstawie współczynnika obciążenia.A hash table's capacity is used to calculate the optimal number of hash table buckets based on the load factor. Pojemność jest automatycznie zwiększana odpowiednio do potrzeb.Capacity is automatically increased as required.

Współczynnik obciążenia to maksymalny stosunek elementów do zasobników.The load factor is the maximum ratio of elements to buckets. Mniejszy współczynnik obciążenia oznacza szybsze wyszukiwanie przy kosztach zwiększonego zużycia pamięci.A smaller load factor means faster lookup at the cost of increased memory consumption.

Gdy rzeczywisty współczynnik obciążenia osiągnie określony współczynnik obciążenia, liczba przedziałów zostanie automatycznie zwiększona do najmniejszej liczby, która jest większa niż dwukrotnie bieżąca liczba zasobników.When the actual load factor reaches the specified load factor, the number of buckets is automatically increased to the smallest prime number that is larger than twice the current number of buckets.

IEqualityComparerObiekt zawiera zarówno dostawcę kodu skrótu, jak i funkcję porównującą.The IEqualityComparer object includes both the hash code provider and the comparer. Jeśli IEqualityComparer jest używana w Hashtable konstruktorze, obiekty używane jako klucze w Hashtable obiekcie nie są wymagane do przesłania Object.GetHashCode Object.Equals metod i.If an IEqualityComparer is used in the Hashtable constructor, the objects used as keys in the Hashtable object are not required to override the Object.GetHashCode and Object.Equals methods.

Dostawca kodu skrótu ma kody skrótów dla kluczy w Hashtable .The hash code provider dispenses hash codes for keys in the Hashtable. Domyślnym dostawcą kodu skrótu jest implementacja klucza Object.GetHashCode .The default hash code provider is the key's implementation of Object.GetHashCode.

Funkcja porównująca określa, czy dwa klucze są równe.The comparer determines whether two keys are equal. Każdy klucz w a Hashtable musi być unikatowy.Every key in a Hashtable must be unique. Domyślna funkcja porównująca jest implementacją klucza Object.Equals .The default comparer is the key's implementation of Object.Equals.

IEqualityComparerUmożliwia wykonywanie takich scenariuszy, jak wyszukiwanie za pomocą ciągów bez uwzględniania wielkości liter.The IEqualityComparer enables scenarios such as doing lookups with case-insensitive strings.

Ten konstruktor jest O(1) operacją.This constructor is an O(1) operation.

Zobacz też

Dotyczy

Produkt Introduced

Hashtable(IDictionary)

Inicjuje nowe wystąpienie Hashtable klasy przez skopiowanie elementów z określonego słownika do nowego Hashtable obiektu.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. Nowy Hashtable obiekt ma początkową pojemność równą liczbie skopiowanych elementów i używa domyślnego współczynnika ładowania, dostawcy kodu skrótu i programu porównującego.The new Hashtable object has an initial capacity equal to the number of elements copied, and uses the default load factor, hash code provider, and comparer.

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)

Parametry

d
IDictionary

IDictionaryObiekt, który ma zostać skopiowany do nowego Hashtable obiektu.The IDictionary object to copy to a new Hashtable object.

Wyjątki

d to null.d is null.

Przykłady

Poniższy przykład kodu tworzy tabele skrótów przy użyciu różnych Hashtable konstruktorów i pokazuje różnice w zachowaniu tabel skrótów, nawet jeśli każda z nich zawiera te same elementy.The following code example creates hash tables using different Hashtable constructors and demonstrates the differences in the behavior of the hash tables, even if each one contains the same elements.

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

Uwagi

Początkowa pojemność jest ustawiona na liczbę elementów w słowniku źródłowym.The initial capacity is set to the number of elements in the source dictionary. Pojemność jest automatycznie zwiększana zgodnie z wymaganiami w zależności od współczynnika obciążenia.Capacity is automatically increased as required based on the load factor.

Współczynnik obciążenia to maksymalny stosunek elementów do zasobników.The load factor is the maximum ratio of elements to buckets. Mniejszy współczynnik obciążenia oznacza szybsze wyszukiwanie przy kosztach zwiększonego zużycia pamięci.A smaller load factor means faster lookup at the cost of increased memory consumption.

Gdy rzeczywisty współczynnik obciążenia osiągnie określony współczynnik obciążenia, liczba przedziałów zostanie automatycznie zwiększona do najmniejszej liczby, która jest większa niż dwukrotnie bieżąca liczba zasobników.When the actual load factor reaches the specified load factor, the number of buckets is automatically increased to the smallest prime number that is larger than twice the current number of buckets.

Dostawca kodu skrótu ma kody skrótów dla kluczy w Hashtable obiekcie.The hash code provider dispenses hash codes for keys in the Hashtable object. Domyślnym dostawcą kodu skrótu jest implementacja klucza Object.GetHashCode .The default hash code provider is the key's implementation of Object.GetHashCode.

Funkcja porównująca określa, czy dwa klucze są równe.The comparer determines whether two keys are equal. Każdy klucz w a Hashtable musi być unikatowy.Every key in a Hashtable must be unique. Domyślna funkcja porównująca jest implementacją klucza Object.Equals .The default comparer is the key's implementation of Object.Equals.

Elementy nowego Hashtable są sortowane w tej samej kolejności, w której moduł wyliczający iteruje przez IDictionary obiekt.The elements of the new Hashtable are sorted in the same order in which the enumerator iterates through the IDictionary object.

Ten konstruktor jest O(n) operacją, gdzie n jest liczbą elementów w d parametrze.This constructor is an O(n) operation, where n is the number of elements in the d parameter.

Zobacz też

Dotyczy

Produkt Introduced

Hashtable(Int32, IEqualityComparer)

Inicjuje nowe, puste wystąpienie Hashtable klasy przy użyciu określonej początkowej pojemności i IEqualityComparer i domyślnego współczynnika obciążenia.Initializes a new, empty instance of the Hashtable class using the specified initial capacity and IEqualityComparer, and the default load factor.

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)

Parametry

capacity
Int32

Przybliżona liczba elementów, które Hashtable obiekt może początkowo zawierać.The approximate number of elements that the Hashtable object can initially contain.

equalityComparer
IEqualityComparer

IEqualityComparerObiekt, który definiuje dostawcę kodu skrótu i moduł porównujący do użycia z Hashtable .The IEqualityComparer object that defines the hash code provider and the comparer to use with the Hashtable.

-lub--or- nullAby użyć domyślnego dostawcy kodu skrótu i domyślnej wartości porównującej.null to use the default hash code provider and the default comparer. Domyślny dostawca kodu skrótu jest implementacją każdego klucza GetHashCode() i domyślną wartością porównującą jest implementacja każdego klucza Equals(Object) .The default hash code provider is each key's implementation of GetHashCode() and the default comparer is each key's implementation of Equals(Object).

Wyjątki

Parametr capacity ma wartość niższą niż zero.capacity is less than zero.

Przykłady

Poniższy przykład kodu tworzy tabele skrótów przy użyciu różnych Hashtable konstruktorów i pokazuje różnice w zachowaniu tabel skrótów, nawet jeśli każda z nich zawiera te same elementy.The following code example creates hash tables using different Hashtable constructors and demonstrates the differences in the behavior of the hash tables, even if each one contains the same elements.

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

Uwagi

Określenie początkowej pojemności eliminuje konieczność wykonywania wielu operacji zmiany rozmiarów podczas dodawania elementów do Hashtable obiektu.Specifying the initial capacity eliminates the need to perform a number of resizing operations while adding elements to the Hashtable object. Pojemność jest automatycznie zwiększana zgodnie z wymaganiami w zależności od współczynnika obciążenia.Capacity is automatically increased as required based on the load factor.

Współczynnik obciążenia to maksymalny stosunek elementów do zasobników.The load factor is the maximum ratio of elements to buckets. Mniejszy współczynnik obciążenia oznacza szybsze wyszukiwanie przy kosztach zwiększonego zużycia pamięci.A smaller load factor means faster lookup at the cost of increased memory consumption.

Gdy rzeczywisty współczynnik obciążenia osiągnie określony współczynnik obciążenia, liczba przedziałów zostanie automatycznie zwiększona do najmniejszej liczby, która jest większa niż dwukrotnie bieżąca liczba zasobników.When the actual load factor reaches the specified load factor, the number of buckets is automatically increased to the smallest prime number that is larger than twice the current number of buckets.

IEqualityComparerObiekt zawiera zarówno dostawcę kodu skrótu, jak i funkcję porównującą.The IEqualityComparer object includes both the hash code provider and the comparer. Jeśli IEqualityComparer jest używana w Hashtable konstruktorze, obiekty używane jako klucze w Hashtable nie są wymagane do przesłania Object.GetHashCode Object.Equals metod i.If an IEqualityComparer is used in the Hashtable constructor, the objects used as keys in the Hashtable are not required to override the Object.GetHashCode and Object.Equals methods.

Dostawca kodu skrótu ma kody skrótów dla kluczy w Hashtable .The hash code provider dispenses hash codes for keys in the Hashtable. Domyślnym dostawcą kodu skrótu jest implementacja klucza Object.GetHashCode .The default hash code provider is the key's implementation of Object.GetHashCode.

Funkcja porównująca określa, czy dwa klucze są równe.The comparer determines whether two keys are equal. Każdy klucz w a Hashtable musi być unikatowy.Every key in a Hashtable must be unique. Domyślna funkcja porównująca jest implementacją klucza Object.Equals .The default comparer is the key's implementation of Object.Equals.

IEqualityComparerUmożliwia wykonywanie takich scenariuszy, jak wyszukiwanie za pomocą ciągów bez uwzględniania wielkości liter.The IEqualityComparer enables scenarios such as doing lookups with case-insensitive strings.

Ten konstruktor jest O(n) operacją, gdzie n jest capacity parametrem.This constructor is an O(n) operation, where n is the capacity parameter.

Zobacz też

Dotyczy

Produkt Introduced