Hashtable Hashtable Hashtable Hashtable Class

Définition

Représente une collection de paires clé/valeur qui sont organisées en fonction du code de hachage de la clé.Represents a collection of key/value pairs that are organized based on the hash code of the key.

public ref class Hashtable : ICloneable, System::Collections::IDictionary, System::Runtime::Serialization::IDeserializationCallback, System::Runtime::Serialization::ISerializable
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public class Hashtable : ICloneable, System.Collections.IDictionary, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable
type Hashtable = class
    interface IDictionary
    interface ISerializable
    interface IDeserializationCallback
    interface ICloneable
    interface ICollection
    interface IEnumerable
Public Class Hashtable
Implements ICloneable, IDeserializationCallback, IDictionary, ISerializable
Héritage
HashtableHashtableHashtableHashtable
Dérivé
Attributs
Implémente

Exemples

L’exemple suivant montre comment créer, initialiser et exécuter diverses fonctions vers Hashtable et comment imprimer ses clés et ses valeurs.The following example shows how to create, initialize and perform various functions to a Hashtable and how to print out its keys and values.

using namespace System;
using namespace System::Collections;

public ref class Example
{
public:
    static void Main()
    {
        // Create a new hash table.
        //
        Hashtable^ openWith = gcnew Hashtable();
        
        // Add some elements to the hash table. There are no
        // duplicate keys, but some of the values are duplicates.
        openWith->Add("txt", "notepad.exe");
        openWith->Add("bmp", "paint.exe");
        openWith->Add("dib", "paint.exe");
        openWith->Add("rtf", "wordpad.exe");

        // The Add method throws an exception if the new key is 
        // already in the hash table.
        try
        {
            openWith->Add("txt", "winword.exe");
        }
        catch(...)
        {
            Console::WriteLine("An element with Key = \"txt\" already exists.");
        }

        // The Item property is the default property, so you 
        // can omit its name when accessing elements. 
        Console::WriteLine("For key = \"rtf\", value = {0}.", openWith["rtf"]);
        
        // The default Item property can be used to change the value
        // associated with a key.
        openWith["rtf"] = "winword.exe";
        Console::WriteLine("For key = \"rtf\", value = {0}.", openWith["rtf"]);

        // If a key does not exist, setting the default Item property
        // for that key adds a new key/value pair.
        openWith["doc"] = "winword.exe";

        // ContainsKey can be used to test keys before inserting 
        // them.
        if (!openWith->ContainsKey("ht"))
        {
            openWith->Add("ht", "hypertrm.exe");
            Console::WriteLine("Value added for key = \"ht\": {0}", openWith["ht"]);
        }

        // When you use foreach to enumerate hash table elements,
        // the elements are retrieved as KeyValuePair objects.
        Console::WriteLine();
        for each( DictionaryEntry de in openWith )
        {
            Console::WriteLine("Key = {0}, Value = {1}", de.Key, de.Value);
        }

        // To get the values alone, use the Values property.
        ICollection^ valueColl = openWith->Values;
        
        // The elements of the ValueCollection are strongly typed
        // with the type that was specified for hash table values.
        Console::WriteLine();
        for each( String^ s in valueColl )
        {
            Console::WriteLine("Value = {0}", s);
        }

        // To get the keys alone, use the Keys property.
        ICollection^ keyColl = openWith->Keys;
        
        // The elements of the KeyCollection are strongly typed
        // with the type that was specified for hash table keys.
        Console::WriteLine();
        for each( String^ s in keyColl )
        {
            Console::WriteLine("Key = {0}", s);
        }

        // Use the Remove method to remove a key/value pair.
        Console::WriteLine("\nRemove(\"doc\")");
        openWith->Remove("doc");

        if (!openWith->ContainsKey("doc"))
        {
            Console::WriteLine("Key \"doc\" is not found.");
        }
    }
};

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

/* This code example produces the following output:

An element with Key = "txt" already exists.
For key = "rtf", value = wordpad.exe.
For key = "rtf", value = winword.exe.
Value added for key = "ht": hypertrm.exe

Key = dib, Value = paint.exe
Key = txt, Value = notepad.exe
Key = ht, Value = hypertrm.exe
Key = bmp, Value = paint.exe
Key = rtf, Value = winword.exe
Key = doc, Value = winword.exe

Value = paint.exe
Value = notepad.exe
Value = hypertrm.exe
Value = paint.exe
Value = winword.exe
Value = winword.exe

Key = dib
Key = txt
Key = ht
Key = bmp
Key = rtf
Key = doc

Remove("doc")
Key "doc" is not found.
 */
using System;
using System.Collections;

