Hashtable Classe

Définition

Espace de noms:

System.Collections

Assembly:

System.Runtime.dll

Source:

Hashtable.cs

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 : ICloneable, System::Collections::IDictionary, System::Runtime::Serialization::IDeserializationCallback, System::Runtime::Serialization::ISerializable

public class Hashtable : ICloneable, System.Collections.IDictionary, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable

type Hashtable = class
    interface ICollection
    interface IEnumerable
    interface IDictionary
    interface ICloneable
    interface IDeserializationCallback
    interface ISerializable

Public Class Hashtable
Implements ICloneable, IDeserializationCallback, IDictionary, ISerializable

Héritage

Object

Hashtable

Dérivé

System.Configuration.SettingsAttributeDictionary

System.Configuration.SettingsContext

System.Data.PropertyCollection

System.Printing.IndexedProperties.PrintPropertyDictionary

Implémente

ICollection IDictionary IEnumerable ICloneable IDeserializationCallback ISerializable

Exemples

L’exemple suivant montre comment créer, initialiser et exécuter diverses fonctions dans un 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 l’être.

Important

Nous vous déconseillons d’utiliser la classe pour le Hashtable nouveau développement. Au lieu de cela, nous vous recommandons d’utiliser la classe générique Dictionary<TKey,TValue> . Pour plus d’informations, consultez Collections non génériques ne doivent pas être utilisées sur GitHub.

Les objets utilisés comme clés par un Hashtable sont requis pour remplacer la Object.GetHashCode méthode (ou l’interface IHashCodeProvider ) et la Object.Equals méthode (ou l’interface IComparer ). L’implémentation des méthodes et des interfaces doit gérer la confidentialité de la casse de la même façon ; sinon, le Hashtable peut se comporter incorrectement. Par exemple, lors de la création d’un Hashtable, vous devez utiliser la CaseInsensitiveHashCodeProvider classe (ou toute implémentation ne respectant IHashCodeProvider pas la casse) avec la CaseInsensitiveComparer classe (ou toute implémentation ne respectant pas la IComparer casse).

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 .Hashtable Une alternative consiste à utiliser un Hashtable constructeur avec un IEqualityComparer paramètre. Si l’égalité clé était simplement l’égalité de référence, la mise en œuvre héritée de Object.GetHashCode et Object.Equals suffirait.

Les objets clés doivent être immuables tant qu’ils sont utilisés comme clés dans .Hashtable

Lorsqu’un élément est ajouté à , Hashtablel’élément est placé dans un compartiment en fonction du code de hachage de la clé. Les recherches suivantes 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 requises pour rechercher un élément.

Le facteur de charge d’un Hashtable détermine le rapport maximal entre les éléments et les compartiments. Les facteurs de charge plus petits entraînent des temps de recherche moyens plus rapides au détriment d’une consommation accrue de mémoire. Le facteur de charge par défaut 1.0 fournit généralement le meilleur équilibre entre vitesse et taille. Un autre facteur de charge peut également être spécifié lors de la création de Hashtable .

À mesure que des éléments sont ajoutés à un Hashtable, le facteur de charge réel du Hashtable augmente. 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 supérieur à deux fois le nombre actuel de Hashtable compartiments.

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

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

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

L’instruction foreach 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 est Hashtable 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’instruction foreach est un wrapper autour de l’énumérateur, qui autorise uniquement la lecture à partir de la collection, et non l’écriture dans.

É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 leur comportement modifié, 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. 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. 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. 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. 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. 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)	Obsolète. 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. 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. 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)	Obsolète. 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 l'élément avec la clé spécifiée d'Hashtable.
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.

Cohérence de thread

Hashtable est thread sécurisé pour une utilisation par plusieurs threads de lecteur et un seul thread d’écriture. Il est thread sécurisé pour l’utilisation de plusieurs threads quand un seul des threads effectue des opérations d’écriture (mise à jour), ce qui permet des lectures sans verrou à condition que les enregistreurs soient sérialisés sur le Hashtable. Pour prendre en charge plusieurs enregistreurs, toutes les opérations sur doivent Hashtable être effectuées via le wrapper retourné par la Synchronized(Hashtable) méthode, à condition qu’aucun thread ne lise l’objet Hashtable .

L’énumération par le biais 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

• IDictionary
• IHashCodeProvider
• GetHashCode()
• Equals(Object)
• DictionaryEntry
• Dictionary<TKey,TValue>
• IEqualityComparer