HashSet C# (Comment ça marche pour les développeurs)

Introduction

La programmation en C# est flexible et offre un large éventail de structures de données permettant de gérer efficacement divers travaux. Les HashSet est l'une de ces structures de données puissantes qui offre des composants distincts et une complexité moyenne en temps constant pour les opérations fondamentales. Ce billet examine l'utilisation de HashSet en C# et la manière dont il peut être utilisé avec IronPDFune puissante bibliothèque pour travailler avec des documents PDF.

Comment utiliser HashSet C&num ;

1. Créez un nouveau projet Console App.

2. Créer un objet pour le HashSet en C#. Ajouter la valeur par défaut au HashSet.

3. Lors de l'ajout, HashSet supprime automatiquement les éléments en double en vérifiant si l'élément existe.

4. Traiter le HashSet uniquement avec des éléments uniques, un par un.

5. Afficher le résultat et éliminer l'objet.

Comprendre les HashSet en C# ;

HashSet en C# est conçu pour fournir des opérations ensemblistes très performantes. Un HashSet est la collection idéale à utiliser dans les situations où vous devez conserver un ensemble distinct de données, car il évite les éléments en double. Il est inclus dans les tables System.Assortments.Hash, à la base de l'espace de noms générique C#, et permet des opérations d'insertion et de suppression rapides, ainsi que des opérations de recherche et de récupération plus rapides. Nous pouvons également trouver le sous-ensemble approprié dans les éléments du HashSet. En C#, utilisez les méthodes d'opérations ensemblistes HashSet qui vous permettent d'effectuer facilement des opérations ensemblistes standard. La classe HashSet fournit des méthodes d'opérations sur les ensembles.

Voici quelques utilisations C# d'un HashSet :

Initialisation et opérations de base

Établissement d'un ensemble de hachage et exécution d'actions fondamentales telles que l'ajout, la suppression et la vérification de l'existence d'entrées.

// set operations 
HashSet<int> numbers = new HashSet<int>();
// Add elements
numbers.Add(1);
numbers.Add(2);
numbers.Add(3);
// Remove an element, predicate function
numbers.Remove(2);
// Check for membership or duplicate element
bool containsThree = numbers.Contains(3);

// set operations 
HashSet<int> numbers = new HashSet<int>();
// Add elements
numbers.Add(1);
numbers.Add(2);
numbers.Add(3);
// Remove an element, predicate function
numbers.Remove(2);
// Check for membership or duplicate element
bool containsThree = numbers.Contains(3);

' set operations 
Dim numbers As New HashSet(Of Integer)()
' Add elements
numbers.Add(1)
numbers.Add(2)
numbers.Add(3)
' Remove an element, predicate function
numbers.Remove(2)
' Check for membership or duplicate element
Dim containsThree As Boolean = numbers.Contains(3)

Initialisation avec la collection

En utilisant une collection existante comme point de départ d'un HashSet, les doublons sont immédiatement éliminés.

List<int> duplicateNumbers = new List<int> { 1, 2, 2, 3, 3, 4 }; // all the elements
HashSet<int> uniqueNumbers = new HashSet<int>(duplicateNumbers);

List<int> duplicateNumbers = new List<int> { 1, 2, 2, 3, 3, 4 }; // all the elements
HashSet<int> uniqueNumbers = new HashSet<int>(duplicateNumbers);

Dim duplicateNumbers As New List(Of Integer) From {1, 2, 2, 3, 3, 4} ' all the elements
Dim uniqueNumbers As New HashSet(Of Integer)(duplicateNumbers)

Union avec un autre HashSet

Combinaison de deux instances de HashSet pour produire un nouvel ensemble qui combine des éléments distincts des deux ensembles à l'aide de la fonction UnionWith.

HashSet<int> set1 = new HashSet<int> { 1, 2, 3 };
HashSet<int> set2 = new HashSet<int> { 3, 4, 5 };
set1.UnionWith(set2); // set1 now contains { 1, 2, 3, 4, 5 }

HashSet<int> set1 = new HashSet<int> { 1, 2, 3 };
HashSet<int> set2 = new HashSet<int> { 3, 4, 5 };
set1.UnionWith(set2); // set1 now contains { 1, 2, 3, 4, 5 }

Dim set1 As New HashSet(Of Integer) From {1, 2, 3}
Dim set2 As New HashSet(Of Integer) From {3, 4, 5}
set1.UnionWith(set2) ' set1 now contains { 1, 2, 3, 4, 5 }

