Comment utiliser HashSet en C #

Un HashSet est une collection optimisée d'éléments uniques non ordonnés qui fournit des recherches rapides et des opérations d'ensemble hautes performances. La classe HashSet a été introduite pour la première fois dans .NET 3.5 et fait partie de l'espace de noms System.Collection.Generic. Cet article explique comment travailler avec les HashSets en C #.

Pour utiliser les exemples de code fournis dans cet article, vous devez disposer de Visual Studio 2019 installé sur votre système. Si vous n'en avez pas déjà une copie, vous pouvez télécharger Visual Studio 2019 ici.

Créer un projet d'application console .NET Core dans Visual Studio

Tout d'abord, créons un projet d'application de console .NET Core dans Visual Studio. En supposant que Visual Studio 2019 est installé sur votre système, suivez les étapes décrites ci-dessous pour créer un nouveau projet d'application console .NET Core dans Visual Studio.

  1. Lancez l'IDE de Visual Studio.
  2. Cliquez sur "Créer un nouveau projet".
  3. Dans la fenêtre «Créer un nouveau projet», sélectionnez «Application console (.NET Core)» dans la liste des modèles affichés.
  4. Cliquez sur Suivant.
  5. Dans la fenêtre «Configurer votre nouveau projet» ci-dessous, spécifiez le nom et l'emplacement du nouveau projet.
  6. Cliquez sur Créer.

Cela créera un nouveau projet d'application console .NET Core dans Visual Studio 2019. Nous utiliserons ce projet pour travailler avec HashSet dans les sections suivantes de cet article.

Qu'est-ce qu'un HashSet?

Un HashSet - représenté par la classe HashSet appartenant à l'espace de noms System.Collections.Generic - est une collection haute performance et non ordonnée d'éléments uniques. Par conséquent, un HashSet n'est pas trié et ne contient aucun élément en double. Un HashSet ne prend pas non plus en charge les index - vous ne pouvez utiliser que des énumérateurs. Un HashSet est généralement utilisé pour des opérations hautes performances impliquant un ensemble de données uniques.

La classe HashSet implémente plusieurs interfaces comme indiqué ci-dessous:

public class HashSet: System.Collections.Generic.ICollection,

System.Collections.Generic.IEnumerable,

System.Collections.Generic.IReadOnlyCollection,

System.Collections.Generic.ISet,

System.Runtime.Serialization.IDeserializationCallback,

System.Runtime.Serialization.ISerializable

Étant donné que HashSet ne contient que des éléments uniques, sa structure interne est optimisée pour des recherches plus rapides. Notez que vous pouvez stocker une seule valeur nulle dans un HashSet. Ainsi, HashSet est un bon choix lorsque vous voulez une collection qui contient des éléments uniques et que les éléments de la collection peuvent être recherchés rapidement.

Rechercher un élément dans un HashSet en C #

Pour rechercher un élément dans un HashSet, vous pouvez utiliser la méthode Contains comme indiqué dans l'extrait de code ci-dessous:

static void Main (string [] args)

        {

            HashSet hashSet = nouveau HashSet ();

            hashSet.Add ("A");

            hashSet.Add ("B");

            hashSet.Add ("C");

            hashSet.Add ("D");

            if (hashSet.Contains ("D"))

                Console.WriteLine ("L'élément requis est disponible.");

            autre

                Console.WriteLine ("L'élément requis n'est pas disponible.");

            Console.ReadKey ();

        }

Les éléments HashSet sont toujours uniques

Si vous essayez d'insérer un élément dupliqué dans un HashSet, il sera simplement ignoré mais aucune exception d'exécution ne sera levée. L'extrait de code suivant illustre cela.

static void Main (string [] args)

{

   HashSet hashSet = nouveau HashSet ();

   hashSet.Add ("A");

   hashSet.Add ("B");

   hashSet.Add ("C");

   hashSet.Add ("D");

   hashSet.Add ("D");

   Console.WriteLine ("Le nombre d'éléments est: {0}", hashSet.Count);

   Console.ReadKey ();

}