class Example
{
    public static void Main()
    {
        // Create a new hash table.
        //
        Hashtable openWith = new Hashtable();
        
        // Add some elements to the hash table. There are no 
        // duplicate keys, but some of the values are duplicates.
        openWith.Add("txt", "notepad.exe");
        openWith.Add("bmp", "paint.exe");
        openWith.Add("dib", "paint.exe");
        openWith.Add("rtf", "wordpad.exe");
        
        // The Add method throws an exception if the new key is 
        // already in the hash table.
        try
        {
            openWith.Add("txt", "winword.exe");
        }
        catch
        {
            Console.WriteLine("An element with Key = \"txt\" already exists.");
        }

        // The Item property is the default property, so you 
        // can omit its name when accessing elements. 
        Console.WriteLine("For key = \"rtf\", value = {0}.", openWith["rtf"]);
        
        // The default Item property can be used to change the value
        // associated with a key.
        openWith["rtf"] = "winword.exe";
        Console.WriteLine("For key = \"rtf\", value = {0}.", openWith["rtf"]);
        
        // If a key does not exist, setting the default Item property
        // for that key adds a new key/value pair.
        openWith["doc"] = "winword.exe";

        // ContainsKey can be used to test keys before inserting 
        // them.
        if (!openWith.ContainsKey("ht"))
        {
            openWith.Add("ht", "hypertrm.exe");
            Console.WriteLine("Value added for key = \"ht\": {0}", openWith["ht"]);
        }

        // When you use foreach to enumerate hash table elements,
        // the elements are retrieved as KeyValuePair objects.
        Console.WriteLine();
        foreach( DictionaryEntry de in openWith )
        {
            Console.WriteLine("Key = {0}, Value = {1}", de.Key, de.Value);
        }

        // To get the values alone, use the Values property.
        ICollection valueColl = openWith.Values;
        
        // The elements of the ValueCollection are strongly typed
        // with the type that was specified for hash table values.
        Console.WriteLine();
        foreach( string s in valueColl )
        {
            Console.WriteLine("Value = {0}", s);
        }

        // To get the keys alone, use the Keys property.
        ICollection keyColl = openWith.Keys;
        
        // The elements of the KeyCollection are strongly typed
        // with the type that was specified for hash table keys.
        Console.WriteLine();
        foreach( string s in keyColl )
        {
            Console.WriteLine("Key = {0}", s);
        }

        // Use the Remove method to remove a key/value pair.
        Console.WriteLine("\nRemove(\"doc\")");
        openWith.Remove("doc");
        
        if (!openWith.ContainsKey("doc"))
        {
            Console.WriteLine("Key \"doc\" is not found.");
        }
    }
}

/* This code example produces the following output:

An element with Key = "txt" already exists.
For key = "rtf", value = wordpad.exe.
For key = "rtf", value = winword.exe.
Value added for key = "ht": hypertrm.exe

Key = dib, Value = paint.exe
Key = txt, Value = notepad.exe
Key = ht, Value = hypertrm.exe
Key = bmp, Value = paint.exe
Key = rtf, Value = winword.exe
Key = doc, Value = winword.exe

Value = paint.exe
Value = notepad.exe
Value = hypertrm.exe
Value = paint.exe
Value = winword.exe
Value = winword.exe

Key = dib
Key = txt
Key = ht
Key = bmp
Key = rtf
Key = doc

Remove("doc")
Key "doc" is not found.
 */
Imports System
Imports System.Collections

