.NET-HILFE

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

Veröffentlicht 14. Januar 2025

Teilen Sie:

Einführung

C#'s IEnumerableDie Schnittstelle ist eines der vielseitigsten Werkzeuge im .NET-Framework und ermöglicht es Entwicklern, auf äußerst flexible Weise mit Sammlungen zu arbeiten. Wenn kombiniert mitIronPDF, IEnumerable ermöglicht eine dynamische Datenmanipulation und effiziente PDF-Erstellung, was es ideal für Szenarien wie die Erstellung von Berichten, den Datenexport oder die Generierung von Dokumenten aus Datenbankabfragen macht.

Die Verwendung von IEnumerable stellt sicher, dass Ihre Anwendung skalierbar und speichereffizient bleibt, da Daten verzögert verarbeitet werden und ganze Datensätze nicht auf einmal in den Speicher geladen werden. Dies ist besonders nützlich für groß angelegte Anwendungen, die umfangreiche Datenkollektionen verarbeiten, wie beispielsweise eine riesige Datenbanktabelle.

Was ist IronPDF?

C# Enumerable(Wie es für Entwickler funktioniert): Abbildung 1

IronPDF ist eine leistungsstarke .NET-Bibliothek, die darauf ausgelegt ist, den Prozess der Erstellung, Bearbeitung und Verwaltung von PDF-Dateien programmatisch zu vereinfachen. Es bietet eine Vielzahl von Funktionen, darunter die Umwandlung von HTML in PDF, Textextraktion, das Zusammenführen von PDFs und mehr. Durch die Integration von IronPDF in Ihre C#-Projekte können Sie komplexe PDF-Aufgaben effizient bearbeiten, ohne tiefgehende Kenntnisse der PDF-Interna zu benötigen.

IronPDF unterstützt auch eine Vielzahl von Formaten, sodass Sie PDFs aus rohem HTML, Razor Views, ASP.NET-Webseiten oder sogar direkt aus Datenstrukturen erzeugen können. Diese Flexibilität macht es zu einem unverzichtbaren Werkzeug für Entwickler, die moderne, datengesteuerte Anwendungen erstellen.

Erste Schritte

Installation von IronPDF

Um IronPDF in Ihrem Projekt zu verwenden, befolgen Sie diese Schritte:

Über die NuGet-Paket-Manager-Konsole

Öffnen Sie Ihr .NET-Projekt in Visual Studio.
1. Öffnen Sie die NuGet-Paket-Manager-Konsole im Dropdown-Menü "Tools".
Führen Sie den folgenden Befehl aus:

Install-Package IronPdf

Install-Package IronPdf

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'Install-Package IronPdf

Über den NuGet-Paket-Manager für die Lösung

Innerhalb Ihres Visual Studio-Projekts gehen Sie zu Extras > NuGet-Paket-Manager > NuGet-Pakete für die Lösung verwalten
1. Suche nach IronPDF
1. Klicken Sie auf "Installieren", um mit der Installation des IronPDF-Pakets in Ihr Projekt zu beginnen.

Grundkonzepte von Enumerable in C

Das IEnumerable-Interface repräsentiert eine Sequenz von Elementen, die aufgezählt werden können. Häufige Beispiele umfassen Arrays, Listen und LINQ-Abfrageergebnisse. Indem Sie LINQ verwenden, können Sie Daten filtern, sortieren und in das gewünschte Format projizieren, bevor Sie mit IronPDF PDFs erstellen.

Einer der Hauptvorteile von IEnumerable ist das Modell der verzögerten Ausführung, das es ermöglicht, Abfragen nur dann auszuführen, wenn auf ihre Ergebnisse zugegriffen wird. Dies ermöglicht eine effiziente Datenverarbeitung und reduziert den Rechenaufwand in komplexen Arbeitsabläufen.

Außerdem bedeutet die Implementierung von IEnumerable in der Liste, dass jede Sammlung wie Listals IEnumerable behandelt werden kann, was einfache LINQ-Operationen, Filterung und Transformation ermöglicht.

Praktische Anwendungsfälle