Lorsque vous exécutez le programme, la sortie sera comme indiqué dans la figure 1.

Considérons maintenant l'extrait de code suivant qui illustre comment les éléments en double sont éliminés:

string [] cities = nouvelle chaîne [] {

                "Delhi",

                "Calcutta",

                "New York",

                "Londres",

                "Tokyo",

                "Washington",

                "Tokyo"

            };

            HashSet hashSet = nouveau HashSet (villes);

            foreach (var city dans hashSet)

            {

                Console.WriteLine (ville);

            }

Lorsque vous exécutez le programme ci-dessus, les noms de ville en double sont supprimés.

Supprimer des éléments d'un HashSet en C #

Pour supprimer un élément d'un HashSet, vous devez appeler la méthode Remove. La syntaxe de la méthode Remove est donnée ci-dessous.

public bool Remove (élément T);

Si l'élément est trouvé dans la collection, la méthode Remove supprime un élément du HashSet et renvoie true en cas de succès, false dans le cas contraire.

L'extrait de code ci-dessous illustre comment vous pouvez utiliser la méthode Remove pour supprimer un élément d'un HashSet.

élément de chaîne = "D";

if (hashSet.Contains (élément))

{

   hashSet.Remove (élément);

}

Pour supprimer tous les éléments d'un HashSet, vous pouvez utiliser la méthode Clear.

Utiliser les méthodes d'opérations de jeu HashSet en C #

HashSet dispose d'un certain nombre de méthodes importantes pour les opérations d'ensemble telles que IntersectWith, UnionWith, IsProperSubsetOf, ExceptWith et SymmetricExceptWith.

IsProperSubsetOf

La méthode IsProperSubsetOf est utilisée pour déterminer si une instance HashSet est un sous-ensemble approprié d'une collection. Ceci est illustré dans l'extrait de code ci-dessous.

HashSet setA = new HashSet () {"A", "B", "C", "D"};

HashSet setB = new HashSet () {"A", "B", "C", "X"};

HashSet setC = new HashSet () {"A", "B", "C", "D", "E"};

si (setA.IsProperSubsetOf (setC))

   Console.WriteLine ("setC contient tous les éléments de setA.");

if (! setA.IsProperSubsetOf (setB))

   Console.WriteLine ("setB ne contient pas tous les éléments de setA.");

Lorsque vous exécutez le programme ci-dessus, vous devriez voir la sortie suivante dans la fenêtre de la console.

Union avec

La méthode UnionWith est utilisée pour l'ajout de jeux, comme illustré dans l'extrait de code ci-dessous.

HashSet setA = new HashSet () {"A", "B", "C", "D", "E"};

HashSet setB = new HashSet () {"A", "B", "C", "X", "Y"};

setA.UnionWith (setB);

foreach (chaîne de caractères dans setA)

{

   Console.WriteLine (str);

}

Lorsque vous exécutez le morceau de code ci-dessus, les éléments de setB sont copiés dans setA. Ainsi, setA comprendra désormais "A", "B", "C", "D", "E", "X" et "Y". 

Intersection avec 

La méthode IntersectWith est utilisée pour représenter l'intersection de deux HashSets. Voici un exemple pour comprendre cela.

HashSet setA = new HashSet () {"A", "B", "C", "D", "E"};

HashSet setB = new HashSet () {"A", "X", "C", "Y"};

setA.IntersectWith (setB);

foreach (chaîne de caractères dans setA)

{

    Console.WriteLine (str);

}

Lorsque vous exécutez le programme ci-dessus, seuls les éléments communs aux deux HashSets seront affichés dans la fenêtre de la console. La sortie ressemblerait à ceci: 

Sauf avec

La méthode ExceptWith représente la soustraction d'ensemble mathématique et est une opération O (n). Supposons que vous ayez deux HashSets setA et setB et que vous spécifiez l'instruction suivante:

setA.ExceptWith (setB);

Cela renverrait les éléments de setA qui ne sont pas présents dans setB. Comprenons cela avec un autre exemple. Considérez l'extrait de code ci-dessous.

HashSet setA = new HashSet () {"A", "B", "C", "D", "E"};

HashSet setB = new HashSet () {"A", "X", "C", "Y"};

setA.ExceptWith (setB);

foreach (chaîne de caractères dans setA)

{

   Console.WriteLine (str);

}

Lorsque vous exécutez le programme ci-dessus, les éléments «B», «D» et «E» seront imprimés dans la fenêtre de la console, comme illustré à la figure 5.

Symétrique sauf avec 

La méthode SymmetricExceptWith est utilisée pour modifier un HashSet pour qu'il ne contienne que les éléments uniques de deux HashSets, c'est-à-dire les éléments qui ne sont pas communs aux deux HashSets. Considérez l'extrait de code suivant qui illustre cela.

HashSet setA = new HashSet () {"A", "B", "C", "D", "E"};

HashSet setB = new HashSet () {"A", "X", "C", "Y"};

setA.SymmetricExceptWith (setB);

foreach (chaîne de caractères dans setA)

{

  Console.WriteLine (str);

}

Lorsque vous exécutez le code ci-dessus, seuls les éléments uniques de setA et setB - c'est-à-dire, les éléments qui sont présents dans setA mais pas dans setB, et les éléments qui sont présents dans setB mais pas dans setA - seront affichés dans la fenêtre de la console comme le montre la figure 6.

Alors que la complexité moyenne pour accéder à un élément dans un tableau est O (n), où n représente le nombre d'éléments dans le tableau, la complexité est juste O (1) pour accéder à un élément particulier dans un HashSet. Cela fait de HashSet un bon choix pour les recherches rapides et pour effectuer des opérations d'ensemble. Vous pouvez utiliser une liste si vous souhaitez stocker une collection d'éléments dans un certain ordre, et peut-être également inclure des doublons. 

Comment faire plus en C #:

  • Comment utiliser des paramètres nommés et facultatifs en C #
  • Comment comparer le code C # à l'aide de BenchmarkDotNet
  • Comment utiliser des interfaces fluides et le chaînage de méthodes en C #
  • Comment tester des méthodes statiques en C #
  • Comment refactoriser des objets Dieu en C #
  • Comment utiliser ValueTask en C #
  • Comment utiliser l'immuabilité en C
  • Comment utiliser const, readonly et static en C #
  • Comment utiliser les annotations de données en C #
  • Comment travailler avec les GUID en C # 8
  • Quand utiliser une classe abstraite ou une interface en C #
  • Comment travailler avec AutoMapper en C #
  • Comment utiliser les expressions lambda en C #
  • Comment travailler avec les délégués Action, Func et Predicate en C #
  • Comment travailler avec des délégués en C #
  • Comment implémenter un simple logger en C #
  • Comment travailler avec des attributs en C #
  • Comment travailler avec log4net en C #
  • Comment implémenter le modèle de conception de référentiel en C #
  • Comment travailler avec la réflexion en C #
  • Comment travailler avec Filesystemwatcher en C #
  • Comment effectuer une initialisation différée en C #
  • Comment travailler avec MSMQ en C #
  • Comment travailler avec des méthodes d'extension en C #
  • Comment utiliser les expressions lambda en C #
  • Quand utiliser le mot clé volatile en C #
  • Comment utiliser le mot clé yield en C #
  • Comment implémenter le polymorphisme en C #
  • Comment créer votre propre planificateur de tâches en C #
  • Comment travailler avec RabbitMQ en C #
  • Comment travailler avec un tuple en C #
  • Explorer les méthodes virtuelles et abstraites en C #
  • Comment utiliser l'ORM Dapper en C #
  • Comment utiliser le modèle de conception de poids mouche en C #