HashSet<T> Classe

Définition

Représente un ensemble de valeurs.Represents a set of values.

generic <typename T>
public ref class HashSet : System::Collections::Generic::ICollection<T>, System::Collections::Generic::IEnumerable<T>, System::Collections::Generic::IReadOnlyCollection<T>, System::Collections::Generic::ISet<T>, System::Runtime::Serialization::IDeserializationCallback, System::Runtime::Serialization::ISerializable
[System.Serializable]
public class HashSet<T> : System.Collections.Generic.ICollection<T>, System.Collections.Generic.IEnumerable<T>, System.Collections.Generic.IReadOnlyCollection<T>, System.Collections.Generic.ISet<T>, System.Runtime.Serialization.IDeserializationCallback, System.Runtime.Serialization.ISerializable
type HashSet<'T> = class
    interface ICollection<'T>
    interface ISerializable
    interface IDeserializationCallback
    interface ISet<'T>
    interface IReadOnlyCollection<'T>
    interface seq<'T>
    interface IEnumerable
Public Class HashSet(Of T)
Implements ICollection(Of T), IDeserializationCallback, IEnumerable(Of T), IReadOnlyCollection(Of T), ISerializable, ISet(Of T)

Paramètres de type

T

Type d'éléments de l'ensemble de hachages.The type of elements in the hash set.

Héritage
HashSet<T>
Attributs
Implémente

Exemples

L’exemple suivant montre comment fusionner deux jeux disparates.The following example demonstrates how to merge two disparate sets. Cet exemple crée deux objets HashSet<T> et les remplit avec des nombres pairs et impairs, respectivement.This example creates two HashSet<T> objects, and populates them with even and odd numbers, respectively. Un troisième objet HashSet<T> est créé à partir de l’ensemble qui contient les nombres pairs.A third HashSet<T> object is created from the set that contains the even numbers. L’exemple appelle ensuite la méthode UnionWith, qui ajoute le nombre impair au troisième jeu.The example then calls the UnionWith method, which adds the odd number set to the third set.

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        HashSet<int> evenNumbers = new HashSet<int>();
        HashSet<int> oddNumbers = new HashSet<int>();

        for (int i = 0; i < 5; i++)
        {
            // Populate numbers with just even numbers.
            evenNumbers.Add(i * 2);

            // Populate oddNumbers with just odd numbers.
            oddNumbers.Add((i * 2) + 1);
        }

        Console.Write("evenNumbers contains {0} elements: ", evenNumbers.Count);
        DisplaySet(evenNumbers);

        Console.Write("oddNumbers contains {0} elements: ", oddNumbers.Count);
        DisplaySet(oddNumbers);

        // Create a new HashSet populated with even numbers.
        HashSet<int> numbers = new HashSet<int>(evenNumbers);
        Console.WriteLine("numbers UnionWith oddNumbers...");
        numbers.UnionWith(oddNumbers);

        Console.Write("numbers contains {0} elements: ", numbers.Count);
        DisplaySet(numbers);

        void DisplaySet(HashSet<int> set)
        {
            Console.Write("{");
            foreach (int i in set)
            {
                Console.Write(" {0}", i);
            }
            Console.WriteLine(" }");
        }

        /* This example produces output similar to the following:
        * evenNumbers contains 5 elements: { 0 2 4 6 8 }
        * oddNumbers contains 5 elements: { 1 3 5 7 9 }
        * numbers UnionWith oddNumbers...
        * numbers contains 10 elements: { 0 2 4 6 8 1 3 5 7 9 }
        */
    }
}
Imports System.Collections.Generic

Class Program

    Shared Sub Main()

        Dim evenNumbers As HashSet(Of Integer) = New HashSet(Of Integer)()
        Dim oddNumbers As HashSet(Of Integer) = New HashSet(Of Integer)()

        For i As Integer = 0 To 4

            ' Populate evenNumbers with only even numbers.
            evenNumbers.Add(i * 2)

            ' Populate oddNumbers with only odd numbers.
            oddNumbers.Add((i * 2) + 1)
        Next i

        Console.Write("evenNumbers contains {0} elements: ", evenNumbers.Count)
        DisplaySet(evenNumbers)

        Console.Write("oddNumbers contains {0} elements: ", oddNumbers.Count)
        DisplaySet(oddNumbers)

        ' Create a new HashSet populated with even numbers.
        Dim numbers As HashSet(Of Integer) = New HashSet(Of Integer)(evenNumbers)
        Console.WriteLine("numbers UnionWith oddNumbers...")
        numbers.UnionWith(oddNumbers)

        Console.Write("numbers contains {0} elements: ", numbers.Count)
        DisplaySet(numbers)
    End Sub


    Private Shared Sub DisplaySet(ByVal coll As HashSet(Of Integer))
        Console.Write("{")
        For Each i As Integer In coll
            Console.Write(" {0}", i)
        Next i
        Console.WriteLine(" }")
    End Sub