Module Example

    Sub Main()

        ' Create a new hash table.
        '
        Dim openWith As New Hashtable()

        ' Add some elements to the hash table. There are no 
        ' duplicate keys, but some of the values are duplicates.
        openWith.Add("txt", "notepad.exe")
        openWith.Add("bmp", "paint.exe")
        openWith.Add("dib", "paint.exe")
        openWith.Add("rtf", "wordpad.exe")

        ' The Add method throws an exception if the new key is 
        ' already in the hash table.
        Try
            openWith.Add("txt", "winword.exe")
        Catch
            Console.WriteLine("An element with Key = ""txt"" already exists.")
        End Try

        ' The Item property is the default property, so you 
        ' can omit its name when accessing elements. 
        Console.WriteLine("For key = ""rtf"", value = {0}.", _
            openWith("rtf"))

        ' The default Item property can be used to change the value
        ' associated with a key.
        openWith("rtf") = "winword.exe"
        Console.WriteLine("For key = ""rtf"", value = {0}.", _
            openWith("rtf"))

        ' If a key does not exist, setting the default Item property
        ' for that key adds a new key/value pair.
        openWith("doc") = "winword.exe"

        ' ContainsKey can be used to test keys before inserting 
        ' them.
        If Not openWith.ContainsKey("ht") Then
            openWith.Add("ht", "hypertrm.exe")
            Console.WriteLine("Value added for key = ""ht"": {0}", _
                openWith("ht"))
        End If

        ' When you use foreach to enumerate hash table elements,
        ' the elements are retrieved as KeyValuePair objects.
        Console.WriteLine()
        For Each de As DictionaryEntry In openWith
            Console.WriteLine("Key = {0}, Value = {1}", _
                de.Key, de.Value)
        Next de

        ' To get the values alone, use the Values property.
        Dim valueColl As ICollection = openWith.Values

        ' The elements of the ValueCollection are strongly typed
        ' with the type that was specified for hash table values.
        Console.WriteLine()
        For Each s As String In valueColl
            Console.WriteLine("Value = {0}", s)
        Next s

        ' To get the keys alone, use the Keys property.
        Dim keyColl As ICollection = openWith.Keys

        ' The elements of the KeyCollection are strongly typed
        ' with the type that was specified for hash table keys.
        Console.WriteLine()
        For Each s As String In keyColl
            Console.WriteLine("Key = {0}", s)
        Next s

        ' Use the Remove method to remove a key/value pair.
        Console.WriteLine(vbLf + "Remove(""doc"")")
        openWith.Remove("doc")

        If Not openWith.ContainsKey("doc") Then
            Console.WriteLine("Key ""doc"" is not found.")
        End If

    End Sub

End Module

' This code example produces the following output:
'
'An element with Key = "txt" already exists.
'For key = "rtf", value = wordpad.exe.
'For key = "rtf", value = winword.exe.
'Value added for key = "ht": hypertrm.exe
'
'Key = dib, Value = paint.exe
'Key = txt, Value = notepad.exe
'Key = ht, Value = hypertrm.exe
'Key = bmp, Value = paint.exe
'Key = rtf, Value = winword.exe
'Key = doc, Value = winword.exe
'
'Value = paint.exe
'Value = notepad.exe
'Value = hypertrm.exe
'Value = paint.exe
'Value = winword.exe
'Value = winword.exe
'
'Key = dib
'Key = txt
'Key = ht
'Key = bmp
'Key = rtf
'Key = doc
'
'Remove("doc")
'Key "doc" is not found.
# Create new hash table using PowerShell syntax
$OpenWith = @{}

# Add one element to the hash table using the Add method
$OpenWith.Add('txt', 'notepad.exe')

# Add three eleements using PowerShell syntax three different ways
$OpenWith.dib = 'paint.exe'

$KeyBMP = 'bmp'
$OpenWith[$KeyBMP] = 'paint.exe'

$OpenWith += @{'rtf' = 'wordpad.exe'}

# Display hash table
"There are {0} in the `$OpenWith hash table as follows:" -f $OpenWith.Count
''

# Display hashtable properties
'Count of items in the hashtable  : {0}' -f $OpenWith.Count
'Is hashtable fixed size?         : {0}' -f $OpenWith.IsFixedSize
'Is hashtable read-only?          : {0}' -f $OpenWith.IsReadonly
'Is hashtabale synchronised?      : {0}' -f $OpenWith.IsSynchronized
''
'Keys in hashtable:'
$OpenWith.Keys
''
'Values in hashtable:'
$OpenWith.Values
''

<#
This script produces the following output:

There are 4 in the $OpenWith hash table as follows:

Name                           Value                                                                            
----                           -----                                                                            
txt                            notepad.exe                                                                      
dib                            paint.exe                                                                        
bmp                            paint.exe                                                                        
rtf                            wordpad.exe                                                                      

Count of items in the hashtable  : 4
Is hashtable fixed size?         : False
Is hashtable read-only?          : False
Is hashtabale synchronised?      : False

Keys in hashtable:
txt
dib
bmp
rtf

Values in hashtable:
notepad.exe
paint.exe
paint.exe
wordpad.exe
#>

Remarques

Chaque élément est une paire clé/valeur stockée dans DictionaryEntry un objet.Each element is a key/value pair stored in a DictionaryEntry object. Une clé ne peut nullpas être, mais une valeur peut être.A key cannot be null, but a value can be.

Important

Nous vous déconseillons d’utiliser Hashtable la classe pour un nouveau développement.We don't recommend that you use the Hashtable class for new development. Au lieu de cela, nous vous recommandons d' Dictionary<TKey,TValue> utiliser la classe générique.Instead, we recommend that you use the generic Dictionary<TKey,TValue> class. Pour plus d’informations, consultez collections non génériques ne doit pas être utilisé sur GitHub.For more information, see Non-generic collections shouldn't be used on GitHub.

