Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. .NET Hilfe
  4. C# LINQ Distinct Anleitung
.NET HILFE

C# LINQ Distinct (Funktionsweise für Entwickler)

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
Aktualisiert:

Die Abfragesprache Language-integrated query (LINQ), ein mächtiges Sprachfeature in C#, ermöglicht Programmierern das Erstellen klarer, ausdrucksstarker Abfragen für eine Vielzahl von Datenquellen. Dieser Beitrag wird die Verwendung von IronPDF, einer vielseitigen C#-Bibliothek zur Arbeit mit PDF-Dokumenten, unter Verwendung der Funktion LINQ's Distinct diskutieren. Wir werden zeigen, wie diese Kombination den Prozess der Erstellung einzigartiger Dokumente aus einer Sammlung erleichtern kann. In diesem Artikel werden wir die C# LINQ distinct Funktion mit IronPDF kennenlernen.

Wie man C# LINQ Distinct Method verwendet

  1. Erstellen Sie ein neues Konsolenprojekt.
  2. Importieren Sie den Namensraum System.Linq.
  3. Erstellen Sie eine Liste mit mehreren Elementen.
  4. Rufen Sie die Methode Distinct() von der Liste auf.
  5. Erhalten Sie die eindeutigen Werte und zeigen Sie das Ergebnis in der Konsole an.
  6. Entsorgen Sie alle erstellten Objekte.

Was ist LINQ

Entwickler können mit dem LINQ (Language Integrated Query) Feature von C# direkt in ihrem Code klare und ausdrucksstarke Abfragen zur Datenmanipulation erstellen. Erstmals in .NET Framework 3.5 eingeführt, bietet LINQ eine standardisierte Syntax für Abfragen an eine Vielzahl von Datenquellen, einschließlich Datenbanken und Sammlungen. LINQ vereinfacht einfache Aufgaben wie Filtern und Projektion mit Operatoren wie Where und Select, was die Lesbarkeit des Codes verbessert. Da es eine verzögerte Ausführung für optimale Geschwindigkeit ermöglicht, ist dieses Feature für C#-Entwickler entscheidend, um sicherzustellen, dass Datenmanipulationsoperationen schnell und natürlich in einer SQL-ähnlichen Weise abgeschlossen werden.

LINQ Distinct verstehen

Doppelte Elemente können aus einer Sammlung oder Sequenz mithilfe der Distinct Funktion von LINQ entfernt werden. In Abwesenheit eines benutzerdefinierten Vergleichers vergleicht es Elemente mit ihrem Standardvergleicher. Dies macht es zu einer großartigen Option in Situationen, in denen Sie mit einer einzigartigen Sammlung arbeiten und doppelte Komponenten entfernen müssen. Die Distinct Methode verwendet die Standardgleichheitsvergleicher, um Werte zu bewerten. Es wird Duplikate ausschließen, um nur eindeutige Elemente zurückzugeben.

Grundlegende Verwendung

Um eindeutige Elemente zu erhalten, ist der einfachste Weg, es zu verwenden, die Distinct Methode direkt auf einer Sammlung zu verwenden.

using System.Linq;
using System.Collections.Generic;

public class DistinctExample
{
    public static void Example()
    {
        // Example list with duplicate integers
        List<int> numbers = new List<int> { 1, 2, 2, 3, 4, 4, 5 };

        // Using Distinct to remove duplicates
        var distinctNumbers = numbers.Distinct();

        // Display the distinct numbers
        foreach (var number in distinctNumbers)
        {
            Console.WriteLine(number);
        }
    }
}
using System.Linq;
using System.Collections.Generic;

public class DistinctExample
{
    public static void Example()
    {
        // Example list with duplicate integers
        List<int> numbers = new List<int> { 1, 2, 2, 3, 4, 4, 5 };

        // Using Distinct to remove duplicates
        var distinctNumbers = numbers.Distinct();

        // Display the distinct numbers
        foreach (var number in distinctNumbers)
        {
            Console.WriteLine(number);
        }
    }
}
Imports System.Linq
Imports System.Collections.Generic

