Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. .NET Aide
  4. HashSet C#
.NET AIDE

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

Jacob Mellor, Directeur technique @ Team Iron
Jacob Mellor
Mis à jour:

La programmation en C# est flexible et offre un large éventail de structures de données pour gérer efficacement divers travaux. Le HashSet est une structure de données puissante qui offre des composants distincts et une complexité moyenne en temps constant pour les opérations fondamentales. Ce post examinera l'utilisation de HashSet en C# et comment il peut être utilisé avec IronPDF, une bibliothèque puissante pour travailler avec des documents PDF.

Comment utiliser HashSet en C\

  1. Créez un nouveau projet d'application console.
  2. Créez un objet pour le HashSet en C#. Ajoutez la valeur par défaut au HashSet.
  3. Lors de l'ajout, HashSet supprimera automatiquement les éléments en double en vérifiant si l'élément existe.
  4. Traitez uniquement les éléments uniques de HashSet un par un.
  5. Affichez le résultat et disposez de l'objet.

Comprendre HashSet en C\

HashSet en C# est conçu pour offrir des opérations d'ensemble haute performance. Un HashSet est la collection parfaite à utiliser dans des situations où vous avez besoin de conserver un ensemble de données distinct car il empêche les éléments en double. Il est inclus dans l'espace de noms System.Collections.Generic et offre des opérations d'insertion rapide, de suppression, de récupération et de recherche. En C#, utilisez les méthodes d'opérations d'ensemble de HashSet qui vous permettent d'effectuer facilement des opérations d'ensemble standard. La classe HashSet offre des méthodes d'opérations d'ensemble.

Voici quelques utilisations de HashSet en C#:

Initialisation et opérations de base

Établir un HashSet et effectuer des actions fondamentales telles que l'ajout, la suppression et la vérification de l'existence des entrées.

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // Initializes a HashSet of integers
        HashSet<int> numbers = new HashSet<int>();

        // Adds elements to the HashSet
        numbers.Add(1);
        numbers.Add(2);
        numbers.Add(3);

        // Removes an element from the HashSet
        numbers.Remove(2);

        // Checks for membership of an element
        bool containsThree = numbers.Contains(3);

        Console.WriteLine($"Contains 3: {containsThree}");
    }
}
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // Initializes a HashSet of integers
        HashSet<int> numbers = new HashSet<int>();

        // Adds elements to the HashSet
        numbers.Add(1);
        numbers.Add(2);
        numbers.Add(3);

        // Removes an element from the HashSet
        numbers.Remove(2);

        // Checks for membership of an element
        bool containsThree = numbers.Contains(3);

        Console.WriteLine($"Contains 3: {containsThree}");
    }
}
Imports System
Imports System.Collections.Generic

Friend Class Program
	Shared Sub Main()
		' Initializes a HashSet of integers
		Dim numbers As New HashSet(Of Integer)()

		' Adds elements to the HashSet
		numbers.Add(1)
		numbers.Add(2)
		numbers.Add(3)

		' Removes an element from the HashSet
		numbers.Remove(2)

		' Checks for membership of an element
		Dim containsThree As Boolean = numbers.Contains(3)

		Console.WriteLine($"Contains 3: {containsThree}")
	End Sub
End Class
$vbLabelText   $csharpLabel

Initialisation avec collection

L'utilisation d'une collection existante comme point de départ pour un HashSet élimine immédiatement les doublons.

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // Creates a list with duplicate elements
        List<int> duplicateNumbers = new List<int> { 1, 2, 2, 3, 3, 4 };

        // Initializes a HashSet with the list, automatically removes duplicates
        HashSet<int> uniqueNumbers = new HashSet<int>(duplicateNumbers);

        Console.WriteLine("Unique numbers:");
        foreach (var number in uniqueNumbers)
        {
            Console.WriteLine(number);
        }
    }
}
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // Creates a list with duplicate elements
        List<int> duplicateNumbers = new List<int> { 1, 2, 2, 3, 3, 4 };

        // Initializes a HashSet with the list, automatically removes duplicates
        HashSet<int> uniqueNumbers = new HashSet<int>(duplicateNumbers);

        Console.WriteLine("Unique numbers:");
        foreach (var number in uniqueNumbers)
        {
            Console.WriteLine(number);
        }
    }
}
Imports System
Imports System.Collections.Generic