Intersection avec un autre HashSet

À l'aide de la fonction IntersectWith, déterminez les composants partagés entre deux instances de HashSet.

HashSet<int> set1 = new HashSet<int> { 1, 2, 3 };
HashSet<int> set2 = new HashSet<int> { 3, 4, 5 };
set1.IntersectWith(set2); // set1 now contains { 3 }

HashSet<int> set1 = new HashSet<int> { 1, 2, 3 };
HashSet<int> set2 = new HashSet<int> { 3, 4, 5 };
set1.IntersectWith(set2); // set1 now contains { 3 }

Dim set1 As New HashSet(Of Integer) From {1, 2, 3}
Dim set2 As New HashSet(Of Integer) From {3, 4, 5}
set1.IntersectWith(set2) ' set1 now contains { 3 }

Différence avec un autre HashSet

En utilisant la fonction ExceptWith, trouvez les éléments qui se trouvent dans un HashSet mais pas dans un autre.

HashSet<int> set1 = new HashSet<int> { 1, 2, 3 };
HashSet<int> set2 = new HashSet<int> { 3, 4, 5 };
set1.ExceptWith(set2); // set1 now contains { 1, 2 }

HashSet<int> set1 = new HashSet<int> { 1, 2, 3 };
HashSet<int> set2 = new HashSet<int> { 3, 4, 5 };
set1.ExceptWith(set2); // set1 now contains { 1, 2 }

Dim set1 As New HashSet(Of Integer) From {1, 2, 3}
Dim set2 As New HashSet(Of Integer) From {3, 4, 5}
set1.ExceptWith(set2) ' set1 now contains { 1, 2 }

Checking for Subset or Superset: (Vérification du sous-ensemble ou du surensemble)

Les méthodes IsSubsetOf et IsSupersetOf permettent de déterminer si une instance de HashSet donnée est un sous-ensemble ou un surensemble d'une autre instance.

HashSet<int> set1 = new HashSet<int> { 1, 2, 3 };
HashSet<int> set2 = new HashSet<int> { 2, 3 };
bool isSubset = set2.IsSubsetOf(set1); // returns true
bool isSuperset = set1.IsSupersetOf(set2); // returns true

HashSet<int> set1 = new HashSet<int> { 1, 2, 3 };
HashSet<int> set2 = new HashSet<int> { 2, 3 };
bool isSubset = set2.IsSubsetOf(set1); // returns true
bool isSuperset = set1.IsSupersetOf(set2); // returns true

Dim set1 As New HashSet(Of Integer) From {1, 2, 3}
Dim set2 As New HashSet(Of Integer) From {2, 3}
Dim isSubset As Boolean = set2.IsSubsetOf(set1) ' returns true
Dim isSuperset As Boolean = set1.IsSupersetOf(set2) ' returns true

Différence symétrique

En utilisant la technique SymmetricExceptWith, déterminez la différence symétrique (éléments présents dans un ensemble, mais pas dans les deux).

HashSet<int> set1 = new HashSet<int> { 1, 2, 3 };
HashSet<int> set2 = new HashSet<int> { 3, 4, 5 };
set1.SymmetricExceptWith(set2); // set1 now contains { 1, 2, 4, 5 }

HashSet<int> set1 = new HashSet<int> { 1, 2, 3 };
HashSet<int> set2 = new HashSet<int> { 3, 4, 5 };
set1.SymmetricExceptWith(set2); // set1 now contains { 1, 2, 4, 5 }

Dim set1 As New HashSet(Of Integer) From {1, 2, 3}
Dim set2 As New HashSet(Of Integer) From {3, 4, 5}
set1.SymmetricExceptWith(set2) ' set1 now contains { 1, 2, 4, 5 }

IronPDF

Les programmeurs peuvent utiliser le langage C# pour produire, éditer et modifier des documents PDF à l'aide de la fonction IronPDF bibliothèque PDF .NET. L'application offre un large éventail d'outils et de fonctionnalités permettant d'effectuer différentes opérations sur les fichiers PDF, notamment la création de nouveaux PDF à partir de HTML, la conversion de HTML en PDF, la combinaison ou la division de documents PDF et l'annotation de PDF existants avec du texte, des photos et d'autres données. Pour en savoir plus sur l'IronPDF, consultez le site suivant la documentation.