Erstellen von PDFs aus aufzählbaren Daten

Beispiel: Exportieren einer Liste von Objekten in eine PDF-Tabelle

Stellen Sie sich vor, Sie haben eine Liste, die IEnumerable von Mitarbeitern implementiert, die Sie als PDF-Tabelle exportieren müssen. Mithilfe von IEnumerable und IronPDF können Sie die Iterator-Methode verwenden, um durch die Daten zu iterieren und sie in ein gut strukturiertes PDF zu konvertieren.

Um die Präsentation zu verbessern, können Sie HTML-Tabellen mit Inline-CSS verwenden, um die Zeilen und Spalten basierend auf den Daten dynamisch zu gestalten. Dies stellt sicher, dass die PDF-Ausgabe sowohl funktional als auch optisch ansprechend ist.

Filtern und Transformieren von Daten vor der PDF-Erstellung

Beispiel: Verwenden von LINQ zum Auswählen und Formatieren von Daten

Mit LINQ können Sie Ihre Daten filtern und transformieren, bevor Sie sie an IronPDF übergeben. Zum Beispiel könnten Sie nur aktive Mitarbeiter filtern und ihre Namen für die PDF-Ausgabe in Großbuchstaben formatieren.

var activeEmployees = employees.Where(e => e.IsActive).Select(e => new {
    Name = e.Name.ToUpper(),
    Position = e.Position,
    Age = e.Age
});

var activeEmployees = employees.Where(e => e.IsActive).Select(e => new {
    Name = e.Name.ToUpper(),
    Position = e.Position,
    Age = e.Age
});

Dim activeEmployees = employees.Where(Function(e) e.IsActive).Select(Function(e) New With {
	Key .Name = e.Name.ToUpper(),
	Key .Position = e.Position,
	Key .Age = e.Age
})

Diese umgewandelten Daten können dann in ein PDF-freundliches HTML-Format zur Darstellung konvertiert werden.

Batch-Erstellung von PDFs aus Enumerables

Beispiel: Erstellen mehrerer PDFs aus einer Sammlung

Wenn Sie für jeden Datensatz in einer Sammlungsklasse ein separates PDF erstellen müssen, können Sie eine foreach-Schleife verwenden, um durch die Auflistung zu iterieren und einzelne PDFs dynamisch zu generieren. Dies ist besonders nützlich für die Erstellung von Rechnungen, Zertifikaten oder personalisierten Berichten.

foreach (var employee in employees)
{
    string html = $"<h1>{employee.Name}</h1><p>Position: {employee.Position}</p><p>Age: {employee.Age}</p>";
    var pdf = Renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs($"{employee.Name}_Report.pdf");
}

foreach (var employee in employees)
{
    string html = $"<h1>{employee.Name}</h1><p>Position: {employee.Position}</p><p>Age: {employee.Age}</p>";
    var pdf = Renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs($"{employee.Name}_Report.pdf");
}

For Each employee In employees
	Dim html As String = $"<h1>{employee.Name}</h1><p>Position: {employee.Position}</p><p>Age: {employee.Age}</p>"
	Dim pdf = Renderer.RenderHtmlAsPdf(html)
	pdf.SaveAs($"{employee.Name}_Report.pdf")
Next employee

Erweiterungsmethoden für Enumerables

In C# sind Erweiterungsmethoden eine leistungsstarke Möglichkeit, um bestehenden Typen Funktionalität hinzuzufügen, ohne deren Quellcode zu ändern. Sie können eine Erweiterungsmethode erstellen, um Vorgänge auf einem IEnumerable oder einer Liste zu optimieren.

Zum Beispiel erstellen wir eine Erweiterungsmethode, um das erste Element aus einer aufzählbaren Sammlung zu erhalten.

public static class EnumerableExtensions
{
    public static T FirstOrDefaultElement<T>(this IEnumerable<T> collection)
    {
        return collection?.FirstOrDefault();
    }
}

public static class EnumerableExtensions
{
    public static T FirstOrDefaultElement<T>(this IEnumerable<T> collection)
    {
        return collection?.FirstOrDefault();
    }
}