Les objets utilisés comme clés par un Hashtable sont requis pour substituer la Object.GetHashCode méthode (ou l' IHashCodeProvider interface) et la Object.Equals méthode (ou l' IComparer interface).The objects used as keys by a Hashtable are required to override the Object.GetHashCode method (or the IHashCodeProvider interface) and the Object.Equals method (or the IComparer interface). L’implémentation des méthodes et des interfaces doit gérer le respect de la casse de la même façon; dans le cas Hashtable contraire, le risque de se comporter de manière incorrecte.The implementation of both methods and interfaces must handle case sensitivity the same way; otherwise, the Hashtable might behave incorrectly. Par exemple, lors de la Hashtablecréation d’un, vous CaseInsensitiveHashCodeProvider devez utiliser la classe (ou toute implémentation IHashCodeProvider ne respectant pas CaseInsensitiveComparer la casse) avec la classe (ou IComparer toute implémentation ne respectant pas la casse).For example, when creating a Hashtable, you must use the CaseInsensitiveHashCodeProvider class (or any case-insensitive IHashCodeProvider implementation) with the CaseInsensitiveComparer class (or any case-insensitive IComparer implementation).

En outre, ces méthodes doivent produire les mêmes résultats lorsqu’elles sont appelées avec les mêmes paramètres alors que Hashtablela clé existe dans le.Furthermore, these methods must produce the same results when called with the same parameters while the key exists in the Hashtable. Une alternative consiste à utiliser un Hashtable constructeur avec un IEqualityComparer paramètre.An alternative is to use a Hashtable constructor with an IEqualityComparer parameter. Si l’égalité des clés était simplement une égalité de référence, Object.GetHashCode l' Object.Equals implémentation héritée de et suffisait.If key equality were simply reference equality, the inherited implementation of Object.GetHashCode and Object.Equals would suffice.

Les objets clés doivent être immuables tant qu’ils sont utilisés en tant que clés Hashtabledans le.Key objects must be immutable as long as they are used as keys in the Hashtable.

Lorsqu’un élément est ajouté au Hashtable, l’élément est placé dans un compartiment en fonction du code de hachage de la clé.When an element is added to the Hashtable, the element is placed into a bucket based on the hash code of the key. Les recherches ultérieures de la clé utilisent le code de hachage de la clé pour effectuer une recherche dans un seul compartiment particulier, ce qui réduit considérablement le nombre de comparaisons de clés nécessaires pour trouver un élément.Subsequent lookups of the key use the hash code of the key to search in only one particular bucket, thus substantially reducing the number of key comparisons required to find an element.

Le facteur de charge d' Hashtable un détermine le rapport maximal entre les éléments et les compartiments.The load factor of a Hashtable determines the maximum ratio of elements to buckets. Des facteurs de charge plus petits entraînent des temps de recherche moyens plus rapides au détriment de la consommation de mémoire accrue.Smaller load factors cause faster average lookup times at the cost of increased memory consumption. Le facteur de charge par défaut de 1,0 fournit généralement le meilleur équilibre entre la vitesse et la taille.The default load factor of 1.0 generally provides the best balance between speed and size. Un facteur de charge différent peut également être spécifié lors Hashtable de la création du.A different load factor can also be specified when the Hashtable is created.

À mesure que des éléments sont Hashtableajoutés à un, le facteur de Hashtable charge réel de l’augmentation.As elements are added to a Hashtable, the actual load factor of the Hashtable increases. Lorsque le facteur de charge réel atteint le facteur de charge spécifié, le nombre de compartiments dans le Hashtable est automatiquement augmenté au plus petit nombre premier qui est supérieur au double du nombre actuel de Hashtable compartiments.When the actual load factor reaches the specified load factor, the number of buckets in the Hashtable is automatically increased to the smallest prime number that is larger than twice the current number of Hashtable buckets.

Chaque objet clé dans Hashtable doit fournir sa propre fonction de hachage, qui est accessible en appelant. GetHashEach key object in the Hashtable must provide its own hash function, which can be accessed by calling GetHash. Toutefois, tout objet qui IHashCodeProvider implémente peut être passé Hashtable à un constructeur, et cette fonction de hachage est utilisée pour tous les objets de la table.However, any object implementing IHashCodeProvider can be passed to a Hashtable constructor, and that hash function is used for all objects in the table.

La capacité d’un Hashtable est le nombre d’éléments que Hashtable peut contenir.The capacity of a Hashtable is the number of elements the Hashtable can hold. À mesure que des éléments sont Hashtableajoutés à un, la capacité est automatiquement augmentée en fonction des besoins par réallocation.As elements are added to a Hashtable, the capacity is automatically increased as required through reallocation.