Friend Class Program
	Shared Sub Main()
		' Creates a list with duplicate elements
		Dim duplicateNumbers As New List(Of Integer) From {1, 2, 2, 3, 3, 4}

		' Initializes a HashSet with the list, automatically removes duplicates
		Dim uniqueNumbers As New HashSet(Of Integer)(duplicateNumbers)

		Console.WriteLine("Unique numbers:")
		For Each number In uniqueNumbers
			Console.WriteLine(number)
		Next number
	End Sub
End Class
$vbLabelText   $csharpLabel

Union avec un autre HashSet

La combinaison de deux instances de HashSet pour produire un nouvel ensemble qui combine des éléments distincts des deux ensembles en utilisant la fonction UnionWith.

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        HashSet<int> set1 = new HashSet<int> { 1, 2, 3 };
        HashSet<int> set2 = new HashSet<int> { 3, 4, 5 };

        // Merges set2 into set1
        set1.UnionWith(set2);

        Console.WriteLine("Union of set1 and set2:");
        foreach (var item in set1)
        {
            Console.WriteLine(item);
        }
    }
}
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        HashSet<int> set1 = new HashSet<int> { 1, 2, 3 };
        HashSet<int> set2 = new HashSet<int> { 3, 4, 5 };

        // Merges set2 into set1
        set1.UnionWith(set2);

        Console.WriteLine("Union of set1 and set2:");
        foreach (var item in set1)
        {
            Console.WriteLine(item);
        }
    }
}
Imports System
Imports System.Collections.Generic

Friend Class Program
	Shared Sub Main()
		Dim set1 As New HashSet(Of Integer) From {1, 2, 3}
		Dim set2 As New HashSet(Of Integer) From {3, 4, 5}

		' Merges set2 into set1
		set1.UnionWith(set2)

		Console.WriteLine("Union of set1 and set2:")
		For Each item In set1
			Console.WriteLine(item)
		Next item
	End Sub
End Class
$vbLabelText   $csharpLabel

Intersection avec un autre HashSet

Utilisation de la fonction IntersectWith pour déterminer les composants partagés entre deux instances de HashSet.

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        HashSet<int> set1 = new HashSet<int> { 1, 2, 3 };
        HashSet<int> set2 = new HashSet<int> { 3, 4, 5 };

        // Keeps only elements that are present in both sets
        set1.IntersectWith(set2);

        Console.WriteLine("Intersection of set1 and set2:");
        foreach (var item in set1)
        {
            Console.WriteLine(item);
        }
    }
}
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        HashSet<int> set1 = new HashSet<int> { 1, 2, 3 };
        HashSet<int> set2 = new HashSet<int> { 3, 4, 5 };

        // Keeps only elements that are present in both sets
        set1.IntersectWith(set2);

        Console.WriteLine("Intersection of set1 and set2:");
        foreach (var item in set1)
        {
            Console.WriteLine(item);
        }
    }
}
Imports System
Imports System.Collections.Generic

Friend Class Program
	Shared Sub Main()
		Dim set1 As New HashSet(Of Integer) From {1, 2, 3}
		Dim set2 As New HashSet(Of Integer) From {3, 4, 5}

		' Keeps only elements that are present in both sets
		set1.IntersectWith(set2)

		Console.WriteLine("Intersection of set1 and set2:")
		For Each item In set1
			Console.WriteLine(item)
		Next item
	End Sub
End Class
$vbLabelText   $csharpLabel

Différence avec un autre HashSet

Utilisation de la fonction ExceptWith pour trouver les éléments qui se trouvent dans un HashSet mais pas dans un autre.

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        HashSet<int> set1 = new HashSet<int> { 1, 2, 3 };
        HashSet<int> set2 = new HashSet<int> { 3, 4, 5 };

        // Removes elements from set1 that are also in set2
        set1.ExceptWith(set2);

        Console.WriteLine("Difference of set1 and set2:");
        foreach (var item in set1)
        {
            Console.WriteLine(item);
        }
    }
}
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        HashSet<int> set1 = new HashSet<int> { 1, 2, 3 };
        HashSet<int> set2 = new HashSet<int> { 3, 4, 5 };

        // Removes elements from set1 that are also in set2
        set1.ExceptWith(set2);

        Console.WriteLine("Difference of set1 and set2:");
        foreach (var item in set1)
        {
            Console.WriteLine(item);
        }
    }
}
Imports System
Imports System.Collections.Generic

Friend Class Program
	Shared Sub Main()
		Dim set1 As New HashSet(Of Integer) From {1, 2, 3}
		Dim set2 As New HashSet(Of Integer) From {3, 4, 5}

		' Removes elements from set1 that are also in set2
		set1.ExceptWith(set2)

		Console.WriteLine("Difference of set1 and set2:")
		For Each item In set1
			Console.WriteLine(item)
		Next item
	End Sub
End Class
$vbLabelText   $csharpLabel

Vérification de sous-ensemble ou sur-ensemble :

Avec les méthodes IsSubsetOf et IsSupersetOf, on peut déterminer si une instance donnée de HashSet est un sous-ensemble ou un sur-ensemble d'un autre.

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        HashSet<int> set1 = new HashSet<int> { 1, 2, 3 };
        HashSet<int> set2 = new HashSet<int> { 2, 3 };

        // Checks if set2 is a subset of set1
        bool isSubset = set2.IsSubsetOf(set1);

        // Checks if set1 is a superset of set2
        bool isSuperset = set1.IsSupersetOf(set2);

        Console.WriteLine($"Is set2 a subset of set1: {isSubset}");
        Console.WriteLine($"Is set1 a superset of set2: {isSuperset}");
    }
}
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        HashSet<int> set1 = new HashSet<int> { 1, 2, 3 };
        HashSet<int> set2 = new HashSet<int> { 2, 3 };

        // Checks if set2 is a subset of set1
        bool isSubset = set2.IsSubsetOf(set1);

        // Checks if set1 is a superset of set2
        bool isSuperset = set1.IsSupersetOf(set2);

        Console.WriteLine($"Is set2 a subset of set1: {isSubset}");
        Console.WriteLine($"Is set1 a superset of set2: {isSuperset}");
    }
}
Imports System
Imports System.Collections.Generic

Friend Class Program
	Shared Sub Main()
		Dim set1 As New HashSet(Of Integer) From {1, 2, 3}
		Dim set2 As New HashSet(Of Integer) From {2, 3}

		' Checks if set2 is a subset of set1
		Dim isSubset As Boolean = set2.IsSubsetOf(set1)

		' Checks if set1 is a superset of set2
		Dim isSuperset As Boolean = set1.IsSupersetOf(set2)

		Console.WriteLine($"Is set2 a subset of set1: {isSubset}")
		Console.WriteLine($"Is set1 a superset of set2: {isSuperset}")
	End Sub
End Class
$vbLabelText   $csharpLabel

Différence symétrique

Utilisation de la technique SymmetricExceptWith pour déterminer la différence symétrique (éléments présents dans un ensemble, mais pas dans les deux).

using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        HashSet<int> set1 = new HashSet<int> { 1, 2, 3 };
        HashSet<int> set2 = new HashSet<int> { 3, 4, 5 };

        // Keeps elements that are in set1 or set2 but not in both
        set1.SymmetricExceptWith(set2);

        Console.WriteLine("Symmetric difference of set1 and set2:");
        foreach (var item in set1)
        {
            Console.WriteLine(item);
        }
    }
}
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        HashSet<int> set1 = new HashSet<int> { 1, 2, 3 };
        HashSet<int> set2 = new HashSet<int> { 3, 4, 5 };

        // Keeps elements that are in set1 or set2 but not in both
        set1.SymmetricExceptWith(set2);

        Console.WriteLine("Symmetric difference of set1 and set2:");
        foreach (var item in set1)
        {
            Console.WriteLine(item);
        }
    }
}
Imports System
Imports System.Collections.Generic

Friend Class Program
	Shared Sub Main()
		Dim set1 As New HashSet(Of Integer) From {1, 2, 3}
		Dim set2 As New HashSet(Of Integer) From {3, 4, 5}

		' Keeps elements that are in set1 or set2 but not in both
		set1.SymmetricExceptWith(set2)

		Console.WriteLine("Symmetric difference of set1 and set2:")
		For Each item In set1
			Console.WriteLine(item)
		Next item
	End Sub
End Class
$vbLabelText   $csharpLabel

IronPDF

Les programmeurs peuvent utiliser le langage C# pour produire, éditer et modifier des documents PDF en utilisant la bibliothèque IronPDF pour .NET. L'application offre une large gamme d'outils et de fonctionnalités permettant d'effectuer différentes opérations avec des fichiers PDF, y compris 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 IronPDF, référez-vous à la documentation officielle.

IronPDF excelle dans la conversion HTML en PDF, garantissant une préservation précise des mises en page et styles originaux. Il est parfait pour créer des PDF à partir de contenus basés sur le Web tels que des rapports, des factures et de la documentation. Avec le support des fichiers HTML, des URLs et des chaînes HTML brutes, IronPDF produit facilement des documents PDF de haute qualité.

using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}
using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();

        // 1. Convert HTML String to PDF
        var htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>";
        var pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent);
        pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf");

        // 2. Convert HTML File to PDF
        var htmlFilePath = "path_to_your_html_file.html"; // Specify the path to your HTML file
        var pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath);
        pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf");

        // 3. Convert URL to PDF
        var url = "http://ironpdf.com"; // Specify the URL
        var pdfFromUrl = renderer.RenderUrlAsPdf(url);
        pdfFromUrl.SaveAs("URLToPDF.pdf");
    }
}
Imports IronPdf

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim renderer = New ChromePdfRenderer()

		' 1. Convert HTML String to PDF
		Dim htmlContent = "<h1>Hello, IronPDF!</h1><p>This is a PDF from an HTML string.</p>"
		Dim pdfFromHtmlString = renderer.RenderHtmlAsPdf(htmlContent)
		pdfFromHtmlString.SaveAs("HTMLStringToPDF.pdf")

		' 2. Convert HTML File to PDF
		Dim htmlFilePath = "path_to_your_html_file.html" ' Specify the path to your HTML file
		Dim pdfFromHtmlFile = renderer.RenderHtmlFileAsPdf(htmlFilePath)
		pdfFromHtmlFile.SaveAs("HTMLFileToPDF.pdf")

		' 3. Convert URL to PDF
		Dim url = "http://ironpdf.com" ' Specify the URL
		Dim pdfFromUrl = renderer.RenderUrlAsPdf(url)
		pdfFromUrl.SaveAs("URLToPDF.pdf")
	End Sub
End Class
$vbLabelText   $csharpLabel

Caractéristiques de IronPDF

  • Conversion de HTML en PDF : Tout type de données HTML, y compris les fichiers, URL, et 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 de façon programmation à des documents PDF en utilisant le langage de programmation C#.
  • Manipulation de PDF : IronPDF peut diviser un fichier PDF en plusieurs fichiers et modifier des fichiers PDF préexistants. Il peut fusionner plusieurs fichiers PDF en un seul fichier.
  • Formulaires PDF : Comme la bibliothèque permet aux utilisateurs de créer et de compléter 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é par mot de passe et permission.

Installer IronPDF

Acquérir la bibliothèque IronPDF ; la prochaine mise à jour l'exige. Pour ce faire, entrez le code suivant dans le gestionnaire de packages :

Install-Package IronPdf

ou

dotnet add package IronPdf

