Hashtable Constructeurs

public:
 Hashtable();

public Hashtable();

Public Sub New ()

Exemples

L’exemple de code suivant crée des tables de hachage à l’aide de constructeurs différents Hashtable et illustre les différences dans le comportement des tables de hachage, même si chacune contient les mêmes éléments.

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

Remarques

La capacité d’une table de hachage est utilisée pour calculer le nombre optimal de compartiments de table de hachage en fonction du facteur de charge. La capacité est automatiquement augmentée en fonction des besoins.

Le facteur de charge correspond au ratio maximal d’éléments par compartiments. Un facteur de charge plus petit signifie une recherche plus rapide au coût d’une consommation accrue de mémoire.

Lorsque le facteur de charge réel atteint le facteur de charge spécifié, le nombre de compartiments est automatiquement augmenté au plus petit nombre premier supérieur à deux fois le nombre actuel de compartiments.

Le fournisseur de code de hachage distribue des codes de hachage pour les clés dans l’objet Hashtable . Le fournisseur de code de hachage par défaut est l’implémentation de la clé .Object.GetHashCode

Le comparateur détermine si deux clés sont égales. Chaque clé d’un Hashtable doit être unique. Le comparateur par défaut est l’implémentation de la clé de Object.Equals.

Ce constructeur est une O(1) opération.

Voir aussi

• GetHashCode()
• Equals(Object)

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

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

[System.Obsolete("Please use Hashtable(int, float, IEqualityComparer) instead.")]
public Hashtable(int capacity, float loadFactor, System.Collections.IHashCodeProvider hcp, System.Collections.IComparer comparer);

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

[<System.Obsolete("Please use Hashtable(int, float, IEqualityComparer) instead.")>]
new System.Collections.Hashtable : int * single * System.Collections.IHashCodeProvider * System.Collections.IComparer -> System.Collections.Hashtable

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

Paramètres

Attributs

ObsoleteAttribute

Exceptions

Remarques

La spécification de la capacité initiale élimine la nécessité d’effectuer un certain nombre d’opérations de redimensionnement lors de l’ajout d’éléments à l’objet Hashtable . La capacité est automatiquement augmentée en fonction du facteur de charge.

Le facteur de charge correspond au ratio maximal d’éléments par compartiments. Un facteur de charge plus petit signifie une recherche plus rapide au coût d’une consommation accrue de mémoire. Un facteur de charge de 1,0 est le meilleur équilibre entre la vitesse et la taille.

Lorsque le facteur de charge réel atteint le facteur de charge spécifié, le nombre de compartiments est automatiquement augmenté au plus petit nombre premier supérieur à deux fois le nombre actuel de compartiments.

Le fournisseur de codes de hachage distribue les codes de hachage pour les clés dans le Hashtable. Le fournisseur de code de hachage par défaut est l’implémentation de la clé .Object.GetHashCode

Le comparateur détermine si deux clés sont égales. Chaque clé d’un Hashtable doit être unique. Le comparateur par défaut est l’implémentation de la clé de Object.Equals.

Le fournisseur de code de hachage personnalisé et le comparateur personnalisé activent des scénarios tels que l’exécution de recherches avec des chaînes qui ne respectent pas la casse.

Ce constructeur est une O(n) opération, où n est le capacity paramètre.

Voir aussi

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

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

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

[System.Obsolete("Please use Hashtable(IDictionary, float, IEqualityComparer) instead.")]
public Hashtable(System.Collections.IDictionary d, float loadFactor, System.Collections.IHashCodeProvider hcp, System.Collections.IComparer comparer);

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

[<System.Obsolete("Please use Hashtable(IDictionary, float, IEqualityComparer) instead.")>]
new System.Collections.Hashtable : System.Collections.IDictionary * single * System.Collections.IHashCodeProvider * System.Collections.IComparer -> System.Collections.Hashtable

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

Paramètres

Attributs

ObsoleteAttribute

Exceptions

Remarques

La capacité initiale est définie sur le nombre d’éléments dans le dictionnaire source. La capacité est automatiquement augmentée en fonction du facteur de charge.

Le facteur de charge correspond au ratio maximal d’éléments par compartiments. Un facteur de charge plus petit signifie une recherche plus rapide au coût d’une consommation accrue de mémoire. Un facteur de charge de 1,0 est le meilleur équilibre entre la vitesse et la taille.

Lorsque le facteur de charge réel atteint le facteur de charge spécifié, le nombre de compartiments est automatiquement augmenté au plus petit nombre premier supérieur à deux fois le nombre actuel de compartiments.

Le fournisseur de code de hachage distribue des codes de hachage pour les clés dans l’objet Hashtable . Le fournisseur de code de hachage par défaut est l’implémentation de la clé .Object.GetHashCode

Le comparateur détermine si deux clés sont égales. Chaque clé d’un Hashtable doit être unique. Le comparateur par défaut est l’implémentation de la clé de Object.Equals.

Le fournisseur de code de hachage personnalisé et le comparateur personnalisé activent des scénarios tels que l’exécution de recherches avec des chaînes qui ne respectent pas la casse.

Les éléments du nouveau Hashtable sont triés dans le même ordre dans lequel l’énumérateur itère dans l’objet IDictionary .

Ce constructeur est une O(n) opération, où n se trouve le nombre d’éléments dans le d paramètre.

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

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

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

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

Paramètres

Exceptions

Exemples

L’exemple de code suivant crée des tables de hachage à l’aide de constructeurs différents Hashtable et illustre les différences dans le comportement des tables de hachage, même si chacune contient les mêmes éléments.

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

Remarques

La spécification de la capacité initiale élimine la nécessité d’effectuer un certain nombre d’opérations de redimensionnement lors de l’ajout d’éléments à l’objet Hashtable . La capacité est automatiquement augmentée en fonction du facteur de charge.

Le facteur de charge correspond au ratio maximal d’éléments par compartiments. Un facteur de charge plus petit signifie une recherche plus rapide au coût d’une consommation accrue de mémoire. Un facteur de charge de 1,0 est le meilleur équilibre entre la vitesse et la taille.

Lorsque le facteur de charge réel atteint le facteur de charge spécifié, le nombre de compartiments est automatiquement augmenté au plus petit nombre premier supérieur à deux fois le nombre actuel de compartiments.

L’objet IEqualityComparer inclut à la fois le fournisseur de code de hachage et le comparateur. Si un IEqualityComparer élément est utilisé dans le Hashtable constructeur, les objets utilisés en tant que clés ne Hashtable sont pas nécessaires pour remplacer les méthodes et Object.Equals les Object.GetHashCode méthodes.

Le fournisseur de codes de hachage distribue les codes de hachage pour les clés dans le Hashtable. Le fournisseur de code de hachage par défaut est l’implémentation de la clé .Object.GetHashCode

Le comparateur détermine si deux clés sont égales. Chaque clé d’un Hashtable doit être unique. Le comparateur par défaut est l’implémentation de la clé de Object.Equals.

Les IEqualityComparer scénarios permettent de faire des recherches avec des chaînes qui ne respectent pas la casse.

Ce constructeur est une O(n) opération, où n est le capacity paramètre.

Voir aussi

• IEqualityComparer

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

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

[System.Obsolete("Please use Hashtable(int, IEqualityComparer) instead.")]
public Hashtable(int capacity, System.Collections.IHashCodeProvider hcp, System.Collections.IComparer comparer);

new System.Collections.Hashtable : int * System.Collections.IHashCodeProvider * System.Collections.IComparer -> System.Collections.Hashtable

[<System.Obsolete("Please use Hashtable(int, IEqualityComparer) instead.")>]
new System.Collections.Hashtable : int * System.Collections.IHashCodeProvider * System.Collections.IComparer -> System.Collections.Hashtable

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

Paramètres

Attributs

ObsoleteAttribute

Exceptions

Remarques

La spécification de la capacité initiale élimine la nécessité d’effectuer un certain nombre d’opérations de redimensionnement lors de l’ajout d’éléments à l’objet Hashtable . La capacité est automatiquement augmentée en fonction du facteur de charge.

Le facteur de charge correspond au ratio maximal d’éléments par compartiments. Un facteur de charge plus petit signifie une recherche plus rapide au coût d’une consommation accrue de mémoire.

Lorsque le facteur de charge réel atteint le facteur de charge spécifié, le nombre de compartiments est automatiquement augmenté au plus petit nombre premier supérieur à deux fois le nombre actuel de compartiments.

Le fournisseur de codes de hachage distribue les codes de hachage pour les clés dans le Hashtable. Le fournisseur de code de hachage par défaut est l’implémentation de la clé .Object.GetHashCode

Le comparateur détermine si deux clés sont égales. Chaque clé d’un Hashtable doit être unique. Le comparateur par défaut est l’implémentation de la clé de Object.Equals.

Le fournisseur de code de hachage personnalisé et le comparateur personnalisé activent des scénarios tels que l’exécution de recherches avec des chaînes qui ne respectent pas la casse.

Ce constructeur est une O(n) opération, où n est le capacity paramètre.

Voir aussi

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

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

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

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

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

Paramètres

Exceptions

Exemples

L’exemple de code suivant crée des tables de hachage à l’aide de constructeurs différents Hashtable et illustre les différences dans le comportement des tables de hachage, même si chacune contient les mêmes éléments.

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

Remarques

La capacité initiale est définie sur le nombre d’éléments dans le dictionnaire source. La capacité est automatiquement augmentée en fonction du facteur de charge.

Le facteur de charge correspond au ratio maximal d’éléments par compartiments. Un facteur de charge plus petit signifie une recherche plus rapide au coût d’une consommation accrue de mémoire. Un facteur de charge de 1,0 est le meilleur équilibre entre la vitesse et la taille.

Lorsque le facteur de charge réel atteint le facteur de charge spécifié, le nombre de compartiments est automatiquement augmenté au plus petit nombre premier supérieur à deux fois le nombre actuel de compartiments.

L’objet IEqualityComparer inclut à la fois le fournisseur de code de hachage et le comparateur. Si un IEqualityComparer élément est utilisé dans le Hashtable constructeur, les objets utilisés comme clés dans l’objet Hashtable ne sont pas nécessaires pour remplacer les méthodes et Object.Equals les Object.GetHashCode méthodes.

Le fournisseur de codes de hachage distribue les codes de hachage pour les clés dans le Hashtable. Le fournisseur de code de hachage par défaut est l’implémentation de la clé .Object.GetHashCode

Le comparateur détermine si deux clés sont égales. Chaque clé d’un Hashtable doit être unique. Le comparateur par défaut est l’implémentation de la clé de Object.Equals.

Les IEqualityComparer scénarios permettent de faire des recherches avec des chaînes qui ne respectent pas la casse.

Les éléments du nouveau Hashtable sont triés dans le même ordre dans lequel l’énumérateur itère dans l’objet IDictionary .

Ce constructeur est une O(n) opération, où n se trouve le nombre d’éléments dans le d paramètre.

Voir aussi

• IEqualityComparer

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

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

[System.Obsolete("Please use Hashtable(IDictionary, IEqualityComparer) instead.")]
public Hashtable(System.Collections.IDictionary d, System.Collections.IHashCodeProvider hcp, System.Collections.IComparer comparer);

new System.Collections.Hashtable : System.Collections.IDictionary * System.Collections.IHashCodeProvider * System.Collections.IComparer -> System.Collections.Hashtable

[<System.Obsolete("Please use Hashtable(IDictionary, IEqualityComparer) instead.")>]
new System.Collections.Hashtable : System.Collections.IDictionary * System.Collections.IHashCodeProvider * System.Collections.IComparer -> System.Collections.Hashtable

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

Paramètres

Attributs

ObsoleteAttribute

Exceptions

Remarques

La capacité initiale est définie sur le nombre d’éléments dans le dictionnaire source. La capacité est automatiquement augmentée en fonction du facteur de charge.

Le facteur de charge correspond au ratio maximal d’éléments par compartiments. Un facteur de charge plus petit signifie une recherche plus rapide au coût d’une consommation accrue de mémoire.

Lorsque le facteur de charge réel atteint le facteur de charge spécifié, le nombre de compartiments est automatiquement augmenté au plus petit nombre premier supérieur à deux fois le nombre actuel de compartiments.

Le fournisseur de code de hachage distribue des codes de hachage pour les clés dans l’objet Hashtable . Le fournisseur de code de hachage par défaut est l’implémentation de la clé .Object.GetHashCode

Le comparateur détermine si deux clés sont égales. Chaque clé d’un Hashtable doit être unique. Le comparateur par défaut est l’implémentation de la clé de Object.Equals.

Le fournisseur de code de hachage personnalisé et le comparateur personnalisé activent des scénarios tels que l’exécution de recherches avec des chaînes qui ne respectent pas la casse.

Les éléments du nouveau Hashtable sont triés dans le même ordre dans lequel l’énumérateur itère dans l’objet IDictionary .

Ce constructeur est une O(n) opération, où n se trouve le nombre d’éléments dans le d paramètre.

Voir aussi

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

public:
 Hashtable(int capacity, float loadFactor);

public Hashtable(int capacity, float loadFactor);

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

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

Paramètres

Exceptions

Exemples

L’exemple de code suivant crée des tables de hachage à l’aide de constructeurs différents Hashtable et illustre les différences dans le comportement des tables de hachage, même si chacune contient les mêmes éléments.

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

Remarques

La spécification de la capacité initiale élimine la nécessité d’effectuer un certain nombre d’opérations de redimensionnement lors de l’ajout d’éléments à l’objet Hashtable . La capacité est automatiquement augmentée en fonction du facteur de charge.

Le facteur de charge correspond au ratio maximal d’éléments par compartiments. Un facteur de charge plus petit signifie une recherche plus rapide au coût d’une consommation accrue de mémoire. Un facteur de charge de 1,0 est le meilleur équilibre entre la vitesse et la taille.

Lorsque le facteur de charge réel atteint le facteur de charge spécifié, le nombre de compartiments est automatiquement augmenté au plus petit nombre premier supérieur à deux fois le nombre actuel de compartiments.

Le fournisseur de codes de hachage distribue les codes de hachage pour les clés dans le Hashtable. Le fournisseur de code de hachage par défaut est l’implémentation de la clé .Object.GetHashCode

Le comparateur détermine si deux clés sont égales. Chaque clé d’un Hashtable doit être unique. Le comparateur par défaut est l’implémentation de la clé de Object.Equals.

Ce constructeur est une O(n) opération, où n est le capacity paramètre.

Voir aussi

• GetHashCode()
• Equals(Object)

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

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

new System.Collections.Hashtable : System.Runtime.Serialization.SerializationInfo * System.Runtime.Serialization.StreamingContext -> System.Collections.Hashtable

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

Paramètres

Exceptions

Remarques

La capacité d’une table de hachage est utilisée pour calculer le nombre optimal de compartiments de table de hachage en fonction du facteur de charge. La capacité est automatiquement augmentée en fonction des besoins.

Le facteur de charge correspond au ratio maximal d’éléments par compartiments. Un facteur de charge plus petit signifie une recherche plus rapide au coût d’une consommation accrue de mémoire.

Lorsque le facteur de charge réel atteint le facteur de charge spécifié, le nombre de compartiments est automatiquement augmenté au plus petit nombre premier supérieur à deux fois le nombre actuel de compartiments.

Le fournisseur de code de hachage distribue des codes de hachage pour les clés dans l’objet Hashtable . Le fournisseur de code de hachage par défaut est l’implémentation de la clé .Object.GetHashCode

Le comparateur détermine si deux clés sont égales. Chaque clé d’un Hashtable doit être unique. Le comparateur par défaut est l’implémentation de la clé de Object.Equals.

Ce constructeur est une O(n) opération, où n est Count.

Étant donné que la sérialisation et la désérialisation d’un énumérateur pour un Hashtable peut entraîner la réorganisation des éléments, il n’est pas possible de continuer l’énumération sans appeler la Reset méthode.

Voir aussi

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

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

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

[System.Obsolete("Please use Hashtable(IEqualityComparer) instead.")]
public Hashtable(System.Collections.IHashCodeProvider hcp, System.Collections.IComparer comparer);

new System.Collections.Hashtable : System.Collections.IHashCodeProvider * System.Collections.IComparer -> System.Collections.Hashtable

[<System.Obsolete("Please use Hashtable(IEqualityComparer) instead.")>]
new System.Collections.Hashtable : System.Collections.IHashCodeProvider * System.Collections.IComparer -> System.Collections.Hashtable

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

Paramètres

Attributs

ObsoleteAttribute

Remarques

La capacité d’une table de hachage est utilisée pour calculer le nombre optimal de compartiments de table de hachage en fonction du facteur de charge. La capacité est automatiquement augmentée en fonction des besoins.

Le facteur de charge correspond au ratio maximal d’éléments par compartiments. Un facteur de charge plus petit signifie une recherche plus rapide au coût d’une consommation accrue de mémoire.

Lorsque le facteur de charge réel atteint le facteur de charge spécifié, le nombre de compartiments est automatiquement augmenté au plus petit nombre premier supérieur à deux fois le nombre actuel de compartiments.

Le fournisseur de code de hachage distribue des codes de hachage pour les clés dans l’objet Hashtable . Le fournisseur de code de hachage par défaut est l’implémentation de la clé .Object.GetHashCode

Le comparateur détermine si deux clés sont égales. Chaque clé d’un Hashtable doit être unique. Le comparateur par défaut est l’implémentation de la clé de Object.Equals.

Le fournisseur de code de hachage personnalisé et le comparateur personnalisé activent des scénarios tels que l’exécution de recherches avec des chaînes qui ne respectent pas la casse.

Ce constructeur est une O(1) opération.

Voir aussi

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

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

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

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

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

Paramètres

Exceptions

Exemples

L’exemple de code suivant crée des tables de hachage à l’aide de constructeurs différents Hashtable et illustre les différences dans le comportement des tables de hachage, même si chacune contient les mêmes éléments.

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

Remarques

La capacité initiale est définie sur le nombre d’éléments dans le dictionnaire source. La capacité est automatiquement augmentée en fonction du facteur de charge.

Le facteur de charge correspond au ratio maximal d’éléments par compartiments. Un facteur de charge plus petit signifie une recherche plus rapide au coût d’une consommation accrue de mémoire. Un facteur de charge de 1,0 est le meilleur équilibre entre la vitesse et la taille.

Lorsque le facteur de charge réel atteint le facteur de charge spécifié, le nombre de compartiments est automatiquement augmenté au plus petit nombre premier supérieur à deux fois le nombre actuel de compartiments.

Le fournisseur de code de hachage distribue des codes de hachage pour les clés dans l’objet Hashtable . Le fournisseur de code de hachage par défaut est l’implémentation de la clé .Object.GetHashCode

Le comparateur détermine si deux clés sont égales. Chaque clé d’un Hashtable doit être unique. Le comparateur par défaut est l’implémentation de la clé de Object.Equals.

Les éléments du nouveau Hashtable sont triés dans le même ordre dans lequel l’énumérateur itère dans l’objet IDictionary .

Ce constructeur est une O(n) opération, où n se trouve le nombre d’éléments dans le d paramètre.

Voir aussi

• IDictionary
• GetHashCode()
• Equals(Object)

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

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

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

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

Paramètres

Exceptions

Exemples

L’exemple de code suivant crée des tables de hachage à l’aide de constructeurs différents Hashtable et illustre les différences dans le comportement des tables de hachage, même si chacune contient les mêmes éléments.

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

Remarques

La capacité initiale est définie sur le nombre d’éléments dans le dictionnaire source. La capacité est automatiquement augmentée en fonction du facteur de charge.

Le facteur de charge correspond au ratio maximal d’éléments par compartiments. Un facteur de charge plus petit signifie une recherche plus rapide au coût d’une consommation accrue de mémoire.

Lorsque le facteur de charge réel atteint le facteur de charge spécifié, le nombre de compartiments est automatiquement augmenté au plus petit nombre premier supérieur à deux fois le nombre actuel de compartiments.

L’objet IEqualityComparer inclut à la fois le fournisseur de code de hachage et le comparateur. Si un IEqualityComparer élément est utilisé dans le Hashtable constructeur, les objets utilisés comme clés dans l’objet Hashtable ne sont pas nécessaires pour remplacer les méthodes et Object.Equals les Object.GetHashCode méthodes.

Le fournisseur de codes de hachage distribue les codes de hachage pour les clés dans le Hashtable. Le fournisseur de code de hachage par défaut est l’implémentation de la clé .Object.GetHashCode

Le comparateur détermine si deux clés sont égales. Chaque clé d’un Hashtable doit être unique. Le comparateur par défaut est l’implémentation de la clé de Object.Equals.

Les IEqualityComparer scénarios permettent de faire des recherches avec des chaînes qui ne respectent pas la casse.

Les éléments du nouveau Hashtable sont triés dans le même ordre dans lequel l’énumérateur itère dans l’objet IDictionary .

Ce constructeur est une O(n) opération, où n se trouve le nombre d’éléments dans le d paramètre.

Voir aussi

• IDictionary
• IEqualityComparer

public:
 Hashtable(int capacity);

public Hashtable(int capacity);

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

Public Sub New (capacity As Integer)

Paramètres

Exceptions

Exemples

L’exemple de code suivant crée des tables de hachage à l’aide de constructeurs différents Hashtable et illustre les différences dans le comportement des tables de hachage, même si chacune contient les mêmes éléments.

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

Remarques

La spécification de la capacité initiale élimine la nécessité d’effectuer un certain nombre d’opérations de redimensionnement lors de l’ajout d’éléments à l’objet Hashtable . La capacité est automatiquement augmentée en fonction du facteur de charge.

Le facteur de charge correspond au ratio maximal d’éléments par compartiments. Un facteur de charge plus petit signifie une recherche plus rapide au coût d’une consommation accrue de mémoire.

Lorsque le facteur de charge réel atteint le facteur de charge spécifié, le nombre de compartiments est automatiquement augmenté au plus petit nombre premier supérieur à deux fois le nombre actuel de compartiments.

Le fournisseur de codes de hachage distribue les codes de hachage pour les clés dans le Hashtable. Le fournisseur de code de hachage par défaut est l’implémentation de la clé .Object.GetHashCode

Le comparateur détermine si deux clés sont égales. Chaque clé d’un Hashtable doit être unique. Le comparateur par défaut est l’implémentation de la clé de Object.Equals.

Ce constructeur est une O(n) opération, où n est capacity.

Voir aussi

• GetHashCode()
• Equals(Object)

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

public Hashtable(System.Collections.IEqualityComparer equalityComparer);

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

Public Sub New (equalityComparer As IEqualityComparer)

Paramètres

Exemples

L’exemple de code suivant crée des tables de hachage à l’aide de constructeurs différents Hashtable et illustre les différences dans le comportement des tables de hachage, même si chacune contient les mêmes éléments.

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

Remarques

La capacité d’une table de hachage est utilisée pour calculer le nombre optimal de compartiments de table de hachage en fonction du facteur de charge. La capacité est automatiquement augmentée en fonction des besoins.

Le facteur de charge correspond au ratio maximal d’éléments par compartiments. Un facteur de charge plus petit signifie une recherche plus rapide au coût d’une consommation accrue de mémoire.

Lorsque le facteur de charge réel atteint le facteur de charge spécifié, le nombre de compartiments est automatiquement augmenté au plus petit nombre premier supérieur à deux fois le nombre actuel de compartiments.

L’objet IEqualityComparer inclut à la fois le fournisseur de code de hachage et le comparateur. Si un IEqualityComparer élément est utilisé dans le Hashtable constructeur, les objets utilisés comme clés dans l’objet Hashtable ne sont pas nécessaires pour remplacer les méthodes et Object.Equals les Object.GetHashCode méthodes.

Le fournisseur de codes de hachage distribue les codes de hachage pour les clés dans le Hashtable. Le fournisseur de code de hachage par défaut est l’implémentation de la clé .Object.GetHashCode

Le comparateur détermine si deux clés sont égales. Chaque clé d’un Hashtable doit être unique. Le comparateur par défaut est l’implémentation de la clé de Object.Equals.

Les IEqualityComparer scénarios permettent de faire des recherches avec des chaînes qui ne respectent pas la casse.

Ce constructeur est une O(1) opération.

Voir aussi

• IEqualityComparer

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

public Hashtable(System.Collections.IDictionary d);

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

Public Sub New (d As IDictionary)

Paramètres

Exceptions

Exemples

L’exemple de code suivant crée des tables de hachage à l’aide de constructeurs différents Hashtable et illustre les différences dans le comportement des tables de hachage, même si chacune contient les mêmes éléments.

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

Remarques

La capacité initiale est définie sur le nombre d’éléments dans le dictionnaire source. La capacité est automatiquement augmentée en fonction du facteur de charge.

Le facteur de charge correspond au ratio maximal d’éléments par compartiments. Un facteur de charge plus petit signifie une recherche plus rapide au coût d’une consommation accrue de mémoire.

Lorsque le facteur de charge réel atteint le facteur de charge spécifié, le nombre de compartiments est automatiquement augmenté au plus petit nombre premier supérieur à deux fois le nombre actuel de compartiments.

Le fournisseur de code de hachage distribue des codes de hachage pour les clés dans l’objet Hashtable . Le fournisseur de code de hachage par défaut est l’implémentation de la clé .Object.GetHashCode

Le comparateur détermine si deux clés sont égales. Chaque clé d’un Hashtable doit être unique. Le comparateur par défaut est l’implémentation de la clé de Object.Equals.

Les éléments du nouveau Hashtable sont triés dans le même ordre dans lequel l’énumérateur itère dans l’objet IDictionary .

Ce constructeur est une O(n) opération, où n se trouve le nombre d’éléments dans le d paramètre.

Voir aussi

• IDictionary
• GetHashCode()
• Equals(Object)

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

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

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

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

Paramètres

Exceptions

Exemples

L’exemple de code suivant crée des tables de hachage à l’aide de constructeurs différents Hashtable et illustre les différences dans le comportement des tables de hachage, même si chacune contient les mêmes éléments.

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

Remarques

La spécification de la capacité initiale élimine la nécessité d’effectuer un certain nombre d’opérations de redimensionnement lors de l’ajout d’éléments à l’objet Hashtable . La capacité est automatiquement augmentée en fonction du facteur de charge.

Le facteur de charge correspond au ratio maximal d’éléments par compartiments. Un facteur de charge plus petit signifie une recherche plus rapide au coût d’une consommation accrue de mémoire.

Lorsque le facteur de charge réel atteint le facteur de charge spécifié, le nombre de compartiments est automatiquement augmenté au plus petit nombre premier supérieur à deux fois le nombre actuel de compartiments.

L’objet IEqualityComparer inclut à la fois le fournisseur de code de hachage et le comparateur. Si un IEqualityComparer élément est utilisé dans le Hashtable constructeur, les objets utilisés en tant que clés ne Hashtable sont pas nécessaires pour remplacer les méthodes et Object.Equals les Object.GetHashCode méthodes.

Le fournisseur de codes de hachage distribue les codes de hachage pour les clés dans le Hashtable. Le fournisseur de code de hachage par défaut est l’implémentation de la clé .Object.GetHashCode

Le comparateur détermine si deux clés sont égales. Chaque clé d’un Hashtable doit être unique. Le comparateur par défaut est l’implémentation de la clé de Object.Equals.

Les IEqualityComparer scénarios permettent de faire des recherches avec des chaînes qui ne respectent pas la casse.

Ce constructeur est une O(n) opération, où n est le capacity paramètre.

Voir aussi

• IEqualityComparer