.NET Framework uniquement: Pour les objets Hashtable très volumineux, vous pouvez augmenter la capacité maximale à 2 milliards éléments sur un système 64 bits en affectant enabled à true l’attribut <gcAllowVeryLargeObjects> de l’élément de configuration la valeur dans l’environnement d’exécution..NET Framework only: For very large Hashtable objects, you can increase the maximum capacity to 2 billion elements on a 64-bit system by setting the enabled attribute of the <gcAllowVeryLargeObjects> configuration element to true in the run-time environment.

L' foreach instruction de la C# langue (For Each en Visual Basic) retourne un objet du type des éléments de la collection.The foreach statement of the C# language (For Each in Visual Basic) returns an object of the type of the elements in the collection. Étant donné que chaque élément Hashtable de est une paire clé/valeur, le type d’élément n’est pas le type de la clé ou le type de la valeur.Since each element of the Hashtable is a key/value pair, the element type is not the type of the key or the type of the value. Au lieu de cela, le DictionaryEntrytype d’élément est.Instead, the element type is DictionaryEntry. Par exemple :For example:

for each(DictionaryEntry de in myHashtable)
{
    // ...
}
foreach(DictionaryEntry de in myHashtable)
{
    // ...
}
For Each de As DictionaryEntry In myHashtable
    ' ...
Next de

L' foreach instruction est un wrapper autour de l’énumérateur, qui autorise uniquement la lecture, et non l’écriture, de la collection.The foreach statement is a wrapper around the enumerator, which only allows reading from, not writing to, the collection.

Étant donné que la sérialisation et la désérialisation d’un Hashtable énumérateur pour un peuvent entraîner la réorganisation des éléments, il n’est pas possible de continuer l’énumération sans appeler la Reset méthode.Because serializing and deserializing an enumerator for a Hashtable can cause the elements to become reordered, it is not possible to continue enumeration without calling the Reset method.

Notes

Étant donné que les clés peuvent être héritées et que leur comportement a changé, leur unicité absolue ne peut Equals pas être garantie par des comparaisons à l’aide de la méthode.Because keys can be inherited and their behavior changed, their absolute uniqueness cannot be guaranteed by comparisons using the Equals method.

Constructeurs

Hashtable() Hashtable() Hashtable() Hashtable()

Initialise une nouvelle instance vide de la classe Hashtable à l'aide de la capacité initiale, du facteur de charge, du fournisseur de codes de hachage et du comparateur par défaut.Initializes a new, empty instance of the Hashtable class using the default initial capacity, load factor, hash code provider, and comparer.

Hashtable(IDictionary) Hashtable(IDictionary) Hashtable(IDictionary) Hashtable(IDictionary)

Initialise une nouvelle instance de la classe Hashtable en copiant les éléments du dictionnaire spécifié vers le nouvel objet Hashtable.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. Le nouvel objet Hashtable a une capacité initiale égale au nombre d'éléments copiés et utilise le facteur de charge, le fournisseur de codes de hachage et le comparateur par défaut.The new Hashtable object has an initial capacity equal to the number of elements copied, and uses the default load factor, hash code provider, and comparer.

Hashtable(IDictionary, IEqualityComparer) Hashtable(IDictionary, IEqualityComparer) Hashtable(IDictionary, IEqualityComparer) Hashtable(IDictionary, IEqualityComparer)

Initialise une nouvelle instance de la classe Hashtable en copiant les éléments du dictionnaire spécifié vers un nouvel objet Hashtable.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to a new Hashtable object. Le nouvel objet Hashtable a une capacité initiale égale au nombre d'éléments copiés et utilise le facteur de charge par défaut et l'objet IEqualityComparer spécifié.The new Hashtable object has an initial capacity equal to the number of elements copied, and uses the default load factor and the specified IEqualityComparer object.

Hashtable(IDictionary, IHashCodeProvider, IComparer) Hashtable(IDictionary, IHashCodeProvider, IComparer) Hashtable(IDictionary, IHashCodeProvider, IComparer) Hashtable(IDictionary, IHashCodeProvider, IComparer)

Initialise une nouvelle instance de la classe Hashtable en copiant les éléments du dictionnaire spécifié vers le nouvel objet Hashtable.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. Le nouvel objet Hashtable a une capacité initiale égale au nombre d'éléments copiés et utilise le facteur de charge par défaut et le fournisseur de codes de hachage et le comparateur spécifiés.The new Hashtable object has an initial capacity equal to the number of elements copied, and uses the default load factor, and the specified hash code provider and comparer. Cette API est obsolète.This API is obsolete. Pour obtenir une alternative, consultez Hashtable(IDictionary, IEqualityComparer).For an alternative, see Hashtable(IDictionary, IEqualityComparer).