Caractéristiques d'IronPDF

• Conversion de HTML en PDF : Tout type de données HTML, y compris les fichiers, les URL et les chaînes de code HTML, peut être converti en documents PDF avec IronPDF.
• Génération de PDF : Du texte, des images et d'autres objets peuvent être ajoutés par programmation aux documents PDF à l'aide du langage de programmation C#.
• Manipulation de PDF : IronPDF peut diviser un fichier PDF en plusieurs fichiers et modifier des fichiers PDF préexistants. Il permet de fusionner plusieurs fichiers PDF en un seul fichier.
• Formulaires PDF : Comme la bibliothèque permet aux utilisateurs de créer et de remplir des formulaires PDF, elle est utile dans les scénarios où les données des formulaires doivent être collectées et traitées.
• Fonctionnalités de sécurité : IronPDF permet le cryptage des documents PDF ainsi que la sécurité des mots de passe et des autorisations.

Installer IronPDF

Acquérir la bibliothèque IronPDF ; le prochain correctif l'exige. Pour ce faire, entrez le code suivant dans le gestionnaire de paquets :

Install-Package IronPDF 
//or 
dotnet add package IronPdf

Une autre option consiste à rechercher le paquetage "IronPDF" à l'aide du gestionnaire de paquets NuGet. Parmi tous les paquets NuGet liés à IronPDF, nous pouvons sélectionner et télécharger le paquet requis dans cette liste.

HashSet avec IronPDF

Dans l'environnement C#, IronPDF est une bibliothèque puissante qui facilite le travail avec les documents PDF. Dans les situations où la représentation distincte des données et la création efficace de documents sont cruciales, la combinaison de l'efficacité de HashSet avec les pouvoirs de manipulation de documents d'IronPDF peut déboucher sur des solutions créatives.

Avantages de l'utilisation de HashSet avec IronPDF

• Réduction de la redondance des données : En garantissant que seuls les éléments distincts sont conservés, les HashSets permettent d'éviter la duplication des données. Cette fonction est très utile lorsqu'il s'agit de supprimer des informations en double dans des ensembles de données volumineux.
• Consultation efficace : Les opérations de base telles que l'insertion, la suppression et la consultation peuvent être effectuées avec une complexité moyenne en temps constant à l'aide de HashSet. Ce type de performance est très important lorsque l'on travaille avec des ensembles de données de tailles différentes.

• Production simplifiée de documents : IronPDF rationalise le processus de création de documents PDF C#. Vous pouvez mettre en place des processus rapides et efficaces pour produire un contenu original et dynamique pour vos PDF en intégrant HashSet à IronPDF.

  Examinons maintenant un scénario réel dans lequel l'utilisation de HashSet avec IronPDF pourrait être utile.

Générer un PDF avec des données uniques

using IronPdf;
using System;
using System.Collections.Generic;
using System.IO;
class PdfGenerator
{
    static void Main()
    {
        // Sample user names
        string [] userNames = { "Alice", "Bob", "Charlie", "Bob", "David", "Alice" };
        // Using HashSet to store unique user names
        HashSet<string> uniqueUserNames = new HashSet<string>(userNames);
        // Generating PDF with unique user names
        GeneratePdf(uniqueUserNames);
    }
    static void GeneratePdf(HashSet<string> uniqueUserNames)
    {
        // Create a new PDF document using IronPDF
        IronPdf.HtmlToPdf renderer = new IronPdf.HtmlToPdf();
        PdfDocument pdf = renderer.RenderHtmlAsPdf(BuildHtmlDocument(uniqueUserNames));
        // Save the PDF to a file
        string pdfFilePath = "UniqueUserNames.pdf";
        pdf.SaveAs(pdfFilePath);
        // Display a message with the file path
        Console.WriteLine($"PDF generated successfully. File saved at: {pdfFilePath}");
    }
    static string BuildHtmlDocument(HashSet<string> uniqueUserNames)
    {
        // Build an HTML document with unique user names
        string htmlDocument = "<html><body><ul>";
        foreach (var userName in uniqueUserNames)
        {
            htmlDocument += $"<li>{userName}</li>";
        }
        htmlDocument += "</ul></body></html>";
        return htmlDocument;
    }
}