End Class
' This example produces output similar to the following:
' evenNumbers contains 5 elements: { 0 2 4 6 8 }
' oddNumbers contains 5 elements: { 1 3 5 7 9 }
' numbers UnionWith oddNumbers...
' numbers contains 10 elements: { 0 2 4 6 8 1 3 5 7 9 }

Remarques

La classe HashSet<T> fournit des opérations de définition de performances élevées.The HashSet<T> class provides high-performance set operations. Un ensemble est une collection qui ne contient aucun élément en double, et dont les éléments ne sont pas dans un ordre particulier.A set is a collection that contains no duplicate elements, and whose elements are in no particular order.

Notes

HashSet<T> implémente l’interface IReadOnlyCollection<T> à partir du .NET Framework 4.6.NET Framework 4.6 ; dans les versions précédentes de la .NET Framework, la classe HashSet<T> n’implémentait pas cette interface.HashSet<T> implements the IReadOnlyCollection<T> interface starting with the .NET Framework 4.6.NET Framework 4.6; in previous versions of the .NET Framework, the HashSet<T> class did not implement this interface.

La capacité d’un objet HashSet<T> correspond au nombre d’éléments que l’objet peut contenir.The capacity of a HashSet<T> object is the number of elements that the object can hold. La capacité d’un objet HashSet<T> augmente automatiquement à mesure que des éléments sont ajoutés à l’objet.A HashSet<T> object's capacity automatically increases as elements are added to the object.

La classe HashSet<T> est basée sur le modèle de jeux mathématiques et fournit des opérations de jeu de performances élevées similaires à l’accès aux clés des collections Dictionary<TKey,TValue> ou Hashtable.The HashSet<T> class is based on the model of mathematical sets and provides high-performance set operations similar to accessing the keys of the Dictionary<TKey,TValue> or Hashtable collections. En termes simples, la classe HashSet<T> peut être considérée comme une collection Dictionary<TKey,TValue> sans valeurs.In simple terms, the HashSet<T> class can be thought of as a Dictionary<TKey,TValue> collection without values.

Une collection HashSet<T> n’est pas triée et ne peut pas contenir d’éléments en double.A HashSet<T> collection is not sorted and cannot contain duplicate elements. Si la duplication d’une commande ou d’un élément est plus importante que les performances de votre application, envisagez d’utiliser la classe List<T> avec la méthode Sort.If order or element duplication is more important than performance for your application, consider using the List<T> class together with the Sort method.

HashSet<T> fournit de nombreuses opérations ensemblistes mathématiques, telles que l’ajout de l’ensemble (unions) et la soustraction de la définition.HashSet<T> provides many mathematical set operations, such as set addition (unions) and set subtraction. Le tableau suivant répertorie les opérations HashSet<T> fournies et leurs équivalents mathématiques.The following table lists the provided HashSet<T> operations and their mathematical equivalents.

Opération HashSetHashSet operation Équivalent mathématiqueMathematical equivalent
UnionWith Ajout d’Union ou de jeuUnion or set addition
IntersectWith IntersectionIntersection
ExceptWith Définir la soustractionSet subtraction
SymmetricExceptWith Différence symétriqueSymmetric difference

Outre les opérations ensemblistes listées, la classe HashSet<T> fournit également des méthodes permettant de déterminer l’égalité définie, le chevauchement des jeux et si un ensemble est un sous-ensemble ou sur-ensemble d’un autre jeu.In addition to the listed set operations, the HashSet<T> class also provides methods for determining set equality, overlap of sets, and whether a set is a subset or superset of another set.

.NET Framework uniquement : Pour les très grands objets HashSet<T>, vous pouvez augmenter la capacité maximale à 2 milliards éléments sur un système 64 bits en affectant à l’attribut enabled de l’élément de configuration <gcAllowVeryLargeObjects> la valeur true dans l’environnement d’exécution..NET Framework only: For very large HashSet<T> 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.

À partir du .NET Framework 4.NET Framework 4, la classe HashSet<T> implémente l’interface ISet<T>.Starting with the .NET Framework 4.NET Framework 4, the HashSet<T> class implements the ISet<T> interface.

HashSet et LINQ, opérations ensemblistesHashSet and LINQ Set Operations