Hashtable(IDictionary, Single) Hashtable(IDictionary, Single) Hashtable(IDictionary, Single) Hashtable(IDictionary, Single)

Initialise une nouvelle instance de la classe Hashtable en copiant les éléments du dictionnaire spécifié vers le nouvel objet Hashtable.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. Le nouvel objet Hashtable a une capacité initiale égale au nombre d'éléments copiés et utilise le facteur de charge spécifié et le fournisseur de codes de hachage et le comparateur par défaut.The new Hashtable object has an initial capacity equal to the number of elements copied, and uses the specified load factor, and the default hash code provider and comparer.

Hashtable(IDictionary, Single, IEqualityComparer) Hashtable(IDictionary, Single, IEqualityComparer) Hashtable(IDictionary, Single, IEqualityComparer) Hashtable(IDictionary, Single, IEqualityComparer)

Initialise une nouvelle instance de la classe Hashtable en copiant les éléments du dictionnaire spécifié vers le nouvel objet Hashtable.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. Le nouvel objet Hashtable a une capacité initiale égale au nombre d'éléments copiés et utilise le facteur de charge et l'objet IEqualityComparer spécifiés.The new Hashtable object has an initial capacity equal to the number of elements copied, and uses the specified load factor and IEqualityComparer object.

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

Initialise une nouvelle instance de la classe Hashtable en copiant les éléments du dictionnaire spécifié vers le nouvel objet Hashtable.Initializes a new instance of the Hashtable class by copying the elements from the specified dictionary to the new Hashtable object. Le nouvel objet Hashtable a une capacité initiale égale au nombre d'éléments copiés et utilise le facteur de charge, le fournisseur de codes de hachage et le comparateur spécifiés.The new Hashtable object has an initial capacity equal to the number of elements copied, and uses the specified load factor, hash code provider, and comparer.

Hashtable(IEqualityComparer) Hashtable(IEqualityComparer) Hashtable(IEqualityComparer) Hashtable(IEqualityComparer)

Initialise une nouvelle instance vide de la classe Hashtable à l'aide de la capacité initiale et du facteur de charge par défaut, et de l'objet IEqualityComparer spécifié.Initializes a new, empty instance of the Hashtable class using the default initial capacity and load factor, and the specified IEqualityComparer object.

Hashtable(IHashCodeProvider, IComparer) Hashtable(IHashCodeProvider, IComparer) Hashtable(IHashCodeProvider, IComparer) Hashtable(IHashCodeProvider, IComparer)

Initialise une nouvelle instance vide de la classe Hashtable à l'aide de la capacité initiale et du facteur de charge par défaut, et du fournisseur de codes de hachage et du comparateur spécifiés.Initializes a new, empty instance of the Hashtable class using the default initial capacity and load factor, and the specified hash code provider and comparer.

Hashtable(Int32) Hashtable(Int32) Hashtable(Int32) Hashtable(Int32)

Initialise une nouvelle instance vide de la classe Hashtable à l'aide de la capacité initiale spécifiée et du facteur de charge, du fournisseur de codes de hachage et du comparateur par défaut.Initializes a new, empty instance of the Hashtable class using the specified initial capacity, and the default load factor, hash code provider, and comparer.

Hashtable(Int32, IEqualityComparer) Hashtable(Int32, IEqualityComparer) Hashtable(Int32, IEqualityComparer) Hashtable(Int32, IEqualityComparer)

Initialise une nouvelle instance vide de la classe Hashtable à l'aide de l'objet IEqualityComparer et de la capacité initiale spécifiés et du facteur de charge par défaut.Initializes a new, empty instance of the Hashtable class using the specified initial capacity and IEqualityComparer, and the default load factor.

Hashtable(Int32, IHashCodeProvider, IComparer) Hashtable(Int32, IHashCodeProvider, IComparer) Hashtable(Int32, IHashCodeProvider, IComparer) Hashtable(Int32, IHashCodeProvider, IComparer)

Initialise une nouvelle instance vide de la classe Hashtable à l'aide de la capacité initiale, du fournisseur de codes de hachage, du comparateur et du facteur de charge par défaut.Initializes a new, empty instance of the Hashtable class using the specified initial capacity, hash code provider, comparer, and the default load factor.

Hashtable(Int32, Single) Hashtable(Int32, Single) Hashtable(Int32, Single) Hashtable(Int32, Single)

Initialise une nouvelle instance vide de la classe Hashtable à l'aide de la capacité initiale et du facteur de charge spécifiés, et du fournisseur de codes de hachage et du comparateur par défaut.Initializes a new, empty instance of the Hashtable class using the specified initial capacity and load factor, and the default hash code provider and comparer.