Public Class DistinctExample
	Public Shared Sub Example()
		' Example list with duplicate integers
		Dim numbers As New List(Of Integer) From {1, 2, 2, 3, 4, 4, 5}

		' Using Distinct to remove duplicates
		Dim distinctNumbers = numbers.Distinct()

		' Display the distinct numbers
		For Each number In distinctNumbers
			Console.WriteLine(number)
		Next number
	End Sub
End Class
$vbLabelText   $csharpLabel

Benutzerdefinierter Gleichheitsvergleicher

Sie können einen benutzerdefinierten Gleichheitsvergleich definieren, indem Sie eine Überladung der Distinct Funktion verwenden. Dies ist hilfreich, wenn Sie Elemente gemäß bestimmten Kriterien vergleichen möchten. Bitte beachten Sie das folgende Beispiel:

using System;
using System.Collections.Generic;
using System.Linq;

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

public class PersonEqualityComparer : IEqualityComparer<Person>
{
    public bool Equals(Person x, Person y)
    {
        return x.FirstName == y.FirstName && x.LastName == y.LastName;
    }

    public int GetHashCode(Person obj)
    {
        return obj.FirstName.GetHashCode() ^ obj.LastName.GetHashCode();
    }
}

public class DistinctCustomComparerExample
{
    public static void Example()
    {
        // Example list of people
        List<Person> people = new List<Person>
        {
            new Person { FirstName = "John", LastName = "Doe" },
            new Person { FirstName = "Jane", LastName = "Doe" },
            new Person { FirstName = "John", LastName = "Doe" }
        };

        // Using Distinct with a custom equality comparer
        var distinctPeople = people.Distinct(new PersonEqualityComparer());

        // Display distinct people
        foreach (var person in distinctPeople)
        {
            Console.WriteLine($"{person.FirstName} {person.LastName}");
        }
    }
}
using System;
using System.Collections.Generic;
using System.Linq;

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

public class PersonEqualityComparer : IEqualityComparer<Person>
{
    public bool Equals(Person x, Person y)
    {
        return x.FirstName == y.FirstName && x.LastName == y.LastName;
    }

    public int GetHashCode(Person obj)
    {
        return obj.FirstName.GetHashCode() ^ obj.LastName.GetHashCode();
    }
}

public class DistinctCustomComparerExample
{
    public static void Example()
    {
        // Example list of people
        List<Person> people = new List<Person>
        {
            new Person { FirstName = "John", LastName = "Doe" },
            new Person { FirstName = "Jane", LastName = "Doe" },
            new Person { FirstName = "John", LastName = "Doe" }
        };

        // Using Distinct with a custom equality comparer
        var distinctPeople = people.Distinct(new PersonEqualityComparer());

        // Display distinct people
        foreach (var person in distinctPeople)
        {
            Console.WriteLine($"{person.FirstName} {person.LastName}");
        }
    }
}
Imports System
Imports System.Collections.Generic
Imports System.Linq

Public Class Person
	Public Property FirstName() As String
	Public Property LastName() As String
End Class

Public Class PersonEqualityComparer
	Implements IEqualityComparer(Of Person)

	Public Function Equals(ByVal x As Person, ByVal y As Person) As Boolean Implements IEqualityComparer(Of Person).Equals
		Return x.FirstName = y.FirstName AndAlso x.LastName = y.LastName
	End Function

	Public Function GetHashCode(ByVal obj As Person) As Integer Implements IEqualityComparer(Of Person).GetHashCode
		Return obj.FirstName.GetHashCode() Xor obj.LastName.GetHashCode()
	End Function
End Class

Public Class DistinctCustomComparerExample
	Public Shared Sub Example()
		' Example list of people
		Dim people As New List(Of Person) From {
			New Person With {
				.FirstName = "John",
				.LastName = "Doe"
			},
			New Person With {
				.FirstName = "Jane",
				.LastName = "Doe"
			},
			New Person With {
				.FirstName = "John",
				.LastName = "Doe"
			}
		}

		' Using Distinct with a custom equality comparer
		Dim distinctPeople = people.Distinct(New PersonEqualityComparer())

		' Display distinct people
		For Each person In distinctPeople
			Console.WriteLine($"{person.FirstName} {person.LastName}")
		Next person
	End Sub
