Hashtable Classe

Définition

Représente une collection de paires clé/valeur qui sont organisées en fonction du code de hachage de la clé.

public ref class Hashtable : System::Collections::IDictionary
public ref class Hashtable : ICloneable, System::Collections::IDictionary, System::Runtime::Serialization::IDeserializationCallback, System::Runtime::Serialization::ISerializable
public class Hashtable : System.Collections.IDictionary
public class Hashtable : ICloneable, System.Collections.IDictionary, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable
[System.Serializable]
public class Hashtable : ICloneable, System.Collections.IDictionary, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public class Hashtable : ICloneable, System.Collections.IDictionary, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable
type Hashtable = class
    interface ICollection
    interface IEnumerable
    interface IDictionary
type Hashtable = class
    interface ICollection
    interface IEnumerable
    interface IDictionary
    interface ICloneable
    interface IDeserializationCallback
    interface ISerializable
type Hashtable = class
    interface ICollection
    interface IEnumerable
    interface IDictionary
    interface ISerializable
    interface IDeserializationCallback
    interface ICloneable
[<System.Serializable>]
type Hashtable = class
    interface IDictionary
    interface ICollection
    interface IEnumerable
    interface ISerializable
    interface IDeserializationCallback
    interface ICloneable
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Hashtable = class
    interface IDictionary
    interface ICollection
    interface IEnumerable
    interface ISerializable
    interface IDeserializationCallback
    interface ICloneable
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type Hashtable = class
    interface IDictionary
    interface ISerializable
    interface IDeserializationCallback
    interface ICloneable
    interface ICollection
    interface IEnumerable
Public Class Hashtable
Implements IDictionary
Public Class Hashtable
Implements ICloneable, IDeserializationCallback, IDictionary, ISerializable
Héritage
Hashtable
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.

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.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 un DictionaryEntry objet. Une clé ne peut pas être null , mais une valeur peut être.

Important

Nous vous déconseillons d’utiliser la Hashtable classe pour un nouveau développement. Au lieu de cela, nous vous recommandons d’utiliser la Dictionary<TKey,TValue> classe générique. Pour plus d’informations, consultez regroupements non génériques sur 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). 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 contraire, le Hashtable risque de se comporter de manière incorrecte. Par exemple, lors de la création d’un Hashtable , vous devez utiliser la CaseInsensitiveHashCodeProvider classe (ou toute implémentation ne respectant pas IHashCodeProvider la casse) avec la CaseInsensitiveComparer classe (ou toute implémentation ne respectant pas la casse IComparer ).

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 la clé existe dans le Hashtable . Une alternative consiste à utiliser un Hashtable constructeur avec un IEqualityComparer paramètre. Si l’égalité des clés était simplement une égalité de référence, l’implémentation héritée de Object.GetHashCode et Object.Equals suffisait.

Les objets clés doivent être immuables tant qu’ils sont utilisés en tant que clés dans le 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é. 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.

Le facteur de charge d’un Hashtable détermine le rapport maximal entre les éléments et les compartiments. 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. Le facteur de charge par défaut de 1,0 fournit généralement le meilleur équilibre entre la vitesse et la taille. Un facteur de charge différent peut également être spécifié lors de la Hashtable création du.

À mesure que des éléments sont ajoutés à un Hashtable , le facteur de charge réel de l' Hashtable augmentation. 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.

Chaque objet clé dans Hashtable doit fournir sa propre fonction de hachage, qui est accessible en appelant GetHash . Toutefois, tout objet qui implémente IHashCodeProvider peut être passé à un Hashtable constructeur, et cette fonction de hachage est utilisée pour tous les objets de la table.

La capacité d’un Hashtable est le nombre d’éléments que Hashtable peut contenir. À mesure que des éléments sont ajoutés à un Hashtable , la capacité est automatiquement augmentée en fonction des besoins par réallocation.

.NET Framework uniquement : Pour les objets très volumineux Hashtable , vous pouvez augmenter la capacité maximale à 2 milliards éléments sur un système 64 bits en affectant enabled à l’attribut de l’élément de configuration la valeur <gcAllowVeryLargeObjects> true dans l’environnement d’exécution.

l' foreach instruction du langage C# ( For Each en Visual Basic) retourne un objet du type des éléments de la collection. Étant donné que chaque élément de Hashtable est une paire clé/valeur, le type d’élément n’est pas le type de la clé ou le type de la valeur. Au lieu de cela, le type d’élément est DictionaryEntry . Exemple :

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.

Étant donné que la sérialisation et la désérialisation d’un énumérateur pour un Hashtable 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.

Notes

Étant donné que les clés peuvent être héritées et que leur comportement a changé, leur unicité absolue ne peut pas être garantie par des comparaisons à l’aide de la Equals méthode.

Constructeurs

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.

Hashtable(IDictionary)

Initialise une nouvelle instance de la classe Hashtable en copiant les éléments du dictionnaire spécifié vers le nouvel objet Hashtable. 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.

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

