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.

Can IronPDF generate PDF documents based on specific dataset attributes?

Yes, IronPDF can generate PDF documents based on specific dataset attributes by using LINQ methods like DistinctBy (from third-party libraries), allowing for the creation of PDFs with unique data attributes.

What is the purpose of LINQ in C#?

LINQ (Language Integrated Query) in C# provides a consistent and expressive way to query and manipulate data from different data sources such as collections, databases, and XML files, improving code readability and performance.

Die C# PDF-Bibliothek

Explore IronPDF Gratis testen

HTML zu PDF

Online Demo Alle Codebeispiele anzeigen

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

using IronPdf;

// Disable local disk access or cross-origin requests
Installation.EnableWebSecurity = true;

// Instantiate Renderer
var renderer = new ChromePdfRenderer();

// Create a PDF from a HTML string using C#
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1>");

// Export to a file or Stream
pdf.SaveAs("output.pdf");

// Advanced Example with HTML Assets
// Load external html assets: Images, CSS and JavaScript.
// An optional BasePath 'C:\site\assets\' is set as the file location to load assets from
var myAdvancedPdf = renderer.RenderHtmlAsPdf("<img src='icons/iron.png'>", @"C:\site\assets\");
myAdvancedPdf.SaveAs("html-with-assets.pdf");

PM >Install-Package IronPdf

Install-Package IronPdf

ENTWICKLER-UPDATES

C# LINQ Distinct (Funktionsweise für Entwickler)

Jacob Mellor

Updated: 21. April 2026

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 die C# LINQ Distinct-Methode verwendet

Erstellen Sie ein neues Konsolenprojekt.
Importieren Sie den System.Linq-Namespace.
Erstellen Sie eine Liste mit mehreren Elementen.
Rufen Sie die Methode Distinct() aus der Liste auf.
Erhalten Sie die eindeutigen Werte und zeigen Sie das Ergebnis in der Konsole an.
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 macht einfache Aufgaben wie Filtern und Projektion einfacher durch die Verwendung von 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 entfernt werden, indem die LINQ-Funktion Distinct verwendet wird. 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 Technik Distinct verwendet die Standard-Gleichheitsvergleichsmethoden, um Werte zu bewerten. Es wird Duplikate ausschließen, um nur eindeutige Elemente zurückzugeben.

Grundlegende Verwendung

Um eindeutige Elemente zu erhalten, ist es der einfachste Weg, die Methode Distinct 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

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

Benutzerdefinierter Gleichheitsvergleicher

Sie können einen benutzerdefinierten Gleichheitsvergleich definieren, indem Sie eine Überladung der Funktion Distinct 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

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

Verwendung von Distinct mit Werttypen

Es ist nicht erforderlich, einen benutzerdefinierten Gleichheitsvergleich bereitzustellen, wenn Sie die Methode Distinct mit Wertetypen 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

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

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

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

Unterscheidung durch eine bestimmte Eigenschaft

Beim Arbeiten mit Objekten können Sie entweder Ihre eigene Logik zum Unterscheiden nach einem bestimmten Attribut erstellen oder die DistinctBy-Erweiterungsmethode 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

' 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

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

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

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:

PM > Install-Package IronPdf

Install-Package IronPdf

C# LINQ Distinct (How It Works For Developers): Figure 1 - To install the IronPDF library using the NuGet Package Manager Console, enter the following command: "Install IronPDF" or ".NET 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 (How It Works For Developers): Figure 2 - To install the IronPDF library using the NuGet Package Manager, search for the package "IronPDF" in the Browse tab and choose the latest version of IronPDF package to download and install in your project.

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 zeigt sich die Nützlichkeit von LINQs Distinct, insbesondere wenn es mit IronPDF verwendet wird, um schnell Dokumente 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
    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

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

In diesem Beispiel wird eine Reihe von eindeutigen Kategorien erhalten, indem die Methode Distinct für die Kategorien-Sammlung verwendet wird. 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 (Wie es für Entwickler funktioniert): Abbildung 3 - Konsolenausgabe

Generierte PDF-Ausgabe

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

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

Die LINQ-Distinct-Erweiterungsmethode in Verbindung mit IronPDF bietet einen robusten und effizienten Mechanismus zur Erstellung einzigartiger 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.

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 Pionierarbeit in der C# PDF-Technologie leistet. Als der ursprüngliche Entwickler hinter der Kern-Codebasis von Iron Software hat er die Produktarchitektur des Unternehmens seit seiner Gründung geprägt und es zusammen mit CEO Cameron Rimington in ein Unternehmen mit mehr als 50 Mitarbeitern verwandelt, das die NASA, Tesla und globale Regierungsbehörden beliefert.

...