End Class
$vbLabelText   $csharpLabel

Verwendung von Distinct mit Werttypen

Sie müssen keinen benutzerdefinierten Gleichheitsvergleich bereitstellen, wenn Sie die Distinct Methode mit Werttypen verwenden.

using System;
using System.Collections.Generic;
using System.Linq;

public class DistinctValueTypeExample
{
    public static void Example()
    {
        List<int> integers = new List<int> { 1, 2, 2, 3, 4, 4, 5 };

        // Using Distinct to remove duplicates
        var distinctIntegers = integers.Distinct();

        // Display distinct integers
        foreach (var integer in distinctIntegers)
        {
            Console.WriteLine(integer);
        }
    }
}
using System;
using System.Collections.Generic;
using System.Linq;

public class DistinctValueTypeExample
{
    public static void Example()
    {
        List<int> integers = new List<int> { 1, 2, 2, 3, 4, 4, 5 };

        // Using Distinct to remove duplicates
        var distinctIntegers = integers.Distinct();

        // Display distinct integers
        foreach (var integer in distinctIntegers)
        {
            Console.WriteLine(integer);
        }
    }
}
Imports System
Imports System.Collections.Generic
Imports System.Linq

Public Class DistinctValueTypeExample
	Public Shared Sub Example()
		Dim integers As New List(Of Integer) From {1, 2, 2, 3, 4, 4, 5}

		' Using Distinct to remove duplicates
		Dim distinctIntegers = integers.Distinct()

		' Display distinct integers
		For Each [integer] In distinctIntegers
			Console.WriteLine([integer])
		Next [integer]
	End Sub
End Class
$vbLabelText   $csharpLabel

Verwendung von Distinct mit anonymen Typen

Distinct kann mit anonymen Typen verwendet werden, um Duplikate basierend auf bestimmten Attributen zu entfernen. Bitte beachten Sie das folgende Beispiel:

using System;
using System.Collections.Generic;
using System.Linq;

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

public class DistinctAnonymousTypesExample
{
    public static void Example()
    {
        List<Person> people = new List<Person>
        {
            new Person { FirstName = "John", LastName = "Doe" },
            new Person { FirstName = "Jane", LastName = "Doe" },
            new Person { FirstName = "John", LastName = "Doe" }
        };

        // Using Distinct with anonymous types
        var distinctPeople = people
            .Select(p => new { p.FirstName, p.LastName })
            .Distinct();

        // Display distinct anonymous types
        foreach (var person in distinctPeople)
        {
            Console.WriteLine($"{person.FirstName} {person.LastName}");
        }
    }
}
using System;
using System.Collections.Generic;
using System.Linq;

public class Person
{
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

public class DistinctAnonymousTypesExample
{
    public static void Example()
    {
        List<Person> people = new List<Person>
        {
            new Person { FirstName = "John", LastName = "Doe" },
            new Person { FirstName = "Jane", LastName = "Doe" },
            new Person { FirstName = "John", LastName = "Doe" }
        };

        // Using Distinct with anonymous types
        var distinctPeople = people
            .Select(p => new { p.FirstName, p.LastName })
            .Distinct();

        // Display distinct anonymous types
        foreach (var person in distinctPeople)
        {
            Console.WriteLine($"{person.FirstName} {person.LastName}");
        }
    }
}
Imports System
Imports System.Collections.Generic
Imports System.Linq

Public Class Person
	Public Property FirstName() As String
	Public Property LastName() As String
End Class

Public Class DistinctAnonymousTypesExample
	Public Shared Sub Example()
		Dim people As New List(Of Person) From {
			New Person With {
				.FirstName = "John",
				.LastName = "Doe"
			},
			New Person With {
				.FirstName = "Jane",
				.LastName = "Doe"
			},
			New Person With {
				.FirstName = "John",
				.LastName = "Doe"
			}
		}

		' Using Distinct with anonymous types
		Dim distinctPeople = people.Select(Function(p) New With {
			Key p.FirstName,
			Key p.LastName
		}).Distinct()