Hashtable(IDictionary, IHashCodeProvider, IComparer)
Obsolète.
Obsolète.

Initialise une nouvelle instance de la classe Hashtable en copiant les éléments du dictionnaire spécifié vers le nouvel objet Hashtable. 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. Cette API est obsolète. Pour obtenir une alternative, consultez Hashtable(IDictionary, IEqualityComparer).

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

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

Hashtable(IDictionary, Single, IHashCodeProvider, IComparer)
Obsolète.
Obsolète.

Initialise une nouvelle instance de la classe Hashtable en copiant les éléments du dictionnaire spécifié vers le nouvel objet Hashtable. 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.

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

Hashtable(IHashCodeProvider, IComparer)
Obsolète.
Obsolète.

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.

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.

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.

Hashtable(Int32, IHashCodeProvider, IComparer)
Obsolète.
Obsolète.

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.

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.

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.

Hashtable(Int32, Single, IHashCodeProvider, IComparer)
Obsolète.
Obsolète.

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.

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.

Propriétés

comparer
Obsolète.
Obsolète.

Obtient ou définit le IComparer à utiliser pour Hashtable.

Count

Obtient le nombre de paires clé/valeur contenues dans Hashtable.

EqualityComparer

Obtient le IEqualityComparer à utiliser pour Hashtable.

hcp
Obsolète.
Obsolète.

Obtient ou définit l'objet qui peut dispenser des codes de hachage.

IsFixedSize

Obtient une valeur indiquant si Hashtable est de taille fixe.

IsReadOnly

Obtient une valeur indiquant si Hashtable est en lecture seule.

IsSynchronized

Obtient une valeur indiquant si l’accès à Hashtable est synchronisé (thread-safe).

Item[Object]

Obtient ou définit la valeur associée à la clé spécifiée.

Keys

Obtient ICollection contenant les clés de Hashtable.

SyncRoot

Obtient un objet qui peut être utilisé pour synchroniser l’accès à Hashtable.

Values

Obtient ICollection contenant les valeurs de Hashtable.

Méthodes

Add(Object, Object)

Ajoute un élément avec la clé et la valeur spécifiées dans Hashtable.

Clear()

Supprime tous les éléments de Hashtable.

Clone()

Crée une copie superficielle de Hashtable.

Contains(Object)

Détermine si Hashtable contient une clé spécifique.

ContainsKey(Object)

Détermine si Hashtable contient une clé spécifique.

ContainsValue(Object)

Détermine si Hashtable contient une valeur spécifique.

CopyTo(Array, Int32)

Copie les éléments Hashtable dans une instance de Array unidimensionnelle à l'index spécifié.

Equals(Object)

Détermine si l'objet spécifié est égal à l'objet actuel.

(Hérité de Object)
GetEnumerator()

Retourne un IDictionaryEnumerator qui itère au sein de Hashtable.

GetHash(Object)

Retourne le code de hachage pour la clé spécifiée.

GetHashCode()

Fait office de fonction de hachage par défaut.

(Hérité de Object)
GetObjectData(SerializationInfo, StreamingContext)

Implémente l'interface ISerializable et retourne les données requises pour sérialiser Hashtable.

GetType()

Obtient le Type de l'instance actuelle.

(Hérité de Object)
KeyEquals(Object, Object)

Compare un Object spécifique avec une clé spécifique dans Hashtable.

MemberwiseClone()

Crée une copie superficielle du Object actuel.

(Hérité de 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.

Remove(Object)

Supprime de Hashtable l'élément ayant la clé spécifiée.

Synchronized(Hashtable)

Retourne un wrapper synchronisé (thread-safe) pour Hashtable.

ToString()

Retourne une chaîne qui représente l'objet actuel.

(Hérité de Object)

Implémentations d’interfaces explicites

IEnumerable.GetEnumerator()

Retourne un énumérateur qui itère au sein d’une collection.

Méthodes d’extension

Cast<TResult>(IEnumerable)

Effectue un cast des éléments d'un IEnumerable vers le type spécifié.

OfType<TResult>(IEnumerable)

Filtre les éléments d'un IEnumerable en fonction du type spécifié.

AsParallel(IEnumerable)

Active la parallélisation d'une requête.

AsQueryable(IEnumerable)

Convertit un IEnumerable en IQueryable.

S’applique à

Cohérence de thread

Hashtable est thread-safe pour une utilisation par plusieurs threads de lecture et un seul thread d’écriture. 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 Writers soient sérialisés dans Hashtable . Pour prendre en charge plusieurs Writers, toutes les opérations sur Hashtable doivent être effectuées via le wrapper retourné par la Synchronized(Hashtable) méthode, à condition qu’il n’y ait aucun thread lisant l' Hashtable objet.

L’énumération d’une collection n’est pas intrinsèquement une procédure thread-safe. 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. 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.

Voir aussi