Public Module EnumerableExtensions
	<System.Runtime.CompilerServices.Extension> _
	Public Function FirstOrDefaultElement(Of T)(ByVal collection As IEnumerable(Of T)) As T
		Return collection?.FirstOrDefault()
	End Function
End Module

Schritt-für-Schritt-Umsetzung

Einrichten des Projekts

Codebeispiel: Initialisieren von IronPDF in C

Beginnen Sie mit der Einrichtung Ihres Projekts und der Initialisierung von IronPDF und der ChromePdfRenderer-Klasse:

using IronPdf;
ChromePdfRenderer renderer = new ChromePdfRenderer();

using IronPdf;
ChromePdfRenderer renderer = new ChromePdfRenderer();

Imports IronPdf
Private renderer As New ChromePdfRenderer()

Umwandlung von Enumerables in PDF-Inhalte

Code-Snippet: Daten iterieren und formatieren in HTML

Bereiten Sie Ihre aufzählbaren Daten als HTML-String vor:

var employees = new List<Employee>
{
    new Employee { Name = "John Doe", Position = "Developer", Age = 30 },
    new Employee { Name = "Jane Smith", Position = "Designer", Age = 25 }
};
string html = "<table style='width:100%; border: 1px solid black;'>" +
              "<tr><th>Name</th><th>Position</th><th>Age</th></tr>";
foreach (var employee in employees)
{
    html += $"<tr><td>{employee.Name}</td><td>{employee.Position}</td><td>{employee.Age}</td></tr>";
}
html += "</table>";

var employees = new List<Employee>
{
    new Employee { Name = "John Doe", Position = "Developer", Age = 30 },
    new Employee { Name = "Jane Smith", Position = "Designer", Age = 25 }
};
string html = "<table style='width:100%; border: 1px solid black;'>" +
              "<tr><th>Name</th><th>Position</th><th>Age</th></tr>";
foreach (var employee in employees)
{
    html += $"<tr><td>{employee.Name}</td><td>{employee.Position}</td><td>{employee.Age}</td></tr>";
}
html += "</table>";

Dim employees = New List(Of Employee) From {
	New Employee With {
		.Name = "John Doe",
		.Position = "Developer",
		.Age = 30
	},
	New Employee With {
		.Name = "Jane Smith",
		.Position = "Designer",
		.Age = 25
	}
}
Dim html As String = "<table style='width:100%; border: 1px solid black;'>" & "<tr><th>Name</th><th>Position</th><th>Age</th></tr>"
For Each employee In employees
	html &= $"<tr><td>{employee.Name}</td><td>{employee.Position}</td><td>{employee.Age}</td></tr>"
Next employee
html &= "</table>"

Code-Snippet: Rendering von HTML in PDF

Konvertieren Sie das HTML in ein PDF:

var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("Employees.pdf");

var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("Employees.pdf");

Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("Employees.pdf")

Vollständiges Code-Beispiel

Nachdem wir uns genauer angeschaut haben, wie Sie die C# Enumerable-Klasse mit IronPDF verwenden können, um PDF-Dateien zu erzeugen, werfen wir nun einen Blick auf einen vollständigen Beispielcode, in dem wir diese Tools verwendet haben, um ein neues, dynamisches PDF-Dokument zu erstellen.

using System;
using System.Collections.Generic;
using System.Linq;
using IronPdf;
public class Employee
{
    public string Name { get; set; }
    public string Position { get; set; }
    public int Age { get; set; }
}
public class Program
{
    public static void Main(string[] args)
    {
        // Sample employee data
        var employees = new List<Employee>
            {
                new Employee { Name = "John Doe", Position = "Developer", Age = 30 },
                new Employee { Name = "Jane Smith", Position = "Designer", Age = 25 },
                new Employee { Name = "Sam Wilson", Position = "Manager", Age = 35 }
            };
        // Filter and sort data using LINQ
        var filteredEmployees = employees
            .Where(e => e.Age >= 25)
            .OrderBy(e => e.Name)
            .ToList();
        // Generate HTML for the PDF
        string html = "<h1 style='text-align:center;'>Employee Report</h1>" +
                      "<table style='width:100%; border-collapse: collapse;'>" +
                      "<tr style='background-color: #f2f2f2;'>" +
                      "<th style='border: 1px solid black; padding: 8px;'>Name</th>" +
                      "<th style='border: 1px solid black; padding: 8px;'>Position</th>" +
                      "<th style='border: 1px solid black; padding: 8px;'>Age</th></tr>";
        foreach (var employee in filteredEmployees)
        {
            html += $"<tr>" +
                    $"<td style='border: 1px solid black; padding: 8px;'>{employee.Name}</td>" +
                    $"<td style='border: 1px solid black; padding: 8px;'>{employee.Position}</td>" +
                    $"<td style='border: 1px solid black; padding: 8px;'>{employee.Age}</td>" +
                    $"</tr>";
        }
        html += "</table>";
        // Initialize ChromePdfRenderer
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        // Render the HTML to PDF
        try
        {
            var pdf = renderer.RenderHtmlAsPdf(html);
            string outputPath = "EmployeeReport.pdf";
            pdf.SaveAs(outputPath);
            Console.WriteLine($"PDF generated successfully at: {outputPath}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error generating PDF: {ex.Message}");
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using IronPdf;
public class Employee
{
    public string Name { get; set; }
    public string Position { get; set; }
    public int Age { get; set; }
}
public class Program
{
    public static void Main(string[] args)
    {
        // Sample employee data
        var employees = new List<Employee>
            {
                new Employee { Name = "John Doe", Position = "Developer", Age = 30 },
                new Employee { Name = "Jane Smith", Position = "Designer", Age = 25 },
                new Employee { Name = "Sam Wilson", Position = "Manager", Age = 35 }
            };
        // Filter and sort data using LINQ
        var filteredEmployees = employees
            .Where(e => e.Age >= 25)
            .OrderBy(e => e.Name)
            .ToList();
        // Generate HTML for the PDF
        string html = "<h1 style='text-align:center;'>Employee Report</h1>" +
                      "<table style='width:100%; border-collapse: collapse;'>" +
                      "<tr style='background-color: #f2f2f2;'>" +
                      "<th style='border: 1px solid black; padding: 8px;'>Name</th>" +
                      "<th style='border: 1px solid black; padding: 8px;'>Position</th>" +
                      "<th style='border: 1px solid black; padding: 8px;'>Age</th></tr>";
        foreach (var employee in filteredEmployees)
        {
            html += $"<tr>" +
                    $"<td style='border: 1px solid black; padding: 8px;'>{employee.Name}</td>" +
                    $"<td style='border: 1px solid black; padding: 8px;'>{employee.Position}</td>" +
                    $"<td style='border: 1px solid black; padding: 8px;'>{employee.Age}</td>" +
                    $"</tr>";
        }
        html += "</table>";
        // Initialize ChromePdfRenderer
        ChromePdfRenderer renderer = new ChromePdfRenderer();
        // Render the HTML to PDF
        try
        {
            var pdf = renderer.RenderHtmlAsPdf(html);
            string outputPath = "EmployeeReport.pdf";
            pdf.SaveAs(outputPath);
            Console.WriteLine($"PDF generated successfully at: {outputPath}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error generating PDF: {ex.Message}");
        }
    }
}

Imports System
Imports System.Collections.Generic
Imports System.Linq
Imports IronPdf
Public Class Employee
	Public Property Name() As String
	Public Property Position() As String
	Public Property Age() As Integer
End Class
Public Class Program
	Public Shared Sub Main(ByVal args() As String)
		' Sample employee data
		Dim employees = New List(Of Employee) From {
			New Employee With {
				.Name = "John Doe",
				.Position = "Developer",
				.Age = 30
			},
			New Employee With {
				.Name = "Jane Smith",
				.Position = "Designer",
				.Age = 25
			},
			New Employee With {
				.Name = "Sam Wilson",
				.Position = "Manager",
				.Age = 35
			}
		}
		' Filter and sort data using LINQ
		Dim filteredEmployees = employees.Where(Function(e) e.Age >= 25).OrderBy(Function(e) e.Name).ToList()
		' Generate HTML for the PDF
		Dim html As String = "<h1 style='text-align:center;'>Employee Report</h1>" & "<table style='width:100%; border-collapse: collapse;'>" & "<tr style='background-color: #f2f2f2;'>" & "<th style='border: 1px solid black; padding: 8px;'>Name</th>" & "<th style='border: 1px solid black; padding: 8px;'>Position</th>" & "<th style='border: 1px solid black; padding: 8px;'>Age</th></tr>"
		For Each employee In filteredEmployees
			html &= $"<tr>" & $"<td style='border: 1px solid black; padding: 8px;'>{employee.Name}</td>" & $"<td style='border: 1px solid black; padding: 8px;'>{employee.Position}</td>" & $"<td style='border: 1px solid black; padding: 8px;'>{employee.Age}</td>" & $"</tr>"
		Next employee
		html &= "</table>"
		' Initialize ChromePdfRenderer
		Dim renderer As New ChromePdfRenderer()
		' Render the HTML to PDF
		Try
			Dim pdf = renderer.RenderHtmlAsPdf(html)
			Dim outputPath As String = "EmployeeReport.pdf"
			pdf.SaveAs(outputPath)
			Console.WriteLine($"PDF generated successfully at: {outputPath}")
		Catch ex As Exception
			Console.WriteLine($"Error generating PDF: {ex.Message}")
		End Try
	End Sub
End Class

Ausgabe PDF

C# Enumerable(Wie es für Entwickler funktioniert): Abbildung 5

Code Erläuterung

Dieses C#-Programm ist darauf ausgelegt, einen PDF-Bericht gefilterter Mitarbeiterdaten mithilfe der IronPDF-Bibliothek zu erstellen. Der obige Code beginnt mit der Definition einer Employee-Klasse mit Eigenschaften für Name, Position und Alter, die einzelne Mitarbeiteraufzeichnungen repräsentieren.

Eine Liste von Beispieldaten von Mitarbeitern wird erstellt, die aus drei Employee-Objekten mit unterschiedlichen Namen, Positionen und Alter besteht. Das Programm verwendet dann LINQ, um diese Liste zu filtern, indem es nur Mitarbeiter auswählt, die 25 Jahre oder älter sind, und sortiert sie alphabetisch nach Namen. Diese gefilterte und sortierte Liste wird in der filteredEmployees-Variable gespeichert.

Als Nächstes erstellt das Programm einen HTML-String, der zur Erzeugung des PDF verwendet wird. Es beginnt mit einer Überschrift und einer Tabellenstruktur, die Spaltenüberschriften für Name, Position und Alter definiert. Anschließend durchläuft es die gefilterte Mitarbeiterliste und erzeugt dynamisch Tabellenzeilen für die Informationen jedes Mitarbeiters. Der resultierende HTML-Code wird verwendet, um mit IronPDF ein PDF zu erstellen.ChromePdfRenderer.

Das obige Beispiel demonstriert effektiv, wie man verwendetIronPDFum ein PDF aus dynamisch generiertem HTML zu erstellen, die Leistung von LINQ zur Filterung und Sortierung von Daten zu demonstrieren und Ausnahmen während des PDF-Erstellungsprozesses elegant zu behandeln.

Leistungstipps und bewährte Praktiken

Optimieren von Aufzählungsoperationen

Verwenden Sie LINQ, um das Filtern und Transformieren Ihrer Daten zu optimieren. Zum Beispiel:

var filteredEmployees = employees.Where(e => e.Age > 25).OrderBy(e => e.Name);

var filteredEmployees = employees.Where(e => e.Age > 25).OrderBy(e => e.Name);

Dim filteredEmployees = employees.Where(Function(e) e.Age > 25).OrderBy(Function(e) e.Name)

Minimieren Sie redundante Operationen, indem Sie LINQ-Methoden effektiv verketten. Dies verbessert die Leistung, insbesondere beim Arbeiten mit großen Datenmengen.

Effiziente Speichernutzung bei großen Datensätzen

Für große Datensätze sollten Sie erwägen, die Daten in kleinere Teile zu streamen, um den Speicheraufwand zu vermeiden. Verwenden Sie yield return, um nicht generische Sammlungsdaten verzögert zu erzeugen und so eine effiziente Speichernutzung zu gewährleisten.

IEnumerable<Employee> GetEmployees() {
    foreach (var employee in database.GetAllEmployees()) {
        yield return employee;
    }
}

IEnumerable<Employee> GetEmployees() {
    foreach (var employee in database.GetAllEmployees()) {
        yield return employee;
    }
}

Private Iterator Function GetEmployees() As IEnumerable(Of Employee)
	For Each employee In database.GetAllEmployees()
		Yield employee
	Next employee
End Function

Fehlerbehandlung bei der PDF-Erstellung

Umschließen Sie Ihre PDF-Erstellungslogik mit einem Try-Catch-Block, um Fehler elegant zu handhaben:

try
{
    var pdf = Renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs("output.pdf");
}
catch (IronPdf.Exceptions.PdfException ex)
{
    Console.WriteLine($"PDF Error: {ex.Message}");
}
catch (Exception ex)
{
    Console.WriteLine($"General Error: {ex.Message}");
}

try
{
    var pdf = Renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs("output.pdf");
}
catch (IronPdf.Exceptions.PdfException ex)
{
    Console.WriteLine($"PDF Error: {ex.Message}");
}
catch (Exception ex)
{
    Console.WriteLine($"General Error: {ex.Message}");
}

Try
	Dim pdf = Renderer.RenderHtmlAsPdf(html)
	pdf.SaveAs("output.pdf")
Catch ex As IronPdf.Exceptions.PdfException
	Console.WriteLine($"PDF Error: {ex.Message}")
Catch ex As Exception
	Console.WriteLine($"General Error: {ex.Message}")
End Try

Das Protokollieren von Fehlern und die Bereitstellung benutzerfreundlicher Rückmeldungen können die Robustheit Ihrer Anwendung erheblich verbessern.

Schlussfolgerung

Die Integration von C#s IEnumerable mitIronPDFschaltet eine effiziente und flexible Möglichkeit frei, um auf programmatischem Weg professionelle PDFs zu erstellen. Durch die Nutzung von IEnumerable können Sie die Transformation und Formatierung von Daten vereinfachen und gleichzeitig von den umfangreichen Funktionen von IronPDF profitieren, um Dokumente in hoher Qualität zu erstellen. Egal, ob Sie Datenberichte exportieren, Rechnungen erstellen oder personalisierte Inhalte generieren, diese Kombination gewährleistet Skalierbarkeit, Leistung und Benutzerfreundlichkeit.

Wir ermutigen Entwickler, die fortgeschrittenen Funktionen von IronPDF zu erkunden, wie das Einbetten von Multimedia oder das Sichern von PDFs, um ihre Dokumentautomatisierungs-Workflows weiter zu verbessern. Für weitere Einblicke, Tutorials und Unterstützung, beziehen Sie sich auf dieIronPDF-Dokumentation.

Regan Pun

Software-Ingenieur

LinkedIn

Regan schloss sein Studium an der University of Reading mit einem BA in Elektrotechnik ab. Bevor er zu Iron Software kam, konzentrierte er sich in seinen früheren Jobs auf einzelne Aufgaben. Was ihm bei Iron Software am meisten Spaß macht, ist das Spektrum der Aufgaben, die er übernehmen kann, sei es im Vertrieb, im technischen Support, in der Produktentwicklung oder im Marketing. Es macht ihm Spaß, die Art und Weise zu verstehen, wie Entwickler die Bibliothek von Iron Software nutzen, und dieses Wissen zu nutzen, um die Dokumentation und die Produkte kontinuierlich zu verbessern.

< PREVIOUS
C# Parallel Foreach (Wie es für Entwickler funktioniert)

NÄCHSTES >
C#-Ereignisse (Wie es für Entwickler funktioniert)