		' Display distinct anonymous types
		For Each person In distinctPeople
			Console.WriteLine($"{person.FirstName} {person.LastName}")
		Next person
	End Sub
End Class
$vbLabelText   $csharpLabel

Unterscheidung durch eine bestimmte Eigenschaft

Beim Arbeiten mit Objekten können Sie entweder Ihre Logik zur Unterscheidung nach einem bestimmten Attribut erstellen oder die Erweiterungsmethode DistinctBy von Drittanbieter-Bibliotheken (wie MoreLINQ) verwenden.

// Ensure to include the MoreLINQ Library
using MoreLinq;
using System;
using System.Collections.Generic;
using System.Linq;

public class Person
{
    public int Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

public class DistinctByExample
{
    public static void Example()
    {
        List<Person> people = new List<Person>
        {
            new Person { Id = 1, FirstName = "John", LastName = "Doe" },
            new Person { Id = 2, FirstName = "Jane", LastName = "Doe" },
            new Person { Id = 1, FirstName = "John", LastName = "Doe" }
        };

        // Using DistinctBy to filter distinct people by Id
        var distinctPeople = people.DistinctBy(p => p.Id);

        // Display distinct people
        foreach (var person in distinctPeople)
        {
            Console.WriteLine($"{person.Id}: {person.FirstName} {person.LastName}");
        }
    }
}
// Ensure to include the MoreLINQ Library
using MoreLinq;
using System;
using System.Collections.Generic;
using System.Linq;

public class Person
{
    public int Id { get; set; }
    public string FirstName { get; set; }
    public string LastName { get; set; }
}

public class DistinctByExample
{
    public static void Example()
    {
        List<Person> people = new List<Person>
        {
            new Person { Id = 1, FirstName = "John", LastName = "Doe" },
            new Person { Id = 2, FirstName = "Jane", LastName = "Doe" },
            new Person { Id = 1, FirstName = "John", LastName = "Doe" }
        };

        // Using DistinctBy to filter distinct people by Id
        var distinctPeople = people.DistinctBy(p => p.Id);

        // Display distinct people
        foreach (var person in distinctPeople)
        {
            Console.WriteLine($"{person.Id}: {person.FirstName} {person.LastName}");
        }
    }
}
' Ensure to include the MoreLINQ Library
Imports MoreLinq
Imports System
Imports System.Collections.Generic
Imports System.Linq

Public Class Person
	Public Property Id() As Integer
	Public Property FirstName() As String
	Public Property LastName() As String
End Class

Public Class DistinctByExample
	Public Shared Sub Example()
		Dim people As New List(Of Person) From {
			New Person With {
				.Id = 1,
				.FirstName = "John",
				.LastName = "Doe"
			},
			New Person With {
				.Id = 2,
				.FirstName = "Jane",
				.LastName = "Doe"
			},
			New Person With {
				.Id = 1,
				.FirstName = "John",
				.LastName = "Doe"
			}
		}

		' Using DistinctBy to filter distinct people by Id
		Dim distinctPeople = people.DistinctBy(Function(p) p.Id)

		' Display distinct people
		For Each person In distinctPeople
			Console.WriteLine($"{person.Id}: {person.FirstName} {person.LastName}")
		Next person
	End Sub
End Class
$vbLabelText   $csharpLabel

IronPDF

Programmierer können mit Hilfe der .NET-Bibliothek IronPDF Website PDF-Dokumente unter Verwendung der C#-Sprache erstellen, bearbeiten und ändern. Das Programm bietet eine Reihe von Werkzeugen und Funktionen, um verschiedene Aufgaben im Zusammenhang mit PDF-Dateien zu ermöglichen, wie das Erstellen von PDFs aus HTML, das Konvertieren von HTML in PDF, das Zusammenführen oder Aufteilen von PDF-Dokumenten und das Hinzufügen von Text, Bildern und Anmerkungen zu bereits vorhandenen PDFs. Um mehr über IronPDF zu erfahren, beachten Sie bitte die IronPDF Dokumentation.

Das Hauptmerkmal von IronPDF ist die HTML zu PDF Konvertierung, die Ihre Layouts und Stile intakt hält. Sie können PDFs aus Webinhalten erstellen, ideal für Berichte, Rechnungen und Dokumentationen. Es unterstützt die Konvertierung von HTML-Dateien, URLs und HTML-Zeichenfolgen in PDF-Dateien.

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

Funktionen von IronPDF