Hashtable(Int32, Single, IEqualityComparer) Hashtable(Int32, Single, IEqualityComparer) Hashtable(Int32, Single, IEqualityComparer) Hashtable(Int32, Single, IEqualityComparer)

Initialise une nouvelle instance vide de la classe Hashtable à l'aide de la capacité initiale, du facteur de charge et de l'objet IEqualityComparer spécifiés.Initializes a new, empty instance of the Hashtable class using the specified initial capacity, load factor, and IEqualityComparer object.

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

Initialise une nouvelle instance vide de la classe Hashtable à l'aide de la capacité initiale, du facteur de charge, du fournisseur de codes de hachage et du comparateur spécifiés.Initializes a new, empty instance of the Hashtable class using the specified initial capacity, load factor, hash code provider, and comparer.

Hashtable(SerializationInfo, StreamingContext) Hashtable(SerializationInfo, StreamingContext) Hashtable(SerializationInfo, StreamingContext) Hashtable(SerializationInfo, StreamingContext)

Initialise une nouvelle instance vide de la classe Hashtable qui est sérialisable à l’aide des objetsSerializationInfo et StreamingContext spécifiés.Initializes a new, empty instance of the Hashtable class that is serializable using the specified SerializationInfo and StreamingContext objects.

Propriétés

comparer comparer comparer comparer

Obtient ou définit le IComparer à utiliser pour Hashtable.Gets or sets the IComparer to use for the Hashtable.

Count Count Count Count

Obtient le nombre de paires clé/valeur contenues dans Hashtable.Gets the number of key/value pairs contained in the Hashtable.

EqualityComparer EqualityComparer EqualityComparer EqualityComparer

Obtient le IEqualityComparer à utiliser pour Hashtable.Gets the IEqualityComparer to use for the Hashtable.

hcp hcp hcp hcp

Obtient ou définit l'objet qui peut dispenser des codes de hachage.Gets or sets the object that can dispense hash codes.

IsFixedSize IsFixedSize IsFixedSize IsFixedSize

Obtient une valeur indiquant si Hashtable est de taille fixe.Gets a value indicating whether the Hashtable has a fixed size.

IsReadOnly IsReadOnly IsReadOnly IsReadOnly

Obtient une valeur indiquant si Hashtable est en lecture seule.Gets a value indicating whether the Hashtable is read-only.

IsSynchronized IsSynchronized IsSynchronized IsSynchronized

Obtient une valeur indiquant si l'accès à Hashtable est synchronisé (thread-safe).Gets a value indicating whether access to the Hashtable is synchronized (thread safe).

Item[Object] Item[Object] Item[Object] Item[Object]

Obtient ou définit la valeur associée à la clé spécifiée.Gets or sets the value associated with the specified key.

Keys Keys Keys Keys

Obtient ICollection contenant les clés de Hashtable.Gets an ICollection containing the keys in the Hashtable.

SyncRoot SyncRoot SyncRoot SyncRoot

Obtient un objet qui peut être utilisé pour synchroniser l'accès à Hashtable.Gets an object that can be used to synchronize access to the Hashtable.

Values Values Values Values

Obtient ICollection contenant les valeurs de Hashtable.Gets an ICollection containing the values in the Hashtable.

Méthodes

Add(Object, Object) Add(Object, Object) Add(Object, Object) Add(Object, Object)

Ajoute un élément avec la clé et la valeur spécifiées dans Hashtable.Adds an element with the specified key and value into the Hashtable.

Clear() Clear() Clear() Clear()

Supprime tous les éléments de Hashtable.Removes all elements from the Hashtable.

Clone() Clone() Clone() Clone()

Crée une copie superficielle de Hashtable.Creates a shallow copy of the Hashtable.

Contains(Object) Contains(Object) Contains(Object) Contains(Object)

Détermine si Hashtable contient une clé spécifique.Determines whether the Hashtable contains a specific key.

ContainsKey(Object) ContainsKey(Object) ContainsKey(Object) ContainsKey(Object)

Détermine si Hashtable contient une clé spécifique.Determines whether the Hashtable contains a specific key.

ContainsValue(Object) ContainsValue(Object) ContainsValue(Object) ContainsValue(Object)

Détermine si Hashtable contient une valeur spécifique.Determines whether the Hashtable contains a specific value.

CopyTo(Array, Int32) CopyTo(Array, Int32) CopyTo(Array, Int32) CopyTo(Array, Int32)

