HashSet C# (Wie es für Entwickler funktioniert)

Einführung

Die Programmierung in C# ist flexibel und bietet eine große Anzahl von Datenstrukturen, um verschiedene Aufgaben effektiv zu verwalten. Die HashSet ist eine solche leistungsfähige Datenstruktur, die eindeutige Komponenten und eine zeitlich konstante durchschnittliche Komplexität für grundlegende Operationen bietet. In diesem Beitrag wird die Verwendung von HashSet in C# untersucht und wie es mit IronPDFeine leistungsstarke Bibliothek für die Arbeit mit PDF-Dokumenten.

Wie verwendet man HashSet C#

1. Erstellen Sie ein neues Console App-Projekt.

2. Erstellen Sie ein Objekt für das HashSet in C#. Fügen Sie den Standardwert zum HashSet hinzu.

3. Beim Hinzufügen entfernt HashSet automatisch doppelte Elemente, indem es überprüft, ob das Element existiert.

4. Verarbeitet das HashSet nur eindeutige Elemente nacheinander.

5. Zeigen Sie das Ergebnis an und entsorgen Sie das Objekt.

Verstehen von HashSet in C##

HashSet in C# wurde entwickelt, um leistungsstarke Mengenoperationen zu ermöglichen. Ein HashSet ist die perfekte Sammlung für Situationen, in denen Sie einen bestimmten Datensatz aufbewahren müssen, da sie doppelte Elemente verhindert. Sie ist in den System.Assortments.Hash-Tabellen enthalten, die die Grundlage des generischen C#-Namensraums bilden, und ermöglicht schnelles Einfügen, Löschen, schnelleres Abrufen und Nachschlagen. Wir können die richtige Teilmenge auch in den HashSet-Elementen finden. Verwenden Sie in C# die HashSet-Methoden für Mengenoperationen, mit denen Sie problemlos Standardmengenoperationen durchführen können. Die Klasse HashSet bietet Methoden für Mengenoperationen.

Im Folgenden werden einige C#-Anwendungen für ein HashSet aufgeführt:

Initialisierung und Grundoperationen

Aufbau eines HashSets und Durchführung grundlegender Aktionen wie Anhängen, Löschen und Überprüfen der Existenz von Einträgen.

// 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)

Initialisierung mit Sammlung

Wird eine vorhandene Sammlung als Ausgangspunkt für ein HashSet verwendet, werden Duplikate sofort entfernt.

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)

Vereinigung mit einem anderen HashSet

Kombinieren von zwei HashSet-Instanzen, um eine neue Menge zu erzeugen, die unterschiedliche Elemente aus beiden Mengen unter Verwendung der Funktion UnionWith kombiniert.

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 }

Schnittpunkt mit einem anderen HashSet

Bestimmen Sie mit der Funktion IntersectWith die gemeinsamen Komponenten zwischen zwei HashSet-Instanzen.

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 }

Unterschied zu einem anderen HashSet

Suchen Sie mit der Funktion ExceptWith die Elemente, die in einem HashSet enthalten sind, aber nicht in einem anderen.

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 }

Prüfung auf Teilmenge oder Obermenge:

Mit den Methoden IsSubsetOf und IsSupersetOf kann man feststellen, ob eine gegebene HashSet-Instanz eine Teilmenge oder Obermenge einer anderen ist.

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

Symmetrische Differenz

Bestimmen Sie mit Hilfe der SymmetricExceptWith-Technik die symmetrische Differenz (elemente, die in einem Satz vorhanden sind, aber nicht in beiden).

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

Programmierer können die Sprache C# verwenden, um PDF-Dokumente zu erstellen, zu bearbeiten und zu ändern, indem sie die IronPDF .NET PDF-Bibliothek. Die Anwendung bietet eine breite Palette von Werkzeugen und Funktionen, um verschiedene Operationen mit PDF-Dateien zu ermöglichen, einschließlich der Erstellung neuer PDFs aus HTML, der Konvertierung von HTML in PDF, der Kombination oder Aufteilung von PDF-Dokumenten und der Kommentierung bestehender PDFs mit Text, Fotos und anderen Daten. Weitere Informationen über IronPDF finden Sie hier dokumentation.

Merkmale von IronPDF

• Konvertierung von HTML in PDF: Jede Art von HTML-Daten, einschließlich Dateien, URLs und HTML-Code-Strings, kann mit IronPDF in PDF-Dokumente umgewandelt werden.
• PDF-Erzeugung: Text, Bilder und andere Objekte können mithilfe der Programmiersprache C# programmgesteuert zu PDF-Dokumenten hinzugefügt werden.
• PDF-Bearbeitung: IronPDF kann eine PDF-Datei in mehrere Dateien aufteilen und bereits existierende PDF-Dateien bearbeiten. Es kann mehrere PDF-Dateien zu einer einzigen Datei zusammenführen.
• PDF-Formulare: Da die Bibliothek es den Benutzern ermöglicht, PDF-Formulare zu erstellen und auszufüllen, ist sie in Szenarien nützlich, in denen Formulardaten gesammelt und verarbeitet werden müssen.
• Sicherheitsfunktionen: IronPDF ermöglicht die Verschlüsselung von PDF-Dokumenten sowie die Sicherheit von Passwörtern und Berechtigungen.

IronPDF installieren

Erwerben Sie die IronPDF-Bibliothek; der kommende Patch erfordert dies. Geben Sie dazu den folgenden Code in den Paketmanager ein:

Install-Package IronPDF 
//or 
dotnet add package IronPdf

Eine weitere Möglichkeit ist die Suche nach dem Paket "IronPDF" über den NuGet Package Manager. Aus allen NuGet-Paketen, die mit IronPDF in Verbindung stehen, können wir das gewünschte Paket aus dieser Liste auswählen und herunterladen.

HashSet mit IronPDF

In der C#-Umgebung ist IronPDF eine leistungsstarke Bibliothek, die die Arbeit mit PDF-Dokumenten erleichtert. In Situationen, in denen eine eindeutige Datendarstellung und eine effektive Dokumentenerstellung von entscheidender Bedeutung sind, kann die Kombination der Effizienz von HashSet mit den Fähigkeiten von IronPDF zur Dokumentenbearbeitung zu kreativen Lösungen führen.

Vorteile der Verwendung von HashSet mit IronPDF

• Reduzierung der Datenredundanz: Indem sichergestellt wird, dass nur eindeutige Elemente gespeichert werden, tragen HashSets zur Vermeidung von Datenduplikaten bei. Bei der Bearbeitung großer Datensätze zur Entfernung doppelter Informationen ist dies sehr hilfreich.
• Effektives Nachschlagen: Grundlegende Operationen wie Einfügen, Löschen und Nachschlagen können mit konstanter durchschnittlicher Komplexität mit HashSet durchgeführt werden. Diese Art von Leistung ist bei der Arbeit mit unterschiedlich großen Datensätzen sehr wichtig.

• Vereinfachte Produktion von Dokumenten: IronPDF rationalisiert den Prozess der Erstellung von C# PDF-Dokumenten. Durch die Integration von HashSet mit IronPDF können Sie schnelle und effektive Prozesse für die Erstellung origineller und dynamischer Inhalte für Ihre PDFs einrichten.

  Sehen wir uns nun ein reales Szenario an, in dem die Verwendung von HashSet mit IronPDF nützlich sein könnte.

PDF mit eindeutigen Daten generieren

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

Im obigen Codebeispiel werden eindeutige Benutzernamen gespeichert, die aus einem Array mit einem HashSet uniqueUserNames abgerufen werden. Das HashSet eliminiert automatisch Duplikate. Als nächstes erstellen wir mit IronPDF eine ungeordnete Liste dieser eindeutigen Benutzernamen in einem PDF-Dokument. Weitere Informationen über den Code finden Sie unter hier.

AUSGABE

Schlussfolgerung

Zusammenfassend lässt sich sagen, dass die C# HashSet-Datenstruktur ein effektives Werkzeug für die Organisation von Mengen unterschiedlicher Elemente ist. In Verbindung mit IronPDF ergeben sich neue Möglichkeiten für die dynamische, einzigartige und leistungsoptimierte Erstellung von PDF-Dokumenten.

Wir haben veranschaulicht, wie man HashSet verwendet, um die Eindeutigkeit der Daten zu garantieren, während man IronPDF zur Erstellung von PDF-Dokumenten in dem genannten Beispiel. Bei der Entwicklung leistungsfähiger und effektiver C#-Anwendungen können Sie von der Kombination aus HashSet und IronPDF profitieren, ganz gleich, ob Sie an der Datendeduplizierung, der Berichterstellung oder der Verwaltung dynamischer Inhalte arbeiten. Berücksichtigen Sie bei Ihren Recherchen die vielen Möglichkeiten, wie Sie diese Kombination zur Verbesserung der Benutzerfreundlichkeit und Funktionalität Ihrer Anwendungen einsetzen können.

Die $749 Lite-Version von IronPDF wird mit einer permanenten Lizenz, Upgrade-Optionen und einem Jahr Software-Support geliefert. In der gesamten mit Wasserzeichen versehenen probezeit um mehr über den Preis, die Lizenzierung und die kostenlose Testversion von IronPDF zu erfahren. Besuchen Sie diese seite für weitere Informationen über Iron Software.