  • HTML in PDF konvertieren: Sie können IronPDF verwenden, um jede Art von HTML-Daten — einschließlich Dateien, URLs und HTML-Code-Zeichenfolgen — in PDF-Dokumente zu konvertieren.
  • PDF-Erzeugung: Text, Bilder und andere Elemente können programmgesteuert mit der C#-Programmiersprache zu PDF-Dokumenten hinzugefügt werden.
  • PDF-Bearbeitung: IronPDF kann eine PDF-Datei in mehrere Dateien aufteilen, mehrere PDF-Dokumente in eine Datei zusammenführen und bereits vorhandene PDFs bearbeiten.
  • PDF-Formulare: Die Bibliothek ermöglicht es Benutzern, PDF-Formulare zu erstellen und auszufüllen, wodurch sie in Szenarien nützlich ist, in denen Formulardaten gesammelt und verarbeitet werden müssen.
  • Sicherheitsfunktionen: IronPDF kann verwendet werden, um PDF-Dokumente zu verschlüsseln und Passwort- und Berechtigungsschutz bereitzustellen.
  • Textextraktion: Text aus PDF-Dateien kann mit IronPDF extrahiert werden.

IronPDF installieren

Holen Sie sich die IronPDF-Bibliothek; es wird benötigt, um Ihr Projekt einzurichten. Geben Sie den folgenden Code in die NuGet-Paketmanager-Konsole ein, um dies zu erreichen:

Install-Package IronPdf

C# LINQ Distinct (So funktioniert es für Entwickler): Abbildung 1 - Um die IronPDF-Bibliothek über die NuGet-Paketmanager-Konsole zu installieren, geben Sie den folgenden Befehl ein: Install IronPDF oder dotnet add package IronPDF

Die Verwendung des NuGet-Paketmanagers zur Suche nach dem Paket "IronPDF" ist eine weitere Option. Wir können aus dieser Liste der mit IronPDF verbundenen NuGet-Pakete das benötigte Paket auswählen und herunterladen.

C# LINQ Distinct (So funktioniert es für Entwickler): Abbildung 2 - Um die IronPDF-Bibliothek mit dem NuGet-Paketmanager zu installieren, suchen Sie im Browse-Tab nach dem Paket IronPDF und wählen Sie die neueste Version des IronPDF-Pakets zum Herunterladen und Installieren in Ihrem Projekt.

LINQ mit IronPDF

Betrachten Sie eine Situation, in der Sie einen Satz von Daten haben und verschiedene PDF-Dokumente gemäß unterschiedlichen Werten in diesem Satz erstellen möchten. Hier kommt die Nützlichkeit von LINQ's Distinct zur Geltung, besonders wenn es mit IronPDF verwendet wird, um Dokumente schnell zu erstellen.

Erzeugung eindeutiger PDFs mit LINQ und IronPDF

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

public class DocumentGenerator
{
    public static void Main()
    {
        // Sample data representing categories
        List<string> categories = new List<string>
        {
            "Technology",
            "Business",
            "Health",
            "Technology",
            "Science",
            "Business",
            "Health"
        };

        // Use LINQ Distinct to filter out duplicate values
        var distinctCategories = categories.Distinct();

        // Generate a distinct elements PDF document for each category
        foreach (var category in distinctCategories)
        {
            GeneratePdfDocument(category);
        }
    }