HashSet C# (How It Works For Developers): Figure 1 - Install IronPDF library using Package Manager Console and entering the following commands: Install-Package IronPDF or dotnet add package IronPdf.

Une autre option est de rechercher le package "IronPDF" à l'aide du Gestionnaire de packages NuGet. Parmi tous les packages NuGet liés à IronPDF, nous pouvons sélectionner et télécharger le package requis de cette liste.

HashSet C# (Comment cela fonctionne pour les développeurs) : Figure 2 - Vous pouvez installer la bibliothèque IronPDF en utilisant le gestionnaire de packages NuGet. Recherchez le package IronPDF dans l'onglet Parcourir, puis sélectionnez et installez la dernière version de l'IronPDF.

HashSet avec IronPDF

Dans l'environnement C#, IronPDF est une bibliothèque puissante qui facilite le travail avec les documents PDF. Dans des situations où la représentation de données distinctes et la création de documents efficaces sont cruciales, la combinaison de l'efficacité de HashSet avec les pouvoirs de manipulation de documents d'IronPDF pourrait aboutir à des solutions innovantes.

Avantages de l'utilisation de HashSet avec IronPDF

  • Réduction de la redondance des données : En veillant à ce que seuls les éléments distincts soient conservés, les HashSets contribuent à éviter la duplication des données. Lorsque vous traitez des ensembles de données volumineux pour éliminer les informations en double, cela est très utile.
  • Recherche efficace : Les opérations de base telles que l'insertion, la suppression et la recherche peuvent être effectuées avec une complexité moyenne en temps constant à l'aide de HashSet. Ce type de performance est très important lorsque vous travaillez avec des ensembles de données de différentes tailles.
  • Production simplifiée de documents : IronPDF simplifie le processus de création de documents PDF en C#. Vous pouvez établir des processus rapides et efficaces pour produire un contenu original et dynamique pour vos PDFs en intégrant HashSet avec IronPDF.

Voyons maintenant un scénario réel où l'utilisation de HashSet avec IronPDF pourrait être utile.

Génération de PDF avec des données uniques

using IronPdf;
using System;
using System.Collections.Generic;