LINQ fournit l’accès aux opérations Set Distinct, Union, Intersect et Except sur toute source de données qui implémente les interfaces IEnumerable ou IQueryable.LINQ provides access to the Distinct, Union, Intersect and Except set operations on any data source that implements the IEnumerable or IQueryable interfaces. HashSet<T> fournit une collection plus importante et plus robuste d’opérations Set.HashSet<T> provides a larger and more robust collection of set operations. Par exemple, HashSet<T> fournit des comparaisons telles que IsSubsetOf et IsSupersetOf.For example, HashSet<T> provides comparisons such as IsSubsetOf and IsSupersetOf.

La principale différence entre les opérations ensemblistes LINQ et les opérations HashSet<T> est que les opérations Set LINQ retournent toujours une nouvelle collection IEnumerable<T>, tandis que les méthodes équivalentes HashSet<T> modifient la collection actuelle.The primary difference between LINQ set operations and HashSet<T> operations is that LINQ set operations always return a new IEnumerable<T> collection, whereas the HashSet<T> equivalent methods modify the current collection.

En règle générale, si vous devez créer un jeu ou si votre application a besoin d’accéder uniquement aux opérations ensemblistes fournies, l’utilisation d’opérations Set LINQ sur une collection ou un tableau IEnumerable<T> suffisait.Typically, if you must create a new set or if your application needs access only to the provided set operations, using LINQ set operations on any IEnumerable<T> collection or array will be sufficient. Toutefois, si votre application nécessite l’accès à des opérations Set supplémentaires, ou s’il n’est pas souhaitable ou nécessaire de créer une nouvelle collection, utilisez la classe HashSet<T>.However, if your application requires access to additional set operations, or if it is not desirable or necessary to create a new collection, use the HashSet<T> class.

Le tableau suivant présente les opérations HashSet<T> et leurs opérations équivalentes LINQ.The following table shows the HashSet<T> operations and their equivalent LINQ set operations.

Opération HashSetHashSet operation Équivalent LINQLINQ equivalent
UnionWith Union
IntersectWith Intersect
ExceptWith Except
Non fourni.Not provided. Distinct
SymmetricExceptWith Non fourni.Not provided.
Overlaps Non fourni.Not provided.
IsSubsetOf Non fourni.Not provided.
IsProperSubsetOf Non fourni.Not provided.
IsSupersetOf Non fourni.Not provided.
IsProperSupersetOf Non fourni.Not provided.
SetEquals Non fourni.Not provided.

Constructeurs

HashSet<T>()

Initialise une nouvelle instance de la classe HashSet<T> vide et utilise le comparateur d'égalité par défaut pour le type du jeu.Initializes a new instance of the HashSet<T> class that is empty and uses the default equality comparer for the set type.

HashSet<T>(IEnumerable<T>)

Initialise une nouvelle instance de la classe HashSet<T> qui utilise le comparateur d'égalité par défaut pour le type du jeu, contient des éléments copiés à partir de la collection spécifiée et possède une capacité suffisante pour accueillir le nombre d'éléments copiés.Initializes a new instance of the HashSet<T> class that uses the default equality comparer for the set type, contains elements copied from the specified collection, and has sufficient capacity to accommodate the number of elements copied.

HashSet<T>(IEnumerable<T>, IEqualityComparer<T>)

Initialise une nouvelle instance de la classe HashSet<T> qui utilise le comparateur d'égalité spécifié pour le type du jeu, contient des éléments copiés à partir de la collection spécifiée et possède une capacité suffisante pour accueillir le nombre d'éléments copiés.Initializes a new instance of the HashSet<T> class that uses the specified equality comparer for the set type, contains elements copied from the specified collection, and has sufficient capacity to accommodate the number of elements copied.

HashSet<T>(IEqualityComparer<T>)

Initialise une nouvelle instance de la classe HashSet<T> vide et utilise le comparateur d'égalité spécifié pour le type du jeu.Initializes a new instance of the HashSet<T> class that is empty and uses the specified equality comparer for the set type.

HashSet<T>(Int32)

Initialise une nouvelle instance de la classe HashSet<T> qui est vide, mais qui a de l’espace réservé pour des éléments capacity et qui utilise le comparateur d’égalité par défaut pour le type de l’ensemble.Initializes a new instance of the HashSet<T> class that is empty, but has reserved space for capacity items and uses the default equality comparer for the set type.

HashSet<T>(Int32, IEqualityComparer<T>)

Initialise une nouvelle instance de la classe HashSet<T> qui utilise le comparateur d’égalité spécifié pour le type de jeu et dispose d’une capacité suffisante pour accueillir les éléments capacity.Initializes a new instance of the HashSet<T> class that uses the specified equality comparer for the set type, and has sufficient capacity to accommodate capacity elements.