    private static void GeneratePdfDocument(string category)
    {
        // Create a new PDF document using IronPDF
        IronPdf.HtmlToPdf renderer = new IronPdf.HtmlToPdf();
        PdfDocument pdf = renderer.RenderHtmlAsPdf($"<h1>{category} Report</h1>");

        // Save the PDF to a file
        string pdfFilePath = $"{category}_Report.pdf";
        pdf.SaveAs(pdfFilePath);

        // Display a message with the file path
        Console.WriteLine($"PDF generated successfully. File saved at: {pdfFilePath}");
    }
}
using IronPdf;
using System;
using System.Collections.Generic;
using System.Linq;

public class DocumentGenerator
{
    public static void Main()
    {
        // Sample data representing categories
        List<string> categories = new List<string>
        {
            "Technology",
            "Business",
            "Health",
            "Technology",
            "Science",
            "Business",
            "Health"
        };

        // Use LINQ Distinct to filter out duplicate values
        var distinctCategories = categories.Distinct();

        // Generate a distinct elements PDF document for each category
        foreach (var category in distinctCategories)
        {
            GeneratePdfDocument(category);
        }
    }

    private static void GeneratePdfDocument(string category)
    {
        // Create a new PDF document using IronPDF
        IronPdf.HtmlToPdf renderer = new IronPdf.HtmlToPdf();
        PdfDocument pdf = renderer.RenderHtmlAsPdf($"<h1>{category} Report</h1>");

        // Save the PDF to a file
        string pdfFilePath = $"{category}_Report.pdf";
        pdf.SaveAs(pdfFilePath);

        // Display a message with the file path
        Console.WriteLine($"PDF generated successfully. File saved at: {pdfFilePath}");
    }
}
Imports IronPdf
Imports System
Imports System.Collections.Generic
Imports System.Linq

Public Class DocumentGenerator
	Public Shared Sub Main()
		' Sample data representing categories
		Dim categories As New List(Of String) From {"Technology", "Business", "Health", "Technology", "Science", "Business", "Health"}

		' Use LINQ Distinct to filter out duplicate values
		Dim distinctCategories = categories.Distinct()

		' Generate a distinct elements PDF document for each category
		For Each category In distinctCategories
			GeneratePdfDocument(category)
		Next category
	End Sub

	Private Shared Sub GeneratePdfDocument(ByVal category As String)
		' Create a new PDF document using IronPDF
		Dim renderer As New IronPdf.HtmlToPdf()
		Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf($"<h1>{category} Report</h1>")

		' Save the PDF to a file
		Dim pdfFilePath As String = $"{category}_Report.pdf"
		pdf.SaveAs(pdfFilePath)