using IronPdf;
using System;
using System.Collections.Generic;
using System.IO;
class PdfGenerator
{
    static void Main()
    {
        // Sample user names
        string [] userNames = { "Alice", "Bob", "Charlie", "Bob", "David", "Alice" };
        // Using HashSet to store unique user names
        HashSet<string> uniqueUserNames = new HashSet<string>(userNames);
        // Generating PDF with unique user names
        GeneratePdf(uniqueUserNames);
    }
    static void GeneratePdf(HashSet<string> uniqueUserNames)
    {
        // Create a new PDF document using IronPDF
        IronPdf.HtmlToPdf renderer = new IronPdf.HtmlToPdf();
        PdfDocument pdf = renderer.RenderHtmlAsPdf(BuildHtmlDocument(uniqueUserNames));
        // Save the PDF to a file
        string pdfFilePath = "UniqueUserNames.pdf";
        pdf.SaveAs(pdfFilePath);
        // Display a message with the file path
        Console.WriteLine($"PDF generated successfully. File saved at: {pdfFilePath}");
    }
    static string BuildHtmlDocument(HashSet<string> uniqueUserNames)
    {
        // Build an HTML document with unique user names
        string htmlDocument = "<html><body><ul>";
        foreach (var userName in uniqueUserNames)
        {
            htmlDocument += $"<li>{userName}</li>";
        }
        htmlDocument += "</ul></body></html>";
        return htmlDocument;
    }
}

Imports IronPdf
Imports System
Imports System.Collections.Generic
Imports System.IO
Friend Class PdfGenerator
	Shared Sub Main()
		' Sample user names
		Dim userNames() As String = { "Alice", "Bob", "Charlie", "Bob", "David", "Alice" }
		' Using HashSet to store unique user names
		Dim uniqueUserNames As New HashSet(Of String)(userNames)
		' Generating PDF with unique user names
		GeneratePdf(uniqueUserNames)
	End Sub
	Private Shared Sub GeneratePdf(ByVal uniqueUserNames As HashSet(Of String))
		' Create a new PDF document using IronPDF
		Dim renderer As New IronPdf.HtmlToPdf()
		Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(BuildHtmlDocument(uniqueUserNames))
		' Save the PDF to a file
		Dim pdfFilePath As String = "UniqueUserNames.pdf"
		pdf.SaveAs(pdfFilePath)
		' Display a message with the file path
		Console.WriteLine($"PDF generated successfully. File saved at: {pdfFilePath}")
	End Sub
	Private Shared Function BuildHtmlDocument(ByVal uniqueUserNames As HashSet(Of String)) As String
		' Build an HTML document with unique user names
		Dim htmlDocument As String = "<html><body><ul>"
		For Each userName In uniqueUserNames
			htmlDocument &= $"<li>{userName}</li>"
		Next userName
		htmlDocument &= "</ul></body></html>"
		Return htmlDocument
	End Function
End Class

Dans l'exemple de code ci-dessus, nous enregistrons les noms d'utilisateurs uniques extraits d'un tableau à l'aide d'un ensemble de hachage uniqueUserNames. Le HashSet élimine automatiquement les doublons. Ensuite, nous créons une liste non ordonnée de ces noms d'utilisateurs distincts dans un document PDF à l'aide d'IronPDF. Pour en savoir plus sur le code, consultez ici.

SORTIE

Conclusion

En résumé, la structure de données C# HashSet est un outil efficace pour organiser des ensembles d'éléments distincts. Associé à IronPDF, il ouvre de nouvelles perspectives pour la création de documents PDF dynamiques, uniques et aux performances optimisées.

Nous avons montré comment utiliser HashSet pour garantir l'unicité des données tout en utilisant IronPDF pour créer des documents PDF dans l'exemple donné. La création d'applications C# solides et efficaces peut bénéficier de la combinaison de HashSet et d'IronPDF, que vous travailliez sur la déduplication des données, la création de rapports ou la gestion de contenu dynamique. Au fur et à mesure de vos recherches, tenez compte des nombreux contextes dans lesquels vous pourriez utiliser cette combinaison pour améliorer la convivialité et la fonctionnalité de vos applications.

La $749 version Lite d'IronPDF est livrée avec une licence permanente, des options de mise à niveau et un an d'assistance logicielle. Tout au long de la période d'essai pour en savoir plus sur le prix, la licence et l'essai gratuit d'IronPDF. Visiter ce site page pour de plus amples informations sur Iron Software.