HashSet<T>(SerializationInfo, StreamingContext)

Initialise une nouvelle instance de la classe HashSet<T> avec des données sérialisées.Initializes a new instance of the HashSet<T> class with serialized data.

Propriétés

Comparer

Obtient l'objet IEqualityComparer<T> qui est utilisé pour déterminer l'égalité des valeurs du jeu.Gets the IEqualityComparer<T> object that is used to determine equality for the values in the set.

Count

Obtient le nombre d'éléments contenus dans un ensemble.Gets the number of elements that are contained in a set.

Méthodes

Add(T)

Ajoute l'élément spécifié à un ensemble.Adds the specified element to a set.

Clear()

Supprime tous les éléments d'un objet HashSet<T>.Removes all elements from a HashSet<T> object.

Contains(T)

Détermine si un objet HashSet<T> contient l'élément spécifié.Determines whether a HashSet<T> object contains the specified element.

CopyTo(T[])

Copie les éléments d'un objet HashSet<T> dans un tableau.Copies the elements of a HashSet<T> object to an array.

CopyTo(T[], Int32)

Copie les éléments d'un objet HashSet<T> dans un tableau, en commençant à l'index de tableau spécifié.Copies the elements of a HashSet<T> object to an array, starting at the specified array index.

CopyTo(T[], Int32, Int32)

Copie le nombre spécifié d'éléments d'un objet HashSet<T> dans un tableau, en commençant à l'index de tableau spécifié.Copies the specified number of elements of a HashSet<T> object to an array, starting at the specified array index.

CreateSetComparer()

Retourne un objet IEqualityComparer qui peut être utilisé pour tester l'égalité d'un objet HashSet<T>.Returns an IEqualityComparer object that can be used for equality testing of a HashSet<T> object.

EnsureCapacity(Int32)

Garantit que ce jeu de hachage peut contenir le nombre spécifié d’éléments sans croître.Ensures that this hash set can hold the specified number of elements without growing.

Equals(Object)

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

(Hérité de Object)
ExceptWith(IEnumerable<T>)

Supprime tous les éléments dans la collection spécifiée de l'objet HashSet<T> actif.Removes all elements in the specified collection from the current HashSet<T> object.

GetEnumerator()

Retourne un énumérateur qui itère au sein d'un objet HashSet<T>.Returns an enumerator that iterates through a HashSet<T> object.

GetHashCode()

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

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

Implémente l'interface ISerializable et retourne les données requises pour sérialiser un objet HashSet<T>.Implements the ISerializable interface and returns the data needed to serialize a HashSet<T> object.

GetType()

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

(Hérité de Object)
IntersectWith(IEnumerable<T>)

Modifie l’objet HashSet<T> actif afin qu’il contienne uniquement les éléments qui sont présents dans cet objet et dans la collection spécifiée.Modifies the current HashSet<T> object to contain only elements that are present in that object and in the specified collection.

IsProperSubsetOf(IEnumerable<T>)

Détermine si un objet HashSet<T> est un sous-ensemble propre à la collection spécifiée.Determines whether a HashSet<T> object is a proper subset of the specified collection.

IsProperSupersetOf(IEnumerable<T>)

Détermine si un objet HashSet<T> est un sur-ensemble propre à la collection spécifiée.Determines whether a HashSet<T> object is a proper superset of the specified collection.

IsSubsetOf(IEnumerable<T>)

Détermine si un objet HashSet<T> est un sous-ensemble de la collection spécifiée.Determines whether a HashSet<T> object is a subset of the specified collection.

IsSupersetOf(IEnumerable<T>)

Détermine si un objet HashSet<T> est un sur-ensemble de la collection spécifiée.Determines whether a HashSet<T> object is a superset of the specified collection.

MemberwiseClone()

Crée une copie superficielle du Object actuel.Creates a shallow copy of the current Object.