		' Display a message with the file path
		Console.WriteLine($"PDF generated successfully. File saved at: {pdfFilePath}")
	End Sub
End Class
$vbLabelText   $csharpLabel

In diesem Beispiel wird eine Serie von eindeutigen Kategorien durch die Verwendung der Distinct Methode für die Kategorien-Sammlung gewonnen. Es hilft, doppelte Elemente aus einer Sequenz zu entfernen. Anschließend wird IronPDF verwendet, um ein PDF-Dokument mit diesen einzigartigen Elementen zu erstellen. Diese Methode gewährleistet, dass separate PDF-Dokumente ausschließlich für eindeutige Kategorien erstellt werden.

Konsole OUTPUT

C# LINQ Distinct (So funktioniert es für Entwickler): Abbildung 3 - Konsolenausgabe

Generierte PDF-Ausgabe

C# LINQ Distinct (So funktioniert es für Entwickler): Abbildung 4 - PDF-Ausgabe: Technologiereport

Um mehr über das IronPDF-Codebeispiel zur PDF-Generierung mit HTML zu erfahren, beziehen Sie sich bitte auf den IronPDF HTML zu PDF Beispielcode.

Abschluss

LINQ's Distinct Erweiterungsmethode in Verbindung mit IronPDF bietet einen robusten und effizienten Mechanismus zur Erstellung eindeutiger PDF-Dokumente basierend auf Werten. Diese Methode strafft den Code und gewährleistet eine effektive Dokumentengenerierung, egal ob Sie mit Kategorien, Tags oder anderen Daten arbeiten, bei denen separate Dokumente benötigt werden.

Sie können eine zuverlässige und ausdrucksstarke Lösung zur Verwaltung verschiedener Aspekte Ihrer C#-Anwendungen entwickeln, indem Sie LINQ für die Datenverarbeitung und IronPDF für die Dokumentenerstellung verwenden. Wenn Sie diese Strategien für Ihre Projekte verwenden, denken Sie an die besonderen Anforderungen Ihrer Anwendung und passen Sie die Implementierung an, um maximale Zuverlässigkeit und Leistung zu erreichen.

Häufig gestellte Fragen

Wie kann ich doppelte Einträge aus einer Sammlung in C# entfernen?

Sie können mit der Distinct-Methode von LINQ doppelte Einträge aus einer Sammlung in C# entfernen. Diese Methode ist besonders nützlich, wenn sie mit IronPDF kombiniert wird, um einzigartige PDF-Dokumente aus unterschiedlichen Datenkategorien zu erzeugen.

Wie konvertiere ich HTML in C# zu einem PDF?

Um HTML in C# zu einem PDF zu konvertieren, können Sie die RenderHtmlAsPdf-Methode von IronPDF verwenden. Dies ermöglicht die effiziente Umwandlung von HTML-Strings oder -Dateien in PDF-Dokumente.

Kann ich LINQ's Distinct-Methode mit benutzerdefinierten Objekten verwenden?

Ja, Sie können die Distinct-Methode von LINQ mit benutzerdefinierten Objekten verwenden, indem Sie einen benutzerdefinierten Gleichheitsvergleicher bereitstellen. Dies ist nützlich, wenn während des PDF-Erstellungsprozesses mit IronPDF spezifische Kriterien zur Bestimmung der Einzigartigkeit definiert werden müssen.

Was ist der Vorteil der Verwendung von LINQ mit IronPDF?

Die Verwendung von LINQ mit IronPDF ermöglicht es Entwicklern, einzigartige und effiziente PDF-Dokumente basierend auf Datenverarbeitung zu erstellen. Es verbessert die Lesbarkeit des Codes und die Leistung, insbesondere bei der Verwaltung groß angelegter Dokumenterstellungsaufgaben.

Wie kann die Distinct-Methode von LINQ die Erstellung von PDF-Dokumenten verbessern?

Die Distinct-Methode von LINQ kann die Erstellung von PDF-Dokumenten verbessern, indem sichergestellt wird, dass nur einzigartige Einträge in das endgültige Ergebnis aufgenommen werden. Diese Methode kann in Verbindung mit IronPDF verwendet werden, um unterschiedliche PDF-Dokumente für verschiedene Datenkategorien zu erzeugen.

Ist es möglich, die PDF-Ausgabe bei der Verwendung von IronPDF anzupassen?

Ja, IronPDF bietet verschiedene Optionen zur Anpassung der PDF-Ausgabe, einschließlich der Einstellung von Seitengrößen, Rändern und dem Hinzufügen von Kopf- oder Fußzeilen. Diese Anpassungen können mit LINQ kombiniert werden, um maßgeschneiderte, einzigartige Dokumentausgaben zu erstellen.

Welche Szenarien können von der Verwendung der Distinct-Methode von LINQ mit PDFs profitieren?

Szenarien wie die Erstellung von Berichten, Rechnungen oder allen Dokumenten, die aus einem Datensatz eine Einzigartigkeit erfordern, können von der Verwendung der Distinct-Methode von LINQ mit PDFs profitieren. IronPDF kann genutzt werden, um effiziente und eindeutige PDF-Ausgaben zu erzeugen.

Wie verbessert LINQ die Effizienz von datengetriebenen PDF-Anwendungen?

LINQ verbessert die Effizienz von datengetriebenen PDF-Anwendungen, indem es Entwicklern ermöglicht, Datensätze zu filtern und zu manipulieren, bevor PDFs generiert werden. Dies stellt sicher, dass nur die notwendigen und einzigartigen Daten in die PDFs aufgenommen werden, und optimiert so die Leistung und Ressourcennutzung.

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
  Jetzt mit dem Ingenieurteam chatten
Chief Technology Officer

Jacob Mellor ist Chief Technology Officer bei Iron Software und ein visionärer Ingenieur, der führend in der C# PDF-Technologie ist. Als ursprünglicher Entwickler der Iron Software-Kerncodebasis hat er die Produktarchitektur des Unternehmens seit seiner Gründung gestaltet und zusammen mit CEO Cameron Rimington in ein Unternehmen ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen