Das IEnumerable-Interface von C# ist eines der vielseitigsten Werkzeuge im .NET-Framework, das es Entwicklern ermöglicht, mit Sammlungen auf hochflexible Weise zu arbeiten. In Kombination mit IronPDF ermöglicht IEnumerable die dynamische Datenmanipulation und effiziente PDF-Erstellung, was ideal für Szenarien wie Berichterstellung, Datenexport oder die Erstellung von Dokumenten aus Datenbankabfragen ist.
Die Verwendung von IEnumerable stellt sicher, dass Ihre Anwendung skalierbar und speichereffizient bleibt, da sie Daten verzögert verarbeitet und das Laden ganzer Datensätze in den Speicher auf einmal vermeidet. Dies ist besonders nützlich für groß angelegte Anwendungen, die umfangreiche Datensammlungen handhaben, wie etwa eine riesige Datenbanktabelle.
IronPDF ist eine leistungsstarke .NET-Bibliothek, die entwickelt wurde, um den Prozess der Erstellung, Bearbeitung und Verwaltung von PDF-Dateien programmatisch zu vereinfachen. Es bietet eine breite Palette von Funktionen, einschließlich HTML-zu-PDF-Konvertierung, Textextraktion, PDF-Zusammenführung und mehr. Indem Sie IronPDF in Ihre C#-Projekte integrieren, können Sie komplexe PDF-Aufgaben effizient handhaben, ohne tiefgehende Expertise in den 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 generieren können. Diese Flexibilität macht es zu einem unverzichtbaren Werkzeug für Entwickler, die moderne, datengesteuerte Anwendungen bauen.
Um IronPDF in Ihrem Projekt zu verwenden, befolgen Sie diese Schritte:
Das IEnumerable-Interface repräsentiert eine Sequenz von Elementen, die aufgezählt werden können. Gängige Beispiele sind Arrays, Listen und LINQ-Abfrageergebnisse. Durch Nutzung von LINQ können Sie Daten filtern, sortieren und in das gewünschte Format projizieren, bevor Sie PDFs mit IronPDF generieren.
Einer der Hauptvorteile von IEnumerable ist sein verzögertes Ausführungsmodell, das erlaubt, Abfragen erst auszuführen, wenn deren Ergebnisse abgerufen werden. Dies ermöglicht eine effiziente Datenverarbeitung und reduziert den rechnerischen Aufwand in komplexen Workflows.
Da eine Liste IEnumerable implementiert, kann jede Sammlung, wie List, als IEnumerable behandelt werden, was einfache LINQ-Operationen, Filterung und Transformation ermöglicht.
Stellen Sie sich vor, Sie haben eine Liste, die IEnumerable von Mitarbeitern implementiert, die Sie als PDF-Tabelle exportieren müssen. Mit IEnumerable und IronPDF können Sie durch die Daten iterieren und sie in ein gut strukturiertes PDF konvertieren.
Um die Präsentation zu verbessern, können Sie HTML-Tabellen mit Inline-CSS verwenden, um die Zeilen und Spalten dynamisch basierend auf den Daten zu formatieren. Dies stellt sicher, dass die PDF-Ausgabe sowohl funktional als auch optisch ansprechend ist.
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
});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 transformierten Daten können dann in ein PDF-freundliches HTML-Format zum Rendern umgewandelt werden.
Wenn Sie für jeden Datensatz in einer Sammlung ein separates PDF generieren müssen, können Sie eine foreach-Schleife verwenden, um durch das Enumerierbare 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");
}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 employeeIn C# sind Erweiterungsmethoden eine leistungsstarke Möglichkeit, bestehenden Typen Funktionalität hinzuzufügen, ohne ihren Quellcode zu modifizieren. Sie können eine Erweiterungsmethode erstellen, um Operationen auf einem IEnumerable oder List zu optimieren.
Zum Beispiel lassen Sie uns eine Erweiterungsmethode erstellen, um das erste Element aus einer enumerierbaren Sammlung zu erhalten.
public static class EnumerableExtensions
{
public static T FirstOrDefaultElement<t>(this IEnumerable<t> collection)
{
return collection?.FirstOrDefault();
}
}Imports System.Collections.Generic
Imports System.Linq
Public Module EnumerableExtensions
<System.Runtime.CompilerServices.Extension>
Public Function FirstOrDefaultElement(Of T)(collection As IEnumerable(Of T)) As T
Return If(collection?.FirstOrDefault(), Nothing)
End Function
End ModuleBeginnen Sie mit der Einrichtung Ihres Projekts und der Initialisierung von IronPDF und der ChromePdfRenderer-Klasse:
using IronPdf;
ChromePdfRenderer renderer = new ChromePdfRenderer();Imports IronPdf
Private renderer As New ChromePdfRenderer()Bereiten Sie Ihre enumerierten Daten als HTML-Zeichenfolge 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>";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>"Konvertieren Sie das HTML in ein PDF:
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("Employees.pdf");Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("Employees.pdf")Jetzt haben wir uns eingehender damit beschäftigt, wie Sie die C#-Enumerable-Klasse mit IronPDF verwenden können, um PDF-Dateien zu generieren. Werfen wir einen Blick auf ein vollständiges Beispiel, in dem wir diese Werkzeuge zur Erstellung eines neuen, dynamischen PDF-Dokuments verwendet haben.
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 a 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 a 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
Dieses C#-Programm ist dazu gedacht, einen PDF-Bericht gefilterter Mitarbeiterdaten mithilfe der IronPDF-Bibliothek zu generieren. Der obige Code beginnt mit der Definition einer Employee-Klasse mit Eigenschaften für Name, Position und Alter, die einzelne Mitarbeiterdatensätze darstellen.
Eine Liste von Beispieldaten von Mitarbeitern wird erstellt, die aus drei Employee-Objekten mit verschiedenen Namen, Positionen und Altersstufen besteht. Das Programm verwendet dann LINQ, um diese Liste zu filtern. Es werden nur Mitarbeiter ausgewählt, die 25 Jahre oder älter sind, und sie werden alphabetisch nach Namen sortiert. Diese gefilterte und sortierte Liste wird in der Variable filteredEmployees gespeichert.
Als nächstes erstellt das Programm eine HTML-Zeichenfolge, die zum Erzeugen des PDFs verwendet wird. Es beginnt mit einer Überschrift und einer Tabellenstruktur, die die Spaltenüberschriften für Name, Position und Alter definiert. Anschließend wird durch die gefilterte Mitarbeiterliste geschleift, um für jede Mitarbeiterinformation dynamisch Tabellenzeilen zu generieren. Das resultierende HTML wird verwendet, um ein PDF über den ChromePdfRenderer von IronPDF zu erstellen.
Das obige Beispiel demonstriert effektiv, wie man IronPDF verwendet, um ein PDF aus dynamisch generiertem HTML zu erzeugen. Es zeigt die Leistungsfähigkeit von LINQ zur Filterung und Sortierung von Daten und den Umgang mit Ausnahmen bei der PDF-Erstellung auf.
Verwenden Sie LINQ, um das Filtern und die Transformationen Ihrer Daten zu optimieren. Zum Beispiel:
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 Datensätzen.
Bei großen Datensätzen sollten Sie in Erwägung ziehen, Daten in kleinere Blöcke zu streamen, um Speicherüberlastungen zu vermeiden. Verwenden Sie yield return, um Sammlungen träge zu erzeugen und einen effizienten Speicherverbrauch sicherzustellen.
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 FunctionUmschließen Sie Ihre PDF-Erstellungslogik in einem Try-Catch-Block, um Fehler elegant zu behandeln:
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 TryDas Protokollieren von Fehlern und die Bereitstellung benutzerfreundlicher Rückmeldungen können die Robustheit Ihrer Anwendung erheblich verbessern.
Die Integration von C#'s IEnumerable mit IronPDF öffnet einen effizienten und flexiblen Weg zur programmgesteuerten Erstellung professioneller PDFs. Durch die Nutzung von IEnumerable können Sie die Transformation und Formatierung von Daten optimieren, während Sie die umfassende Funktionalität von IronPDF nutzen, um hochwertige Dokumente zu erstellen. Ob Sie Datenberichte exportieren, Rechnungen erstellen oder personalisierte Inhalte generieren - diese Kombination sichert Skalierbarkeit, Leistung und Benutzerfreundlichkeit.
Wir ermutigen Entwickler, sich eingehender mit den erweiterten Funktionen von IronPDF, wie der Einbettung von Multimedia oder der Sicherung von PDFs, zu beschäftigen, um ihre Arbeitsabläufe in der Dokumentenautomatisierung weiter zu verbessern. Für zusätzliche Einblicke, Tutorials und Unterstützung siehe die IronPDF-Dokumentation.
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.
IronPDF ist ein Teil der IRONSUITE
10 .NET-API-Produkte für Ihre Bürodokumente
Wenn Ihr PDF wie HTML aussehen soll, schnell.