Copie les éléments Hashtable dans une instance de Array unidimensionnelle à l'index spécifié.Copies the Hashtable elements to a one-dimensional Array instance at the specified index.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Détermine si l'objet spécifié est identique à l'objet actuel.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetEnumerator() GetEnumerator() GetEnumerator() GetEnumerator()

Retourne un IDictionaryEnumerator qui itère au sein de Hashtable.Returns an IDictionaryEnumerator that iterates through the Hashtable.

GetHash(Object) GetHash(Object) GetHash(Object) GetHash(Object)

Retourne le code de hachage pour la clé spécifiée.Returns the hash code for the specified key.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Fait office de fonction de hachage par défaut.Serves as the default hash function.

(Inherited from Object)
GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext) GetObjectData(SerializationInfo, StreamingContext)

Implémente l'interface ISerializable et retourne les données requises pour sérialiser Hashtable.Implements the ISerializable interface and returns the data needed to serialize the Hashtable.

GetType() GetType() GetType() GetType()

Obtient le Type de l'instance actuelle.Gets the Type of the current instance.

(Inherited from Object)
KeyEquals(Object, Object) KeyEquals(Object, Object) KeyEquals(Object, Object) KeyEquals(Object, Object)

Compare un Object spécifique avec une clé spécifique dans Hashtable.Compares a specific Object with a specific key in the Hashtable.

MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Crée une copie superficielle de l'objet Object actuel.Creates a shallow copy of the current Object.

(Inherited from Object)
OnDeserialization(Object) OnDeserialization(Object) OnDeserialization(Object) OnDeserialization(Object)

Implémente l’interface ISerializable et déclenche l’événement de désérialisation une fois la désérialisation terminée.Implements the ISerializable interface and raises the deserialization event when the deserialization is complete.

Remove(Object) Remove(Object) Remove(Object) Remove(Object)

Supprime l'élément avec la clé spécifiée d'Hashtable.Removes the element with the specified key from the Hashtable.

Synchronized(Hashtable) Synchronized(Hashtable) Synchronized(Hashtable) Synchronized(Hashtable)

Retourne un wrapper synchronisé (thread-safe) pour Hashtable.Returns a synchronized (thread-safe) wrapper for the Hashtable.

ToString() ToString() ToString() ToString()

Retourne une chaîne qui représente l'objet actuel.Returns a string that represents the current object.

(Inherited from Object)

Implémentations d’interfaces explicites

IEnumerable.GetEnumerator() IEnumerable.GetEnumerator() IEnumerable.GetEnumerator() IEnumerable.GetEnumerator()

Retourne un énumérateur qui itère au sein d’une collection.Returns an enumerator that iterates through a collection.

Méthodes d’extension

Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable)

Effectue un cast des éléments d'un IEnumerable vers le type spécifié.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable)

Filtre les éléments d'un IEnumerable en fonction du type spécifié.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable)

Active la parallélisation d'une requête.Enables parallelization of a query.

AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable)

Convertit un IEnumerable en IQueryable.Converts an IEnumerable to an IQueryable.

S’applique à

Cohérence de thread

Hashtableest thread-safe pour une utilisation par plusieurs threads de lecture et un seul thread d’écriture.Hashtable is thread safe for use by multiple reader threads and a single writing thread. Il est thread-safe pour l’utilisation de plusieurs threads lorsqu’un seul thread effectue des opérations d’écriture (mise à jour), ce qui permet des lectures sans verrou à condition que les HashtableWriters soient sérialisés dans.It is thread safe for multi-thread use when only one of the threads perform write (update) operations, which allows for lock-free reads provided that the writers are serialized to the Hashtable. Pour prendre en charge plusieurs Writers, Hashtable toutes les opérations sur doivent être effectuées via le Synchronized(Hashtable) wrapper retourné par la méthode, à condition qu’il Hashtable n’y ait aucun thread lisant l’objet.To support multiple writers all operations on the Hashtable must be done through the wrapper returned by the Synchronized(Hashtable) method, provided that there are no threads reading the Hashtable object.

L’énumération d’une collection n’est pas intrinsèquement une procédure thread-safe.Enumerating through a collection is intrinsically not a thread safe procedure. Même lorsqu'une collection est synchronisée, les autres threads peuvent toujours la modifier, ce qui entraîne la levée d'une exception par l'énumérateur.Even when a collection is synchronized, other threads can still modify the collection, which causes the enumerator to throw an exception. Pour garantir la sécurité des threads au cours de l’énumération, vous pouvez verrouiller la collection pendant l’ensemble de l’énumération ou bien intercepter les exceptions résultant des modifications apportées par les autres threads.To guarantee thread safety during enumeration, you can either lock the collection during the entire enumeration or catch the exceptions resulting from changes made by other threads.

Voir aussi