(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.Implements the ISerializable interface and raises the deserialization event when the deserialization is complete.

Overlaps(IEnumerable<T>)

Détermine si l'objet HashSet<T> actuel et une collection spécifiée partagent des éléments communs.Determines whether the current HashSet<T> object and a specified collection share common elements.

Remove(T)

Supprime l'élément spécifié d'un objet HashSet<T>.Removes the specified element from a HashSet<T> object.

RemoveWhere(Predicate<T>)

Supprime tous les éléments qui correspondent aux conditions définies par le prédicat spécifié de la collection HashSet<T>.Removes all elements that match the conditions defined by the specified predicate from a HashSet<T> collection.

SetEquals(IEnumerable<T>)

Détermine si un objet HashSet<T> et la collection spécifiée contiennent les mêmes éléments.Determines whether a HashSet<T> object and the specified collection contain the same elements.

SymmetricExceptWith(IEnumerable<T>)

Modifie l'objet HashSet<T> actif afin qu'il contienne uniquement les éléments présents dans cet objet ou dans la collection spécifiée, mais pas dans les deux.Modifies the current HashSet<T> object to contain only elements that are present either in that object or in the specified collection, but not both.

ToString()

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

(Hérité de Object)
TrimExcess()

Affecte à la capacité d'un objet HashSet<T> le nombre réel d'éléments qu'il contient, arrondi à une valeur proche spécifique à l'implémentation.Sets the capacity of a HashSet<T> object to the actual number of elements it contains, rounded up to a nearby, implementation-specific value.

TryGetValue(T, T)

Recherche dans l’ensemble une valeur donnée et retourne la valeur égale qu’il trouve, le cas échéant.Searches the set for a given value and returns the equal value it finds, if any.

UnionWith(IEnumerable<T>)

Modifie l'objet HashSet<T> actif afin qu'il contienne tous les éléments qui sont présents dans cet objet, dans la collection spécifiée ou dans les deux.Modifies the current HashSet<T> object to contain all elements that are present in itself, the specified collection, or both.

Implémentations d’interfaces explicites

ICollection<T>.Add(T)

Ajoute un élément à un objet ICollection<T>.Adds an item to an ICollection<T> object.

ICollection<T>.IsReadOnly

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

IEnumerable.GetEnumerator()

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

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

CopyToDataTable<T>(IEnumerable<T>)

Retourne un DataTable qui contient des copies des objets DataRow, à partir d'un objet d'entrée IEnumerable<T> où le paramètre générique T est DataRow.Returns a DataTable that contains copies of the DataRow objects, given an input IEnumerable<T> object where the generic parameter T is DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)

Copie les objets DataRow vers le DataTable spécifié, à partir d'un objet d'entrée IEnumerable<T> où le paramètre générique T est DataRow.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)

Copie les objets DataRow vers le DataTable spécifié, à partir d'un objet d'entrée IEnumerable<T> où le paramètre générique T est DataRow.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

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)

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)

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

AsQueryable(IEnumerable)

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

Ancestors<T>(IEnumerable<T>)

Retourne une collection d'éléments qui contient les ancêtres de chaque nœud de la collection source.Returns a collection of elements that contains the ancestors of every node in the source collection.

Ancestors<T>(IEnumerable<T>, XName)

Retourne une collection d'éléments filtrée qui contient les ancêtres de chaque nœud de la collection source.Returns a filtered collection of elements that contains the ancestors of every node in the source collection. Seuls les éléments avec un XName correspondant sont inclus dans la collection.Only elements that have a matching XName are included in the collection.

DescendantNodes<T>(IEnumerable<T>)

Retourne une collection des nœuds descendants de chaque document et élément de la collection source.Returns a collection of the descendant nodes of every document and element in the source collection.

Descendants<T>(IEnumerable<T>)

Retourne une collection d'éléments qui contient les éléments descendants de tous les éléments et tous les documents de la collection source.Returns a collection of elements that contains the descendant elements of every element and document in the source collection.

Descendants<T>(IEnumerable<T>, XName)

Retourne une collection d'éléments filtrée qui contient les éléments descendants de tous les éléments et tous les documents de la collection source.Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. Seuls les éléments avec un XName correspondant sont inclus dans la collection.Only elements that have a matching XName are included in the collection.

Elements<T>(IEnumerable<T>)

Retourne une collection des éléments enfants de chaque élément et document de la collection source.Returns a collection of the child elements of every element and document in the source collection.

Elements<T>(IEnumerable<T>, XName)

Retourne une collection filtrée des éléments enfants de chaque élément et document de la collection source.Returns a filtered collection of the child elements of every element and document in the source collection. Seuls les éléments avec un XName correspondant sont inclus dans la collection.Only elements that have a matching XName are included in the collection.

InDocumentOrder<T>(IEnumerable<T>)

Retourne une collection de nœuds qui contient tous les nœuds de la collection source, triés selon l'ordre des documents.Returns a collection of nodes that contains all nodes in the source collection, sorted in document order.

Nodes<T>(IEnumerable<T>)

Retourne une collection des nœuds enfants de chaque document et élément de la collection source.Returns a collection of the child nodes of every document and element in the source collection.

Remove<T>(IEnumerable<T>)

Supprime chaque nœud de la collection source de son nœud parent.Removes every node in the source collection from its parent node.

S’applique à

Voir aussi