Hashtable Konstruktoren
Definition
Wichtig
Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.
Initialisiert eine neue Instanz der Hashtable-Klasse.
Überlädt
| Hashtable() |
Initialisiert eine neue leere Instanz der Hashtable-Klasse unter Verwendung der anfänglichen Standardkapazität, des Standardlastfaktors, Hashcode-Standardanbieters und des Standardcomparers. |
| Hashtable(Int32, Single, IHashCodeProvider, IComparer) |
Veraltet.
Veraltet.
Initialisiert eine neue leere Instanz der Hashtable-Klasse unter Verwendung der angegebenen Anfangskapazität, des angegebenen Lastfaktors, des angegebenen Hashcode-Anbieters und des angegebenen Comparers. |
| Hashtable(IDictionary, Single, IHashCodeProvider, IComparer) |
Veraltet.
Veraltet.
Initialisiert eine neue Instanz der Hashtable-Klasse durch Kopieren der Elemente aus dem angegebenen Wörterbuch in das neue Hashtable-Objekt. Das neue Hashtable-Objekt besitzt eine Anfangskapazität, die mit der Anzahl der kopierten Elemente identisch ist, und verwendet den angegebenen Lastfaktor, den angegebenen Hashcodeanbieter und den angegebenen Comparer. |
| Hashtable(Int32, Single, IEqualityComparer) |
Initialisiert eine neue leere Instanz der Hashtable-Klasse unter Verwendung der angegebenen Anfangskapazität, des angegebenen Lastfaktors und des angegebenen IEqualityComparer-Objekts. |
| Hashtable(Int32, IHashCodeProvider, IComparer) |
Veraltet.
Veraltet.
Initialisiert eine neue leere Instanz der Hashtable-Klasse unter Verwendung der angegebenen Anfangskapazität, des angegebenen Hashcodeanbieters, des angegebenen Comparers und des Standardlastfaktors. |
| Hashtable(IDictionary, Single, IEqualityComparer) |
Initialisiert eine neue Instanz der Hashtable-Klasse durch Kopieren der Elemente aus dem angegebenen Wörterbuch in das neue Hashtable-Objekt. Das neue Hashtable-Objekt besitzt eine Anfangskapazität, die mit der Anzahl der kopierten Elemente identisch ist, und verwendet den angegebenen Lastfaktor und das angegebene IEqualityComparer-Objekt. |
| Hashtable(IDictionary, IHashCodeProvider, IComparer) |
Veraltet.
Veraltet.
Initialisiert eine neue Instanz der Hashtable-Klasse durch Kopieren der Elemente aus dem angegebenen Wörterbuch in das neue Hashtable-Objekt. Das neue Hashtable-Objekt besitzt eine Anfangskapazität, die mit der Anzahl der kopierten Elemente identisch ist, und verwendet den Standardlastfaktor sowie den angegebenen Hashcodeanbieter und den angegebenen Comparer. Diese API ist veraltet. Eine Alternative finden Sie unter Hashtable(IDictionary, IEqualityComparer). |
| Hashtable(Int32, Single) |
Initialisiert eine neue leere Instanz der Hashtable-Klasse unter Verwendung der angegebenen Anfangskapazität und des Lastfaktors sowie des Hashcode-Standardanbieter und des angegebenen Comparers. |
| Hashtable(SerializationInfo, StreamingContext) |
Veraltet.
Initialisiert eine neue leere Instanz der Hashtable-Klasse, die serialisierbar ist, wobei die angegebenen SerializationInfo-Objekte und die angegebenen StreamingContext-Objekte verwendet werden. |
| Hashtable(IHashCodeProvider, IComparer) |
Veraltet.
Veraltet.
Veraltet.
Initialisiert eine neue leere Instanz der Hashtable-Klasse unter Verwendung der anfänglichen Standardkapazität, des Standardlastfaktors, des angegebenen Hashcodeanbieters und des angegebenen Comparers. |
| Hashtable(IDictionary, Single) |
Initialisiert eine neue Instanz der Hashtable-Klasse durch Kopieren der Elemente aus dem angegebenen Wörterbuch in das neue Hashtable-Objekt. Das neue Hashtable-Objekt besitzt eine Anfangskapazität, die mit der Anzahl der kopierten Elemente identisch ist, und verwendet den angegebenen Lastfaktor sowie den Hashcode-Standardanbieter und den Standardcomparer. |
| Hashtable(IDictionary, IEqualityComparer) |
Initialisiert eine neue Instanz der Hashtable-Klasse durch Kopieren der Elemente aus dem angegebenen Wörterbuch in ein neues Hashtable-Objekt. Das neue Hashtable-Objekt besitzt eine Anfangskapazität, die mit der Anzahl der kopierten Elemente identisch ist, und verwendet den Standardlastfaktor sowie das angegebene IEqualityComparer-Objekt. |
| Hashtable(Int32) |
Initialisiert eine neue leere Instanz der Hashtable-Klasse unter Verwendung der angegebenen Anfangskapazität, des Standardlastfaktors, des Hashcode-Standardanbieters und des Standardcomparers. |
| Hashtable(IEqualityComparer) |
Initialisiert eine neue leere Instanz der Hashtable-Klasse unter Verwendung der anfänglichen Standardkapazität, des Standardlastfaktors und des angegebenen IEqualityComparer-Objekts. |
| Hashtable(IDictionary) |
Initialisiert eine neue Instanz der Hashtable-Klasse durch Kopieren der Elemente aus dem angegebenen Wörterbuch in das neue Hashtable-Objekt. Das neue Hashtable-Objekt besitzt eine Anfangskapazität, die mit der Anzahl der kopierten Elemente identisch ist, und verwendet den Standardlastfaktor, den Hashcode-Standardanbieter und den Standardcomparer. |
| Hashtable(Int32, IEqualityComparer) |
Initialisiert eine neue leere Instanz der Hashtable-Klasse unter Verwendung der angegebenen Anfangskapazität und des angegebenen IEqualityComparer sowie des Standardlastfaktors. |
Hashtable()
Initialisiert eine neue leere Instanz der Hashtable-Klasse unter Verwendung der anfänglichen Standardkapazität, des Standardlastfaktors, Hashcode-Standardanbieters und des Standardcomparers.
public:
Hashtable();public Hashtable ();Public Sub New ()Beispiele
Im folgenden Codebeispiel werden Hashtabellen mit unterschiedlichen Hashtable Konstruktoren erstellt und die Unterschiede im Verhalten der Hashtabellen veranschaulicht, auch wenn jede die gleichen Elemente enthält.
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
Hinweise
Die Kapazität einer Hashtabelle wird verwendet, um die optimale Anzahl von Hashtabellen-Buckets basierend auf dem Auslastungsfaktor zu berechnen. Die Kapazität wird bei Bedarf automatisch erhöht.
Der Auslastungsfaktor ist das maximale Verhältnis von Elementen zu Buckets. Ein geringerer Auslastungsfaktor bedeutet eine schnellere Suche nach den Kosten des erhöhten Arbeitsspeicherverbrauchs.
Wenn der tatsächliche Auslastungsfaktor den angegebenen Auslastungsfaktor erreicht, wird die Anzahl der Buckets automatisch auf die kleinste Primzahl erhöht, die größer als das Doppelte der aktuellen Anzahl von Buckets ist.
Der Hashcodeanbieter gibt Hashcodes für Schlüssel im Hashtable -Objekt aus. Der Standard-Hashcodeanbieter ist die Implementierung des Object.GetHashCodeSchlüssels.
Der Vergleich bestimmt, ob zwei Schlüssel gleich sind. Jeder Schlüssel in einem Hashtable muss eindeutig sein. Der Standardvergleich ist die Implementierung des Object.EqualsSchlüssels von .
Dieser Konstruktor ist ein O(1) Vorgang.
Weitere Informationen
Gilt für:
Hashtable(Int32, Single, IHashCodeProvider, IComparer)
Achtung
Please use Hashtable(int, float, IEqualityComparer) instead.
Achtung
This constructor has been deprecated. Use Hashtable(int, float, IEqualityComparer) instead.
Initialisiert eine neue leere Instanz der Hashtable-Klasse unter Verwendung der angegebenen Anfangskapazität, des angegebenen Lastfaktors, des angegebenen Hashcode-Anbieters und des angegebenen Comparers.
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);[System.Obsolete("This constructor has been deprecated. Use Hashtable(int, float, IEqualityComparer) instead.")]
public Hashtable (int capacity, float loadFactor, System.Collections.IHashCodeProvider? hcp, System.Collections.IComparer? comparer);[System.Obsolete("Please use Hashtable(int, float, IEqualityComparer) instead.")]
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.")>]
new System.Collections.Hashtable : int * single * System.Collections.IHashCodeProvider * System.Collections.IComparer -> System.Collections.Hashtable[<System.Obsolete("This constructor has been deprecated. Use Hashtable(int, float, IEqualityComparer) instead.")>]
new System.Collections.Hashtable : int * single * System.Collections.IHashCodeProvider * System.Collections.IComparer -> System.Collections.Hashtablenew System.Collections.Hashtable : int * single * System.Collections.IHashCodeProvider * System.Collections.IComparer -> System.Collections.HashtablePublic Sub New (capacity As Integer, loadFactor As Single, hcp As IHashCodeProvider, comparer As IComparer)Parameter
- loadFactor
- Single
Eine Zahl im Bereich 0,1 bis 1,0, die mit dem Standardwert für die optimale Leistung multipliziert wird. Das Ergebnis ist das maximale Verhältnis von Elementen zu Buckets.
Das IHashCodeProvider-Objekt, das die Hashcodes für alle Schlüssel in der Hashtable bereitstellt.
- oder -
null, wenn der Hashcode-Standardanbieter verwendet werden soll. Dies ist die jeweilige GetHashCode()-Implementierung eines Schlüssels.
- comparer
- IComparer
Das IComparer-Objekt, mit dem ermittelt wird, ob zwei Schlüssel gleich sind.
- oder -
null, wenn der Standardcomparer verwendet werden soll. Dies ist die jeweilige Equals(Object)-Implementierung eines Schlüssels.
- Attribute
Ausnahmen
capacity ist kleiner als Null.
- oder -
loadFactor ist kleiner als 0,1.
- oder -
loadFactor ist größer als 1,0.
Beispiele
Im folgenden Codebeispiel werden Hashtabellen mit unterschiedlichen Hashtable Konstruktoren erstellt und die Unterschiede im Verhalten der Hashtabellen veranschaulicht, auch wenn jede die gleichen Elemente enthält.
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
Hinweise
Wenn Sie die anfängliche Kapazität angeben, müssen Sie beim Hinzufügen von Elementen zum Hashtable Objekt eine Reihe von Größenänderungsvorgängen durchführen. Die Kapazität wird automatisch je nach Bedarf basierend auf dem Auslastungsfaktor erhöht.
Der Auslastungsfaktor ist das maximale Verhältnis von Elementen zu Buckets. Ein geringerer Auslastungsfaktor bedeutet eine schnellere Suche nach den Kosten des erhöhten Arbeitsspeicherverbrauchs. Ein Auslastungsfaktor von 1,0 ist die beste Balance zwischen Geschwindigkeit und Größe.
Wenn der tatsächliche Auslastungsfaktor den angegebenen Auslastungsfaktor erreicht, wird die Anzahl der Buckets automatisch auf die kleinste Primzahl erhöht, die größer als das Doppelte der aktuellen Anzahl von Buckets ist.
Der Hashcodeanbieter gibt Hashcodes für Schlüssel in aus Hashtable. Der Standard-Hashcodeanbieter ist die Implementierung des Object.GetHashCodeSchlüssels.
Der Vergleich bestimmt, ob zwei Schlüssel gleich sind. Jeder Schlüssel in einem Hashtable muss eindeutig sein. Der Standardvergleich ist die Implementierung des Object.EqualsSchlüssels von .
Der benutzerdefinierte Hashcodeanbieter und der benutzerdefinierte Vergleich ermöglichen Szenarien wie das Durchführen von Nachschlagevorgängen mit Zeichenfolgen ohne Beachtung der Groß-/Kleinschreibung.
Dieser Konstruktor ist ein O(n) Vorgang, wobei n der capacity Parameter ist.
Weitere Informationen
Gilt für:
Hashtable(IDictionary, Single, IHashCodeProvider, IComparer)
Achtung
Please use Hashtable(IDictionary, float, IEqualityComparer) instead.
Achtung
This constructor has been deprecated. Use Hashtable(IDictionary, float, IEqualityComparer) instead.
Initialisiert eine neue Instanz der Hashtable-Klasse durch Kopieren der Elemente aus dem angegebenen Wörterbuch in das neue Hashtable-Objekt. Das neue Hashtable-Objekt besitzt eine Anfangskapazität, die mit der Anzahl der kopierten Elemente identisch ist, und verwendet den angegebenen Lastfaktor, den angegebenen Hashcodeanbieter und den angegebenen 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("This constructor has been deprecated. Use Hashtable(IDictionary, float, IEqualityComparer) instead.")]
public Hashtable (System.Collections.IDictionary d, float loadFactor, System.Collections.IHashCodeProvider? hcp, System.Collections.IComparer? comparer);[System.Obsolete("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);[<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[<System.Obsolete("This constructor has been deprecated. Use Hashtable(IDictionary, float, IEqualityComparer) instead.")>]
new System.Collections.Hashtable : System.Collections.IDictionary * single * System.Collections.IHashCodeProvider * System.Collections.IComparer -> System.Collections.Hashtablenew System.Collections.Hashtable : System.Collections.IDictionary * single * System.Collections.IHashCodeProvider * System.Collections.IComparer -> System.Collections.HashtablePublic Sub New (d As IDictionary, loadFactor As Single, hcp As IHashCodeProvider, comparer As IComparer)Parameter
Das IDictionary-Objekt, das in ein neues Hashtable-Objekt kopiert werden soll.
- loadFactor
- Single
Eine Zahl im Bereich 0,1 bis 1,0, die mit dem Standardwert für die optimale Leistung multipliziert wird. Das Ergebnis ist das maximale Verhältnis von Elementen zu Buckets.
Das IHashCodeProvider-Objekt, das die Hashcodes für alle Schlüssel in der Hashtable bereitstellt.
- oder -
null, wenn der Hashcode-Standardanbieter verwendet werden soll. Dies ist die jeweilige GetHashCode()-Implementierung eines Schlüssels.
- comparer
- IComparer
Das IComparer-Objekt, mit dem ermittelt wird, ob zwei Schlüssel gleich sind.
- oder -
null, wenn der Standardcomparer verwendet werden soll. Dies ist die jeweilige Equals(Object)-Implementierung eines Schlüssels.
- Attribute
Ausnahmen
d ist null.
Beispiele
Im folgenden Codebeispiel werden Hashtabellen mit unterschiedlichen Hashtable Konstruktoren erstellt und die Unterschiede im Verhalten der Hashtabellen veranschaulicht, auch wenn jede die gleichen Elemente enthält.
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
Hinweise
Die anfängliche Kapazität wird auf die Anzahl der Elemente im Quellwörterbuch festgelegt. Die Kapazität wird je nach Bedarf basierend auf dem Auslastungsfaktor automatisch erhöht.
Der Auslastungsfaktor ist das maximale Verhältnis von Elementen zu Buckets. Ein geringerer Auslastungsfaktor bedeutet eine schnellere Suche nach den Kosten des erhöhten Arbeitsspeicherverbrauchs. Ein Lastfaktor von 1,0 ist die beste Balance zwischen Geschwindigkeit und Größe.
Wenn der tatsächliche Auslastungsfaktor den angegebenen Auslastungsfaktor erreicht, wird die Anzahl der Buckets automatisch auf die kleinste Primzahl erhöht, die größer als das Doppelte der aktuellen Anzahl von Buckets ist.
Der Hashcodeanbieter gibt Hashcodes für Schlüssel im Hashtable -Objekt aus. Der Standard-Hashcodeanbieter ist die Implementierung des Schlüssels von Object.GetHashCode.
Der Vergleich bestimmt, ob zwei Schlüssel gleich sind. Jeder Schlüssel in einem Hashtable muss eindeutig sein. Der Standardvergleich ist die Implementierung des Schlüssels von Object.Equals.
Der benutzerdefinierte Hashcodeanbieter und der benutzerdefinierte Vergleich ermöglichen Szenarien wie das Durchführen von Nachschlagevorgängen mit Zeichenfolgen ohne Berücksichtigung der Groß-/Kleinschreibung.
Die Elemente des neuen Hashtable werden in derselben Reihenfolge sortiert, in der der Enumerator das IDictionary Objekt durchläuft.
Dieser Konstruktor ist ein O(n) Vorgang, wobei n die Anzahl der Elemente im d Parameter entspricht.
Gilt für:
Hashtable(Int32, Single, IEqualityComparer)
Initialisiert eine neue leere Instanz der Hashtable-Klasse unter Verwendung der angegebenen Anfangskapazität, des angegebenen Lastfaktors und des angegebenen IEqualityComparer-Objekts.
public:
Hashtable(int capacity, float loadFactor, System::Collections::IEqualityComparer ^ equalityComparer);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.HashtablePublic Sub New (capacity As Integer, loadFactor As Single, equalityComparer As IEqualityComparer)Parameter
- loadFactor
- Single
Eine Zahl im Bereich 0,1 bis 1,0, die mit dem Standardwert für die optimale Leistung multipliziert wird. Das Ergebnis ist das maximale Verhältnis von Elementen zu Buckets.
- equalityComparer
- IEqualityComparer
Der IEqualityComparer, der sowohl den Hashcodeanbieter als auch den Comparer zur Verwendung mit der Hashtable definiert.
- oder -
null, um den Hashcode-Standardanbieter und den Standardcomparer zu verwenden. Der Hashcode-Standardanbieter ist die Implementierung von GetHashCode() jedes Schlüssels, und der Standardcomparer ist die Implementierung von Equals(Object) jedes Schlüssels.
Ausnahmen
capacity ist kleiner als Null.
- oder -
loadFactor ist kleiner als 0,1.
- oder -
loadFactor ist größer als 1,0.
Beispiele
Im folgenden Codebeispiel werden Hashtabellen mit unterschiedlichen Hashtable Konstruktoren erstellt und die Unterschiede im Verhalten der Hashtabellen veranschaulicht, auch wenn jede die gleichen Elemente enthält.
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
Hinweise
Das Angeben der anfänglichen Kapazität entfällt die Notwendigkeit, beim Hinzufügen von Elementen zum Hashtable Objekt eine Reihe von Größenänderungsvorgängen durchzuführen. Die Kapazität wird je nach Bedarf basierend auf dem Auslastungsfaktor automatisch erhöht.
Der Auslastungsfaktor ist das maximale Verhältnis von Elementen zu Buckets. Ein geringerer Auslastungsfaktor bedeutet eine schnellere Suche nach den Kosten des erhöhten Arbeitsspeicherverbrauchs. Ein Lastfaktor von 1,0 ist die beste Balance zwischen Geschwindigkeit und Größe.
Wenn der tatsächliche Auslastungsfaktor den angegebenen Auslastungsfaktor erreicht, wird die Anzahl der Buckets automatisch auf die kleinste Primzahl erhöht, die größer als das Doppelte der aktuellen Anzahl von Buckets ist.
Das IEqualityComparer -Objekt enthält sowohl den Hashcodeanbieter als auch den Comparer. Wenn ein IEqualityComparer im Hashtable Konstruktor verwendet wird, sind die als Schlüssel im Hashtable verwendeten Objekte nicht erforderlich, um die Object.GetHashCode Methoden und Object.Equals außer Kraft zu setzen.
Der Hashcodeanbieter gibt Hashcodes für Schlüssel im aus Hashtable. Der Standard-Hashcodeanbieter ist die Implementierung des Schlüssels von Object.GetHashCode.
Der Vergleich bestimmt, ob zwei Schlüssel gleich sind. Jeder Schlüssel in einem Hashtable muss eindeutig sein. Der Standardvergleich ist die Implementierung des Schlüssels von Object.Equals.
Ermöglicht IEqualityComparer Szenarien wie das Durchführen von Nachschlagevorgängen mit Zeichenfolgen ohne Berücksichtigung der Groß-/Kleinschreibung.
Dieser Konstruktor ist ein O(n) Vorgang, wobei n der capacity Parameter ist.
Weitere Informationen
Gilt für:
Hashtable(Int32, IHashCodeProvider, IComparer)
Achtung
Please use Hashtable(int, IEqualityComparer) instead.
Achtung
This constructor has been deprecated. Use Hashtable(int, IEqualityComparer) instead.
Initialisiert eine neue leere Instanz der Hashtable-Klasse unter Verwendung der angegebenen Anfangskapazität, des angegebenen Hashcodeanbieters, des angegebenen Comparers und des Standardlastfaktors.
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);[System.Obsolete("This constructor has been deprecated. Use Hashtable(int, IEqualityComparer) instead.")]
public Hashtable (int capacity, System.Collections.IHashCodeProvider? hcp, System.Collections.IComparer? comparer);[System.Obsolete("Please use Hashtable(int, IEqualityComparer) instead.")]
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.")>]
new System.Collections.Hashtable : int * System.Collections.IHashCodeProvider * System.Collections.IComparer -> System.Collections.Hashtable[<System.Obsolete("This constructor has been deprecated. Use Hashtable(int, IEqualityComparer) instead.")>]
new System.Collections.Hashtable : int * System.Collections.IHashCodeProvider * System.Collections.IComparer -> System.Collections.Hashtablenew System.Collections.Hashtable : int * System.Collections.IHashCodeProvider * System.Collections.IComparer -> System.Collections.HashtablePublic Sub New (capacity As Integer, hcp As IHashCodeProvider, comparer As IComparer)Parameter
Das IHashCodeProvider-Objekt, das die Hashcodes für alle Schlüssel in der Hashtable bereitstellt.
- oder -
null, wenn der Hashcode-Standardanbieter verwendet werden soll. Dies ist die jeweilige GetHashCode()-Implementierung eines Schlüssels.
- comparer
- IComparer
Das IComparer-Objekt, mit dem ermittelt wird, ob zwei Schlüssel gleich sind.
- oder -
null, wenn der Standardcomparer verwendet werden soll. Dies ist die jeweilige Equals(Object)-Implementierung eines Schlüssels.
- Attribute
Ausnahmen
capacity ist kleiner als Null.
Beispiele
Im folgenden Codebeispiel werden Hashtabellen mit unterschiedlichen Hashtable Konstruktoren erstellt und die Unterschiede im Verhalten der Hashtabellen veranschaulicht, auch wenn jede die gleichen Elemente enthält.
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
Hinweise
Das Angeben der anfänglichen Kapazität entfällt die Notwendigkeit, beim Hinzufügen von Elementen zum Hashtable Objekt eine Reihe von Größenänderungsvorgängen durchzuführen. Die Kapazität wird je nach Bedarf basierend auf dem Auslastungsfaktor automatisch erhöht.
Der Auslastungsfaktor ist das maximale Verhältnis von Elementen zu Buckets. Ein geringerer Auslastungsfaktor bedeutet eine schnellere Suche nach den Kosten des erhöhten Arbeitsspeicherverbrauchs.
Wenn der tatsächliche Auslastungsfaktor den angegebenen Auslastungsfaktor erreicht, wird die Anzahl der Buckets automatisch auf die kleinste Primzahl erhöht, die größer als das Doppelte der aktuellen Anzahl von Buckets ist.
Der Hashcodeanbieter gibt Hashcodes für Schlüssel im aus Hashtable. Der Standard-Hashcodeanbieter ist die Implementierung des Schlüssels von Object.GetHashCode.
Der Vergleich bestimmt, ob zwei Schlüssel gleich sind. Jeder Schlüssel in einem Hashtable muss eindeutig sein. Der Standardvergleich ist die Implementierung des Schlüssels von Object.Equals.
Der benutzerdefinierte Hashcodeanbieter und der benutzerdefinierte Vergleich ermöglichen Szenarien wie das Durchführen von Nachschlagevorgängen mit Zeichenfolgen ohne Berücksichtigung der Groß-/Kleinschreibung.
Dieser Konstruktor ist ein O(n) Vorgang, wobei n der capacity Parameter ist.
Weitere Informationen
Gilt für:
Hashtable(IDictionary, Single, IEqualityComparer)
Initialisiert eine neue Instanz der Hashtable-Klasse durch Kopieren der Elemente aus dem angegebenen Wörterbuch in das neue Hashtable-Objekt. Das neue Hashtable-Objekt besitzt eine Anfangskapazität, die mit der Anzahl der kopierten Elemente identisch ist, und verwendet den angegebenen Lastfaktor und das angegebene IEqualityComparer-Objekt.
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.HashtablePublic Sub New (d As IDictionary, loadFactor As Single, equalityComparer As IEqualityComparer)Parameter
Das IDictionary-Objekt, das in ein neues Hashtable-Objekt kopiert werden soll.
- loadFactor
- Single
Eine Zahl im Bereich 0,1 bis 1,0, die mit dem Standardwert für die optimale Leistung multipliziert wird. Das Ergebnis ist das maximale Verhältnis von Elementen zu Buckets.
- equalityComparer
- IEqualityComparer
Der IEqualityComparer, der sowohl den Hashcodeanbieter als auch den Comparer zur Verwendung mit der Hashtable definiert.
- oder -
null, um den Hashcode-Standardanbieter und den Standardcomparer zu verwenden. Der Hashcode-Standardanbieter ist die Implementierung von GetHashCode() jedes Schlüssels, und der Standardcomparer ist die Implementierung von Equals(Object) jedes Schlüssels.
Ausnahmen
d ist null.
Beispiele
Im folgenden Codebeispiel werden Hashtabellen mit unterschiedlichen Hashtable Konstruktoren erstellt und die Unterschiede im Verhalten der Hashtabellen veranschaulicht, auch wenn jede die gleichen Elemente enthält.
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
Hinweise
Die anfängliche Kapazität wird auf die Anzahl der Elemente im Quellwörterbuch festgelegt. Die Kapazität wird je nach Bedarf basierend auf dem Auslastungsfaktor automatisch erhöht.
Der Auslastungsfaktor ist das maximale Verhältnis von Elementen zu Buckets. Ein geringerer Auslastungsfaktor bedeutet eine schnellere Suche nach den Kosten des erhöhten Arbeitsspeicherverbrauchs. Ein Lastfaktor von 1,0 ist die beste Balance zwischen Geschwindigkeit und Größe.
Wenn der tatsächliche Auslastungsfaktor den angegebenen Auslastungsfaktor erreicht, wird die Anzahl der Buckets automatisch auf die kleinste Primzahl erhöht, die größer als das Doppelte der aktuellen Anzahl von Buckets ist.
Das IEqualityComparer -Objekt enthält sowohl den Hashcodeanbieter als auch den Comparer. Wenn ein IEqualityComparer im Hashtable Konstruktor verwendet wird, müssen die als Schlüssel im Hashtable -Objekt verwendeten Objekte die Object.GetHashCode Methoden und Object.Equals nicht überschreiben.
Der Hashcodeanbieter gibt Hashcodes für Schlüssel im aus Hashtable. Der Standard-Hashcodeanbieter ist die Implementierung des Schlüssels von Object.GetHashCode.
Der Vergleich bestimmt, ob zwei Schlüssel gleich sind. Jeder Schlüssel in einem Hashtable muss eindeutig sein. Der Standardvergleich ist die Implementierung des Object.EqualsSchlüssels von .
Die IEqualityComparer ermöglicht Szenarien, z. B. Nachschlagevorgänge mit Zeichenfolgen, bei denen die Groß-/Kleinschreibung nicht beachtet wird.
Die Elemente des neuen Hashtable werden in derselben Reihenfolge sortiert, in der der Enumerator das IDictionary Objekt durchlaufen wird.
Dieser Konstruktor ist ein O(n) Vorgang, wobei n die Anzahl der Elemente im d Parameter angegeben ist.
Weitere Informationen
Gilt für:
Hashtable(IDictionary, IHashCodeProvider, IComparer)
Achtung
Please use Hashtable(IDictionary, IEqualityComparer) instead.
Achtung
This constructor has been deprecated. Use Hashtable(IDictionary, IEqualityComparer) instead.
Initialisiert eine neue Instanz der Hashtable-Klasse durch Kopieren der Elemente aus dem angegebenen Wörterbuch in das neue Hashtable-Objekt. Das neue Hashtable-Objekt besitzt eine Anfangskapazität, die mit der Anzahl der kopierten Elemente identisch ist, und verwendet den Standardlastfaktor sowie den angegebenen Hashcodeanbieter und den angegebenen Comparer. Diese API ist veraltet. Eine Alternative finden Sie unter Hashtable(IDictionary, IEqualityComparer).
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("This constructor has been deprecated. Use Hashtable(IDictionary, IEqualityComparer) instead.")]
public Hashtable (System.Collections.IDictionary d, System.Collections.IHashCodeProvider? hcp, System.Collections.IComparer? comparer);[System.Obsolete("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);[<System.Obsolete("Please use Hashtable(IDictionary, IEqualityComparer) instead.")>]
new System.Collections.Hashtable : System.Collections.IDictionary * System.Collections.IHashCodeProvider * System.Collections.IComparer -> System.Collections.Hashtable[<System.Obsolete("This constructor has been deprecated. Use Hashtable(IDictionary, IEqualityComparer) instead.")>]
new System.Collections.Hashtable : System.Collections.IDictionary * System.Collections.IHashCodeProvider * System.Collections.IComparer -> System.Collections.Hashtablenew System.Collections.Hashtable : System.Collections.IDictionary * System.Collections.IHashCodeProvider * System.Collections.IComparer -> System.Collections.HashtablePublic Sub New (d As IDictionary, hcp As IHashCodeProvider, comparer As IComparer)Parameter
Das IDictionary-Objekt, das in ein neues Hashtable-Objekt kopiert werden soll.
Das IHashCodeProvider-Objekt, das die Hashcodes für alle Schlüssel in der Hashtable bereitstellt.
- oder -
null, wenn der Hashcode-Standardanbieter verwendet werden soll. Dies ist die jeweilige GetHashCode()-Implementierung eines Schlüssels.
- comparer
- IComparer
Das IComparer-Objekt, mit dem ermittelt wird, ob zwei Schlüssel gleich sind.
- oder -
null, wenn der Standardcomparer verwendet werden soll. Dies ist die jeweilige Equals(Object)-Implementierung eines Schlüssels.
- Attribute
Ausnahmen
d ist null.
Beispiele
Im folgenden Codebeispiel werden Hashtabellen mit unterschiedlichen Hashtable Konstruktoren erstellt und die Unterschiede im Verhalten der Hashtabellen veranschaulicht, auch wenn jede die gleichen Elemente enthält.
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
Hinweise
Die anfängliche Kapazität ist auf die Anzahl der Elemente im Quellwörterbuch festgelegt. Die Kapazität wird automatisch je nach Bedarf basierend auf dem Auslastungsfaktor erhöht.
Der Auslastungsfaktor ist das maximale Verhältnis von Elementen zu Buckets. Ein geringerer Auslastungsfaktor bedeutet eine schnellere Suche nach den Kosten des erhöhten Arbeitsspeicherverbrauchs.
Wenn der tatsächliche Auslastungsfaktor den angegebenen Auslastungsfaktor erreicht, wird die Anzahl der Buckets automatisch auf die kleinste Primzahl erhöht, die größer als das Doppelte der aktuellen Anzahl von Buckets ist.
Der Hashcodeanbieter gibt Hashcodes für Schlüssel im Hashtable -Objekt aus. Der Standard-Hashcodeanbieter ist die Implementierung des Object.GetHashCodeSchlüssels.
Der Vergleich bestimmt, ob zwei Schlüssel gleich sind. Jeder Schlüssel in einem Hashtable muss eindeutig sein. Der Standardvergleich ist die Implementierung des Object.EqualsSchlüssels von .
Der benutzerdefinierte Hashcodeanbieter und der benutzerdefinierte Vergleich ermöglichen Szenarien wie das Durchführen von Nachschlagevorgängen mit Zeichenfolgen ohne Beachtung der Groß-/Kleinschreibung.
Die Elemente des neuen Hashtable werden in derselben Reihenfolge sortiert, in der der Enumerator das IDictionary Objekt durchlaufen wird.
Dieser Konstruktor ist ein O(n) Vorgang, wobei n die Anzahl der Elemente im d Parameter angegeben ist.
Weitere Informationen
Gilt für:
Hashtable(Int32, Single)
Initialisiert eine neue leere Instanz der Hashtable-Klasse unter Verwendung der angegebenen Anfangskapazität und des Lastfaktors sowie des Hashcode-Standardanbieter und des angegebenen Comparers.
public:
Hashtable(int capacity, float loadFactor);public Hashtable (int capacity, float loadFactor);new System.Collections.Hashtable : int * single -> System.Collections.HashtablePublic Sub New (capacity As Integer, loadFactor As Single)Parameter
- loadFactor
- Single
Eine Zahl im Bereich 0,1 bis 1,0, die mit dem Standardwert für die optimale Leistung multipliziert wird. Das Ergebnis ist das maximale Verhältnis von Elementen zu Buckets.
Ausnahmen
capacity ist kleiner als Null.
- oder -
loadFactor ist kleiner als 0,1.
- oder -
loadFactor ist größer als 1,0.
capacity verursacht einen Überlauf.
Beispiele
Im folgenden Codebeispiel werden Hashtabellen mit unterschiedlichen Hashtable Konstruktoren erstellt und die Unterschiede im Verhalten der Hashtabellen veranschaulicht, auch wenn jede die gleichen Elemente enthält.
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
Hinweise
Wenn Sie die anfängliche Kapazität angeben, müssen Sie beim Hinzufügen von Elementen zum Hashtable Objekt eine Reihe von Größenänderungsvorgängen durchführen. Die Kapazität wird automatisch je nach Bedarf basierend auf dem Auslastungsfaktor erhöht.
Der Auslastungsfaktor ist das maximale Verhältnis von Elementen zu Buckets. Ein geringerer Auslastungsfaktor bedeutet eine schnellere Suche nach den Kosten des erhöhten Arbeitsspeicherverbrauchs. Ein Auslastungsfaktor von 1,0 ist die beste Balance zwischen Geschwindigkeit und Größe.
Wenn der tatsächliche Auslastungsfaktor den angegebenen Auslastungsfaktor erreicht, wird die Anzahl der Buckets automatisch auf die kleinste Primzahl erhöht, die größer als das Doppelte der aktuellen Anzahl von Buckets ist.
Der Hashcodeanbieter gibt Hashcodes für Schlüssel in aus Hashtable. Der Standard-Hashcodeanbieter ist die Implementierung des Object.GetHashCodeSchlüssels.
Der Vergleich bestimmt, ob zwei Schlüssel gleich sind. Jeder Schlüssel in einem Hashtable muss eindeutig sein. Der Standardvergleich ist die Implementierung des Object.EqualsSchlüssels von .
Dieser Konstruktor ist ein O(n) Vorgang, wobei n der capacity Parameter ist.
Weitere Informationen
Gilt für:
Hashtable(SerializationInfo, StreamingContext)
Achtung
This API supports obsolete formatter-based serialization. It should not be called or extended by application code.
Initialisiert eine neue leere Instanz der Hashtable-Klasse, die serialisierbar ist, wobei die angegebenen SerializationInfo-Objekte und die angegebenen StreamingContext-Objekte verwendet werden.
protected:
Hashtable(System::Runtime::Serialization::SerializationInfo ^ info, System::Runtime::Serialization::StreamingContext context);protected Hashtable (System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context);[System.Obsolete("This API supports obsolete formatter-based serialization. It should not be called or extended by application code.", DiagnosticId="SYSLIB0051", UrlFormat="https://aka.ms/dotnet-warnings/{0}")]
protected Hashtable (System.Runtime.Serialization.SerializationInfo info, System.Runtime.Serialization.StreamingContext context);new System.Collections.Hashtable : System.Runtime.Serialization.SerializationInfo * System.Runtime.Serialization.StreamingContext -> System.Collections.Hashtable[<System.Obsolete("This API supports obsolete formatter-based serialization. It should not be called or extended by application code.", DiagnosticId="SYSLIB0051", UrlFormat="https://aka.ms/dotnet-warnings/{0}")>]
new System.Collections.Hashtable : System.Runtime.Serialization.SerializationInfo * System.Runtime.Serialization.StreamingContext -> System.Collections.HashtableProtected Sub New (info As SerializationInfo, context As StreamingContext)Parameter
- info
- SerializationInfo
Ein SerializationInfo-Objekt mit den zum Serialisieren des Hashtable-Objekts erforderlichen Informationen.
- context
- StreamingContext
Ein StreamingContext-Objekt mit der Quelle und dem Ziel des entsprechenden serialisierten Streams für Hashtable.
- Attribute
Ausnahmen
info ist null.
Hinweise
Die Kapazität einer Hashtabelle wird verwendet, um die optimale Anzahl von Hashtabellen-Buckets basierend auf dem Auslastungsfaktor zu berechnen. Die Kapazität wird bei Bedarf automatisch erhöht.
Der Auslastungsfaktor ist das maximale Verhältnis von Elementen zu Buckets. Ein geringerer Auslastungsfaktor bedeutet eine schnellere Suche nach den Kosten des erhöhten Arbeitsspeicherverbrauchs.
Wenn der tatsächliche Auslastungsfaktor den angegebenen Auslastungsfaktor erreicht, wird die Anzahl der Buckets automatisch auf die kleinste Primzahl erhöht, die größer als das Doppelte der aktuellen Anzahl von Buckets ist.
Der Hashcodeanbieter gibt Hashcodes für Schlüssel im Hashtable -Objekt aus. Der Standard-Hashcodeanbieter ist die Implementierung des Object.GetHashCodeSchlüssels.
Der Vergleich bestimmt, ob zwei Schlüssel gleich sind. Jeder Schlüssel in einem Hashtable muss eindeutig sein. Der Standardvergleich ist die Implementierung des Object.EqualsSchlüssels von .
Dieser Konstruktor ist ein O(n) Vorgang, wobei n ist Count.
Da das Serialisieren und Deserialisieren eines Enumerators für ein Hashtable dazu führen kann, dass die Elemente neu sortiert werden, ist es nicht möglich, die Enumeration fortzusetzen, ohne die Reset -Methode aufzurufen.
Weitere Informationen
- ISerializable
- SerializationInfo
- StreamingContext
- OnDeserialization(Object)
- GetHashCode()
- Equals(Object)
Gilt für:
Hashtable(IHashCodeProvider, IComparer)
Achtung
Please use Hashtable(IEqualityComparer) instead.
Achtung
This constructor has been deprecated. Use Hashtable(IEqualityComparer).
Achtung
This constructor has been deprecated. Use Hashtable(IEqualityComparer) instead.
Initialisiert eine neue leere Instanz der Hashtable-Klasse unter Verwendung der anfänglichen Standardkapazität, des Standardlastfaktors, des angegebenen Hashcodeanbieters und des angegebenen Comparers.
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);[System.Obsolete("This constructor has been deprecated. Use Hashtable(IEqualityComparer).")]
public Hashtable (System.Collections.IHashCodeProvider? hcp, System.Collections.IComparer? comparer);[System.Obsolete("This constructor has been deprecated. Use Hashtable(IEqualityComparer) instead.")]
public Hashtable (System.Collections.IHashCodeProvider? hcp, System.Collections.IComparer? comparer);[System.Obsolete("Please use Hashtable(IEqualityComparer) instead.")]
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.")>]
new System.Collections.Hashtable : System.Collections.IHashCodeProvider * System.Collections.IComparer -> System.Collections.Hashtable[<System.Obsolete("This constructor has been deprecated. Use Hashtable(IEqualityComparer).")>]
new System.Collections.Hashtable : System.Collections.IHashCodeProvider * System.Collections.IComparer -> System.Collections.Hashtable[<System.Obsolete("This constructor has been deprecated. Use Hashtable(IEqualityComparer) instead.")>]
new System.Collections.Hashtable : System.Collections.IHashCodeProvider * System.Collections.IComparer -> System.Collections.Hashtablenew System.Collections.Hashtable : System.Collections.IHashCodeProvider * System.Collections.IComparer -> System.Collections.HashtablePublic Sub New (hcp As IHashCodeProvider, comparer As IComparer)Parameter
Das IHashCodeProvider-Objekt, das die Hashcodes für alle Schlüssel in der Hashtable bereitstellt.
- oder -
null, wenn der Hashcode-Standardanbieter verwendet werden soll. Dies ist die jeweilige GetHashCode()-Implementierung eines Schlüssels.
- comparer
- IComparer
Das IComparer-Objekt, mit dem ermittelt wird, ob zwei Schlüssel gleich sind.
- oder -
null, wenn der Standardcomparer verwendet werden soll. Dies ist die jeweilige Equals(Object)-Implementierung eines Schlüssels.
- Attribute
Beispiele
Im folgenden Codebeispiel werden Hashtabellen mit unterschiedlichen Hashtable Konstruktoren erstellt und die Unterschiede im Verhalten der Hashtabellen veranschaulicht, auch wenn jede die gleichen Elemente enthält.
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
Hinweise
Die Kapazität einer Hashtabelle wird verwendet, um die optimale Anzahl von Hashtabellen-Buckets basierend auf dem Auslastungsfaktor zu berechnen. Die Kapazität wird bei Bedarf automatisch erhöht.
Der Auslastungsfaktor ist das maximale Verhältnis von Elementen zu Buckets. Ein geringerer Auslastungsfaktor bedeutet eine schnellere Suche nach den Kosten des erhöhten Arbeitsspeicherverbrauchs.
Wenn der tatsächliche Auslastungsfaktor den angegebenen Auslastungsfaktor erreicht, wird die Anzahl der Buckets automatisch auf die kleinste Primzahl erhöht, die größer als das Doppelte der aktuellen Anzahl von Buckets ist.
Der Hashcodeanbieter gibt Hashcodes für Schlüssel im Hashtable -Objekt aus. Der Standard-Hashcodeanbieter ist die Implementierung des Object.GetHashCodeSchlüssels.
Der Vergleich bestimmt, ob zwei Schlüssel gleich sind. Jeder Schlüssel in einem Hashtable muss eindeutig sein. Der Standardvergleich ist die Implementierung des Object.EqualsSchlüssels von .
Der benutzerdefinierte Hashcodeanbieter und der benutzerdefinierte Vergleich ermöglichen Szenarien wie das Durchführen von Nachschlagevorgängen mit Zeichenfolgen ohne Beachtung der Groß-/Kleinschreibung.
Dieser Konstruktor ist ein O(1) Vorgang.
Weitere Informationen
Gilt für:
Hashtable(IDictionary, Single)
Initialisiert eine neue Instanz der Hashtable-Klasse durch Kopieren der Elemente aus dem angegebenen Wörterbuch in das neue Hashtable-Objekt. Das neue Hashtable-Objekt besitzt eine Anfangskapazität, die mit der Anzahl der kopierten Elemente identisch ist, und verwendet den angegebenen Lastfaktor sowie den Hashcode-Standardanbieter und den Standardcomparer.
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.HashtablePublic Sub New (d As IDictionary, loadFactor As Single)Parameter
Das IDictionary-Objekt, das in ein neues Hashtable-Objekt kopiert werden soll.
- loadFactor
- Single
Eine Zahl im Bereich 0,1 bis 1,0, die mit dem Standardwert für die optimale Leistung multipliziert wird. Das Ergebnis ist das maximale Verhältnis von Elementen zu Buckets.
Ausnahmen
d ist null.
Beispiele
Im folgenden Codebeispiel werden Hashtabellen mit unterschiedlichen Hashtable Konstruktoren erstellt und die Unterschiede im Verhalten der Hashtabellen veranschaulicht, auch wenn jede die gleichen Elemente enthält.
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
Hinweise
Die anfängliche Kapazität ist auf die Anzahl der Elemente im Quellwörterbuch festgelegt. Die Kapazität wird je nach Bedarf basierend auf dem Auslastungsfaktor automatisch erhöht.
Der Auslastungsfaktor ist das maximale Verhältnis von Elementen zu Buckets. Ein geringerer Auslastungsfaktor bedeutet eine schnellere Suche nach den Kosten des erhöhten Arbeitsspeicherverbrauchs. Ein Lastfaktor von 1,0 ist die beste Balance zwischen Geschwindigkeit und Größe.
Wenn der tatsächliche Auslastungsfaktor den angegebenen Auslastungsfaktor erreicht, wird die Anzahl der Buckets automatisch auf die kleinste Primzahl erhöht, die größer als das Doppelte der aktuellen Anzahl von Buckets ist.
Der Hashcodeanbieter gibt Hashcodes für Schlüssel im Hashtable -Objekt aus. Der Standard-Hashcodeanbieter ist die Implementierung des Schlüssels von Object.GetHashCode.
Der Vergleich bestimmt, ob zwei Schlüssel gleich sind. Jeder Schlüssel in einem Hashtable muss eindeutig sein. Der Standardvergleich ist die Implementierung des Schlüssels von Object.Equals.
Die Elemente des neuen Hashtable werden in derselben Reihenfolge sortiert, in der der Enumerator das IDictionary Objekt durchläuft.
Dieser Konstruktor ist ein O(n) Vorgang, wobei n die Anzahl der Elemente im d Parameter entspricht.
Weitere Informationen
Gilt für:
Hashtable(IDictionary, IEqualityComparer)
Initialisiert eine neue Instanz der Hashtable-Klasse durch Kopieren der Elemente aus dem angegebenen Wörterbuch in ein neues Hashtable-Objekt. Das neue Hashtable-Objekt besitzt eine Anfangskapazität, die mit der Anzahl der kopierten Elemente identisch ist, und verwendet den Standardlastfaktor sowie das angegebene IEqualityComparer-Objekt.
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.HashtablePublic Sub New (d As IDictionary, equalityComparer As IEqualityComparer)Parameter
Das IDictionary-Objekt, das in ein neues Hashtable-Objekt kopiert werden soll.
- equalityComparer
- IEqualityComparer
Der IEqualityComparer, der sowohl den Hashcodeanbieter als auch den Comparer zur Verwendung mit der Hashtable definiert.
- oder -
null, um den Hashcode-Standardanbieter und den Standardcomparer zu verwenden. Der Hashcode-Standardanbieter ist die Implementierung von GetHashCode() jedes Schlüssels, und der Standardcomparer ist die Implementierung von Equals(Object) jedes Schlüssels.
Ausnahmen
d ist null.
Beispiele
Im folgenden Codebeispiel werden Hashtabellen mit unterschiedlichen Hashtable Konstruktoren erstellt und die Unterschiede im Verhalten der Hashtabellen veranschaulicht, auch wenn jede die gleichen Elemente enthält.
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
Hinweise
Die anfängliche Kapazität wird auf die Anzahl der Elemente im Quellwörterbuch festgelegt. Die Kapazität wird je nach Bedarf basierend auf dem Auslastungsfaktor automatisch erhöht.
Der Auslastungsfaktor ist das maximale Verhältnis von Elementen zu Buckets. Ein geringerer Auslastungsfaktor bedeutet eine schnellere Suche nach den Kosten des erhöhten Arbeitsspeicherverbrauchs.
Wenn der tatsächliche Auslastungsfaktor den angegebenen Auslastungsfaktor erreicht, wird die Anzahl der Buckets automatisch auf die kleinste Primzahl erhöht, die größer als das Doppelte der aktuellen Anzahl von Buckets ist.
Das IEqualityComparer -Objekt enthält sowohl den Hashcodeanbieter als auch den Comparer. Wenn ein IEqualityComparer im Hashtable Konstruktor verwendet wird, müssen die als Schlüssel im Hashtable -Objekt verwendeten Objekte die Object.GetHashCode Methoden und Object.Equals nicht überschreiben.
Der Hashcodeanbieter gibt Hashcodes für Schlüssel im aus Hashtable. Der Standard-Hashcodeanbieter ist die Implementierung des Schlüssels von Object.GetHashCode.
Der Vergleich bestimmt, ob zwei Schlüssel gleich sind. Jeder Schlüssel in einem Hashtable muss eindeutig sein. Der Standardvergleich ist die Implementierung des Schlüssels von Object.Equals.
Ermöglicht IEqualityComparer Szenarien wie das Durchführen von Nachschlagevorgängen mit Zeichenfolgen ohne Berücksichtigung der Groß-/Kleinschreibung.
Die Elemente des neuen Hashtable werden in derselben Reihenfolge sortiert, in der der Enumerator das IDictionary Objekt durchläuft.
Dieser Konstruktor ist ein O(n) Vorgang, wobei n die Anzahl der Elemente im d Parameter entspricht.
Weitere Informationen
Gilt für:
Hashtable(Int32)
Initialisiert eine neue leere Instanz der Hashtable-Klasse unter Verwendung der angegebenen Anfangskapazität, des Standardlastfaktors, des Hashcode-Standardanbieters und des Standardcomparers.
public:
Hashtable(int capacity);public Hashtable (int capacity);new System.Collections.Hashtable : int -> System.Collections.HashtablePublic Sub New (capacity As Integer)Parameter
Ausnahmen
capacity ist kleiner als Null.
Beispiele
Im folgenden Codebeispiel werden Hashtabellen mit unterschiedlichen Hashtable Konstruktoren erstellt und die Unterschiede im Verhalten der Hashtabellen veranschaulicht, auch wenn jede die gleichen Elemente enthält.
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
Hinweise
Das Angeben der anfänglichen Kapazität entfällt die Notwendigkeit, beim Hinzufügen von Elementen zum Hashtable Objekt eine Reihe von Größenänderungsvorgängen durchzuführen. Die Kapazität wird je nach Bedarf basierend auf dem Auslastungsfaktor automatisch erhöht.
Der Auslastungsfaktor ist das maximale Verhältnis von Elementen zu Buckets. Ein geringerer Auslastungsfaktor bedeutet eine schnellere Suche nach den Kosten des erhöhten Arbeitsspeicherverbrauchs.
Wenn der tatsächliche Auslastungsfaktor den angegebenen Auslastungsfaktor erreicht, wird die Anzahl der Buckets automatisch auf die kleinste Primzahl erhöht, die größer als das Doppelte der aktuellen Anzahl von Buckets ist.
Der Hashcodeanbieter gibt Hashcodes für Schlüssel im aus Hashtable. Der Standard-Hashcodeanbieter ist die Implementierung des Schlüssels von Object.GetHashCode.
Der Vergleich bestimmt, ob zwei Schlüssel gleich sind. Jeder Schlüssel in einem Hashtable muss eindeutig sein. Der Standardvergleich ist die Implementierung des Schlüssels von Object.Equals.
Dieser Konstruktor ist ein O(n) Vorgang, wobei n ist capacity.
Weitere Informationen
Gilt für:
Hashtable(IEqualityComparer)
Initialisiert eine neue leere Instanz der Hashtable-Klasse unter Verwendung der anfänglichen Standardkapazität, des Standardlastfaktors und des angegebenen IEqualityComparer-Objekts.
public:
Hashtable(System::Collections::IEqualityComparer ^ equalityComparer);public Hashtable (System.Collections.IEqualityComparer equalityComparer);public Hashtable (System.Collections.IEqualityComparer? equalityComparer);new System.Collections.Hashtable : System.Collections.IEqualityComparer -> System.Collections.HashtablePublic Sub New (equalityComparer As IEqualityComparer)Parameter
- equalityComparer
- IEqualityComparer
Der IEqualityComparer, der sowohl den Hashcodeanbieter als auch den Comparer zur Verwendung mit der Hashtable definiert.
- oder -
null, um den Hashcode-Standardanbieter und den Standardcomparer zu verwenden. Der Hashcode-Standardanbieter ist die Implementierung von GetHashCode() jedes Schlüssels, und der Standardcomparer ist die Implementierung von Equals(Object) jedes Schlüssels.
Beispiele
Im folgenden Codebeispiel werden Hashtabellen mit unterschiedlichen Hashtable Konstruktoren erstellt und die Unterschiede im Verhalten der Hashtabellen veranschaulicht, auch wenn jede die gleichen Elemente enthält.
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
Hinweise
Die Kapazität einer Hashtabelle wird verwendet, um die optimale Anzahl von Hashtabellenbuckets basierend auf dem Auslastungsfaktor zu berechnen. Die Kapazität wird bei Bedarf automatisch erhöht.
Der Auslastungsfaktor ist das maximale Verhältnis von Elementen zu Buckets. Ein geringerer Auslastungsfaktor bedeutet eine schnellere Suche nach den Kosten des erhöhten Arbeitsspeicherverbrauchs.
Wenn der tatsächliche Auslastungsfaktor den angegebenen Auslastungsfaktor erreicht, wird die Anzahl der Buckets automatisch auf die kleinste Primzahl erhöht, die größer als das Doppelte der aktuellen Anzahl von Buckets ist.
Das IEqualityComparer -Objekt enthält sowohl den Hashcodeanbieter als auch den Comparer. Wenn ein IEqualityComparer im Hashtable Konstruktor verwendet wird, müssen die als Schlüssel im Hashtable -Objekt verwendeten Objekte die Object.GetHashCode Methoden und Object.Equals nicht überschreiben.
Der Hashcodeanbieter gibt Hashcodes für Schlüssel im aus Hashtable. Der Standard-Hashcodeanbieter ist die Implementierung des Schlüssels von Object.GetHashCode.
Der Vergleich bestimmt, ob zwei Schlüssel gleich sind. Jeder Schlüssel in einem Hashtable muss eindeutig sein. Der Standardvergleich ist die Implementierung des Schlüssels von Object.Equals.
Ermöglicht IEqualityComparer Szenarien wie das Durchführen von Nachschlagevorgängen mit Zeichenfolgen ohne Berücksichtigung der Groß-/Kleinschreibung.
Dieser Konstruktor ist ein O(1) Vorgang.
Weitere Informationen
Gilt für:
Hashtable(IDictionary)
Initialisiert eine neue Instanz der Hashtable-Klasse durch Kopieren der Elemente aus dem angegebenen Wörterbuch in das neue Hashtable-Objekt. Das neue Hashtable-Objekt besitzt eine Anfangskapazität, die mit der Anzahl der kopierten Elemente identisch ist, und verwendet den Standardlastfaktor, den Hashcode-Standardanbieter und den Standardcomparer.
public:
Hashtable(System::Collections::IDictionary ^ d);public Hashtable (System.Collections.IDictionary d);new System.Collections.Hashtable : System.Collections.IDictionary -> System.Collections.HashtablePublic Sub New (d As IDictionary)Parameter
Das IDictionary-Objekt, das in ein neues Hashtable-Objekt kopiert werden soll.
Ausnahmen
d ist null.
Beispiele
Im folgenden Codebeispiel werden Hashtabellen mit unterschiedlichen Hashtable Konstruktoren erstellt und die Unterschiede im Verhalten der Hashtabellen veranschaulicht, auch wenn jede die gleichen Elemente enthält.
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
Hinweise
Die anfängliche Kapazität wird auf die Anzahl der Elemente im Quellwörterbuch festgelegt. Die Kapazität wird je nach Bedarf basierend auf dem Auslastungsfaktor automatisch erhöht.
Der Auslastungsfaktor ist das maximale Verhältnis von Elementen zu Buckets. Ein geringerer Auslastungsfaktor bedeutet eine schnellere Suche nach den Kosten des erhöhten Arbeitsspeicherverbrauchs.
Wenn der tatsächliche Auslastungsfaktor den angegebenen Auslastungsfaktor erreicht, wird die Anzahl der Buckets automatisch auf die kleinste Primzahl erhöht, die größer als das Doppelte der aktuellen Anzahl von Buckets ist.
Der Hashcodeanbieter gibt Hashcodes für Schlüssel im Hashtable -Objekt aus. Der Standard-Hashcodeanbieter ist die Implementierung des Schlüssels von Object.GetHashCode.
Der Vergleich bestimmt, ob zwei Schlüssel gleich sind. Jeder Schlüssel in einem Hashtable muss eindeutig sein. Der Standardvergleich ist die Implementierung des Schlüssels von Object.Equals.
Die Elemente des neuen Hashtable werden in derselben Reihenfolge sortiert, in der der Enumerator das IDictionary Objekt durchläuft.
Dieser Konstruktor ist ein O(n) Vorgang, wobei n die Anzahl der Elemente im d Parameter entspricht.
Weitere Informationen
Gilt für:
Hashtable(Int32, IEqualityComparer)
Initialisiert eine neue leere Instanz der Hashtable-Klasse unter Verwendung der angegebenen Anfangskapazität und des angegebenen IEqualityComparer sowie des Standardlastfaktors.
public:
Hashtable(int capacity, System::Collections::IEqualityComparer ^ equalityComparer);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.HashtablePublic Sub New (capacity As Integer, equalityComparer As IEqualityComparer)Parameter
- equalityComparer
- IEqualityComparer
Der IEqualityComparer, der sowohl den Hashcodeanbieter als auch den Comparer zur Verwendung mit der Hashtable definiert.
- oder -
null, um den Hashcode-Standardanbieter und den Standardcomparer zu verwenden. Der Hashcode-Standardanbieter ist die Implementierung von GetHashCode() jedes Schlüssels, und der Standardcomparer ist die Implementierung von Equals(Object) jedes Schlüssels.
Ausnahmen
capacity ist kleiner als Null.
Beispiele
Im folgenden Codebeispiel werden Hashtabellen mit unterschiedlichen Hashtable Konstruktoren erstellt und die Unterschiede im Verhalten der Hashtabellen veranschaulicht, auch wenn jede die gleichen Elemente enthält.
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
Hinweise
Das Angeben der anfänglichen Kapazität entfällt die Notwendigkeit, beim Hinzufügen von Elementen zum Hashtable Objekt eine Reihe von Größenänderungsvorgängen durchzuführen. Die Kapazität wird je nach Bedarf basierend auf dem Auslastungsfaktor automatisch erhöht.
Der Auslastungsfaktor ist das maximale Verhältnis von Elementen zu Buckets. Ein geringerer Auslastungsfaktor bedeutet eine schnellere Suche nach den Kosten des erhöhten Arbeitsspeicherverbrauchs.
Wenn der tatsächliche Auslastungsfaktor den angegebenen Auslastungsfaktor erreicht, wird die Anzahl der Buckets automatisch auf die kleinste Primzahl erhöht, die größer als das Doppelte der aktuellen Anzahl von Buckets ist.
Das IEqualityComparer -Objekt enthält sowohl den Hashcodeanbieter als auch den Comparer. Wenn ein IEqualityComparer im Hashtable Konstruktor verwendet wird, sind die als Schlüssel im Hashtable verwendeten Objekte nicht erforderlich, um die Object.GetHashCode Methoden und Object.Equals außer Kraft zu setzen.
Der Hashcodeanbieter gibt Hashcodes für Schlüssel in aus Hashtable. Der Standard-Hashcodeanbieter ist die Implementierung des Object.GetHashCodeSchlüssels.
Der Vergleich bestimmt, ob zwei Schlüssel gleich sind. Jeder Schlüssel in einem Hashtable muss eindeutig sein. Der Standardvergleich ist die Implementierung des Object.EqualsSchlüssels von .
Die IEqualityComparer ermöglicht Szenarien, z. B. Nachschlagevorgänge mit Zeichenfolgen, bei denen die Groß-/Kleinschreibung nicht beachtet wird.
Dieser Konstruktor ist ein O(n) Vorgang, wobei n der capacity Parameter ist.
Weitere Informationen
Gilt für:
Feedback
Bald verfügbar: Im Laufe des Jahres 2024 werden wir GitHub-Tickets als Feedbackmechanismus für Inhalte auslaufen lassen und es durch ein neues Feedbacksystem ersetzen. Weitere Informationen finden Sie unter: https://aka.ms/ContentUserFeedback.
Feedback senden und anzeigen für