class PdfGenerator
{
    static void Main()
    {
        // Sample user names with duplicates
        string[] userNames = { "Alice", "Bob", "Charlie", "Bob", "David", "Alice" };

        // Using HashSet to ensure 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
        HtmlToPdf renderer = new HtmlToPdf();

        // Render a PDF from an HTML document consisting of unique user names
        var 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;

class PdfGenerator
{
    static void Main()
    {
        // Sample user names with duplicates
        string[] userNames = { "Alice", "Bob", "Charlie", "Bob", "David", "Alice" };

        // Using HashSet to ensure 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
        HtmlToPdf renderer = new HtmlToPdf();

        // Render a PDF from an HTML document consisting of unique user names
        var 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

Friend Class PdfGenerator
	Shared Sub Main()
		' Sample user names with duplicates
		Dim userNames() As String = { "Alice", "Bob", "Charlie", "Bob", "David", "Alice" }

		' Using HashSet to ensure 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 HtmlToPdf()

		' Render a PDF from an HTML document consisting of unique user names
		Dim pdf = 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
$vbLabelText   $csharpLabel

Dans l'exemple de code ci-dessus, nous enregistrons des noms d'utilisateurs uniques récupérés à partir d'un tableau en utilisant un HashSet uniqueUserNames. Le HashSet élimine automatiquement les doublons. Ensuite, nous créons une liste non ordonnée de ces noms d'utilisateur distincts dans un document PDF à l'aide d'IronPDF. Pour en savoir plus sur le code, consultez utiliser HTML pour créer un PDF.

Sortie

HashSet C# (Fonctionnement pour les développeurs) : Figure 3 - Soutie : UniqueUserNames.pdf

Conclusion

En résumé, la structure de données HashSet en C# est un outil efficace pour organiser des ensembles d'éléments distincts. Elle crée de nouvelles opportunités pour la création de documents PDF dynamiques, uniques et optimisés en termes de performance, lorsqu'elle est associée à IronPDF.

Nous avons illustré comment utiliser HashSet pour garantir l'unicité des données tout en utilisant IronPDF pour créer des documents PDF dans l'exemple qui a été donné. La construction d'applications C# robustes et efficaces peut bénéficier de la combinaison de HashSet et IronPDF, que vous travailliez sur la déduplication de données, les rapports ou la gestion de contenu dynamique. En explorant davantage, tenez compte des nombreux contextes dans lesquels vous pourriez utiliser cette combinaison pour améliorer la convivialité et la fonction de vos applications.

La version Lite d'IronPDF est fournie avec une licence permanente, des options de mise à niveau et un an de support logiciel. Tout au long de la période d'essai avec filigrane, pour en savoir plus sur le prix, la licence et l'essai gratuit d'IronPDF. Visitez le site web Iron Software pour obtenir plus d'informations sur Iron Software.

Questions Fréquemment Posées

Comment puis-je garantir des données uniques lors de la génération de documents PDF en C# ?

Vous pouvez utiliser un HashSet pour stocker des éléments de données uniques, comme des noms d'utilisateur, avant de générer votre document PDF. Cela garantit que les entrées en double sont supprimées, offrant un contenu PDF plus propre et plus précis.

Quel est l'avantage d'utiliser un HashSet avec IronPDF ?

Utiliser un HashSet avec IronPDF permet une gestion efficace de données uniques lors de la création de PDF. Le HashSet garantit l'unicité des données, tandis qu'IronPDF excelle dans la conversion de contenu HTML en PDF, en préservant les mises en page et les styles.

Comment convertir du contenu HTML en PDF en C# ?

Vous pouvez convertir du contenu HTML en PDF en C# en utilisant la méthode RenderHtmlAsPdf d'IronPDF. Cette méthode vous permet de convertir directement des chaînes HTML en PDF, en conservant la mise en page et le style d'origine.

Quelles opérations un HashSet prend-il en charge en C# ?

HashSet en C# prend en charge une variété d'opérations d'ensemble telles que UnionWith, IntersectWith, ExceptWith, et SymmetricExceptWith, qui facilitent la manipulation efficace des données et les comparaisons d'ensembles.

Comment puis-je intégrer un HashSet à la création de documents PDF ?

Pour intégrer un HashSet à la création de documents PDF, utilisez le HashSet pour gérer et filtrer vos données afin d'assurer leur unicité avant de les transmettre à IronPDF pour générer le document PDF final.

Quel est le rôle d'un HashSet dans la gestion de contenu dynamique ?

Dans la gestion de contenu dynamique, un HashSet joue un rôle crucial en garantissant que les données restent uniques, ce qui est essentiel pour des tâches telles que la génération de documents, la production de rapports, et le maintien de l'intégrité des données.

Comment installer IronPDF dans un projet C#?

Vous pouvez installer IronPDF dans un projet C# en utilisant le gestionnaire de packages NuGet avec la commande : Install-Package IronPDF, ou en utilisant la CLI .NET avec : dotnet add package IronPDF.

Un HashSet peut-il améliorer la performance des applications C# ?

Oui, un HashSet peut améliorer considérablement la performance des applications C# en fournissant une complexité temporelle constante pour les opérations de base telles que l'insertion, la suppression et la recherche, ce qui le rend efficace pour gérer de grands ensembles de données.

Jacob Mellor, Directeur technique @ Team Iron
Jacob Mellor
  Discutez maintenant avec l'équipe d'ingénierie
Directeur technique

Jacob Mellor est directeur de la technologie chez Iron Software et un ingénieur visionnaire pionnier de la technologie C# PDF. En tant que développeur à l'origine de la base de code centrale d'Iron Software, il a façonné l'architecture des produits de l'entreprise depuis sa création, ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Essai gratuit

Équipe de soutien Iron

Nous sommes en ligne 24 heures sur 24, 5 jours sur 7.
Chat
Email
Appelez-moi