Dynamische PDF-Erstellung ermöglicht es Ihren .NET-Anwendungen, personalisierte Rechnungen, Echtzeit-Datenberichte und benutzerdefinierte Zertifikate auf Abruf zu erstellen — alles ohne eine einzige statische Vorlage zu berühren. IronPDF macht dies unkompliziert, indem es eine auf Chrome basierende Rendering-Engine bereitstellt, die HTML, CSS und JavaScript direkt in pixelgenaue PDF-Dokumente umwandelt, sodass Sie sich auf die Geschäftslogik anstatt auf die internen Details von PDF konzentrieren können.
Dieser Leitfaden führt Sie durch alle wichtigen Techniken zur Erstellung datengesteuerter PDFs in .NET: Installation der Bibliothek, Anwendung von Platzhaltervorlagen, programmatische Tabellenerstellung, Verwendung bedingter Inhaltsblöcke und Ausführung von JavaScript vor dem Rendern. Jeder Abschnitt enthält ein funktionierendes C#-Codebeispiel und eine Erläuterung, wann man die jeweilige Strategie anwenden sollte. Am Ende dieses Kurses verfügen Sie über ausreichend praktische Kenntnisse, um ein komplettes dynamisches PDF-Generierungssystem zu entwickeln, das auf die spezifischen Anforderungen Ihrer Anwendung zugeschnitten ist.
Dynamische PDF-Generierung bedeutet, dass PDF-Dokumente zur Laufzeit erstellt werden, wobei jedes Inhaltselement – Namen, Abbildungen, Datumsangaben, Tabellen, Diagramme – aus Live-Daten und nicht aus einem festen Layout stammt. Die Dokumentstruktur mag gleich bleiben, aber der Inhalt ändert sich mit jeder Anfrage.
Hier sind die Szenarien, in denen dieser Ansatz den größten Nutzen bringt:
Die herkömmliche Alternative besteht darin, eine Bibliothek statischer Vorlagen zu pflegen und diese für jede Variante manuell zu bearbeiten. Dieser Ansatz stößt schnell an seine Grenzen, wenn das Dokumentenvolumen zunimmt und sich die Geschäftsregeln vervielfachen. Mit der HTML-zu-PDF-Konvertierungs-Engine von IronPDF schreiben Sie die Generierungslogik nur einmal und erzeugen Tausende von korrekt formatierten, datengenauen PDFs ohne manuelle Eingriffe.
IronPDF läuft unter Windows, Linux, macOS, Docker und Azure – die gleiche API funktioniert auf allen Plattformen identisch. Diese plattformübergreifende Konsistenz bedeutet, dass Sie lokal entwickeln und in einem Cloud-Container bereitstellen können, ohne plattformspezifische Anpassungen vornehmen zu müssen. Die Bibliothek ist für .NET 6 und höher ausgelegt und unterstützt sowohl die neuesten .NET Versionen als auch Versionen mit Langzeitunterstützung.
IronPDF wird als NuGet Paket vertrieben und lässt sich in jedes .NET 6- oder späteres Projekt integrieren, einschließlich ASP.NET Core, Blazor und Konsolenanwendungen. Installieren Sie es über die Paket-Manager-Konsole oder die .NET -Befehlszeilenschnittstelle:
Sobald das Paket installiert ist, können Sie sofort mit der Generierung von PDFs beginnen – während der kostenlosen Testphase ist keine Konfigurationsdatei oder ein API-Schlüssel erforderlich. Für Produktionslizenzen besuchen Sie die IronPDF Lizenzierungsseite und wählen Sie den Plan aus, der zu Ihrem Bereitstellungsmodell passt.
Der Einstiegspunkt für alle Renderings ist ChromePdfRenderer. Der folgende Codeausschnitt zeigt den minimalen Code, der benötigt wird, um eine dynamische HTML-Zeichenkette in eine gespeicherte PDF-Datei umzuwandeln:
using IronPdf;
var renderer = new ChromePdfRenderer();
var customerName = "Alexandra Chen";
var orderNumber = "ORD-2025-001";
var totalAmount = 1499.99m;
var html = $"""
<h1>Order Confirmation</h1>
<p>Dear {customerName},</p>
<p>Thank you for your order #{orderNumber}.</p>
<p>Total amount: ${totalAmount:F2}</p>
<p>Your order will be processed within 24 hours.</p>
""";
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("order-confirmation.pdf");
// Stream the bytes directly in a web response if needed
byte[] pdfBytes = pdf.BinaryData;Imports IronPdf
Dim renderer As New ChromePdfRenderer()
Dim customerName As String = "Alexandra Chen"
Dim orderNumber As String = "ORD-2025-001"
Dim totalAmount As Decimal = 1499.99D
Dim html As String = $"
<h1>Order Confirmation</h1>
<p>Dear {customerName},</p>
<p>Thank you for your order #{orderNumber}.</p>
<p>Total amount: ${totalAmount:F2}</p>
<p>Your order will be processed within 24 hours.</p>
"
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("order-confirmation.pdf")
' Stream the bytes directly in a web response if needed
Dim pdfBytes As Byte() = pdf.BinaryDataChromePdfRenderer behandelt alle Komplexitäten des Renderings intern. String-Interpolation ($"""...""") fügt C#-Variablen in HTML an der Aufrufstelle ein und hält Vorlagen lesbar, wodurch für einfache Fälle eine dedizierte Vorlagenbibliothek entfällt.
Eine vollständige Anleitung zur Einrichtung, einschließlich der Konfiguration für MVC-Views und Blazor Serverprojekte, finden Sie in der IronPDF Dokumentation .
Die vorlagenbasierte Generierung trennt das Dokumentdesign von der Datenbindung. Ein Designer erstellt das HTML-Layout einmal, indem er benannte Platzhalter ({{TOKEN}}) an den Stellen einfügt, an denen zur Laufzeit Werte erscheinen sollen. Ihre Anwendung ersetzt diese Token vor dem Rendering. Dies ist das in den Diskussionen über die PDF-Generierung auf Stack Overflow empfohlene Muster für Projekte, bei denen sich die Vorlagen häufiger ändern als der Anwendungscode.
using IronPdf;
// Reusable template -- stored in a file or database in production
var htmlTemplate = """
<style>
.invoice { font-family: Arial; max-width: 800px; margin: auto; }
.header { background: #f0f0f0; padding: 20px; }
.label { font-weight: bold; }
</style>
<div class='invoice'>
<div class='header'>
<h2>Invoice #{{INVOICE_NUMBER}}</h2>
<p>Date: {{INVOICE_DATE}}</p>
</div>
<p>Bill to: {{CUSTOMER_NAME}}</p>
<p class='label'>Amount due: ${{TOTAL_AMOUNT}}</p>
</div>
""";
var invoiceHtml = htmlTemplate
.Replace("{{INVOICE_NUMBER}}", "INV-2025-1234")
.Replace("{{INVOICE_DATE}}", DateTime.Now.ToString("MMM dd, yyyy"))
.Replace("{{CUSTOMER_NAME}}", "TechCorp Industries")
.Replace("{{TOTAL_AMOUNT}}", "5,750.00");
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.TextHeader = new TextHeaderFooter
{
CenterText = "Invoice",
DrawDividerLine = true
};
var pdf = renderer.RenderHtmlAsPdf(invoiceHtml);
pdf.SaveAs("invoice.pdf");Imports IronPdf
' Reusable template -- stored in a file or database in production
Dim htmlTemplate As String = "
<style>
.invoice { font-family: Arial; max-width: 800px; margin: auto; }
.header { background: #f0f0f0; padding: 20px; }
.label { font-weight: bold; }
</style>
<div class='invoice'>
<div class='header'>
<h2>Invoice #{{INVOICE_NUMBER}}</h2>
<p>Date: {{INVOICE_DATE}}</p>
</div>
<p>Bill to: {{CUSTOMER_NAME}}</p>
<p class='label'>Amount due: ${{TOTAL_AMOUNT}}</p>
</div>
"
Dim invoiceHtml As String = htmlTemplate _
.Replace("{{INVOICE_NUMBER}}", "INV-2025-1234") _
.Replace("{{INVOICE_DATE}}", DateTime.Now.ToString("MMM dd, yyyy")) _
.Replace("{{CUSTOMER_NAME}}", "TechCorp Industries") _
.Replace("{{TOTAL_AMOUNT}}", "5,750.00")
Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.TextHeader = New TextHeaderFooter With {
.CenterText = "Invoice",
.DrawDividerLine = True
}
Dim pdf = renderer.RenderHtmlAsPdf(invoiceHtml)
pdf.SaveAs("invoice.pdf")Die Token ({{...}}) markieren genau, wo Daten in das Dokument gelangen, sodass Vorlagen von Nicht-Entwicklern lesbar sind. Durch das Speichern von Vorlagen als externe Dateien kann ein Designer das Layout aktualisieren, ohne den Anwendungscode verändern zu müssen. Eine detailliertere Beschreibung dieses Musters finden Sie im IronPDF Vorlagen-Tutorial .
Wenn der Dokumentinhalt von Schleifen, Aggregationen oder bedingter Formatierung abhängt, bietet die Erstellung des HTML-Strings im Code die größte Kontrolle. Diese Vorgehensweise ist im Finanz- und Betriebsberichtswesen üblich, wo die Anzahl der Zeilen zur Kompilierzeit unbekannt ist. Sie ermöglicht es außerdem, Formatierungsregeln direkt in C# anzuwenden, anstatt sie in eine statische Vorlage einzubetten.
using IronPdf;
using System.Text;
var orderItems = new[]
{
new { Product = "Premium License", Quantity = 5, Price = 399.00m },
new { Product = "Support Package", Quantity = 1, Price = 299.00m },
new { Product = "Training Session", Quantity = 2, Price = 150.00m }
};
var sb = new StringBuilder();
sb.Append("<h2>Order Summary</h2>");
sb.Append("<table style='width:100%; border-collapse:collapse;'>");
sb.Append("<tr style='background:#333; color:white;'>");
sb.Append("<th style='padding:10px;'>Product</th><th>Qty</th><th>Unit Price</th><th>Total</th>");
sb.Append("</tr>");
decimal grandTotal = 0;
foreach (var item in orderItems)
{
var lineTotal = item.Quantity * item.Price;
grandTotal += lineTotal;
sb.Append($"""
<tr>
<td style='padding:10px;'>{item.Product}</td>
<td style='text-align:center;'>{item.Quantity}</td>
<td style='text-align:right;'>${item.Price:F2}</td>
<td style='text-align:right;'>${lineTotal:F2}</td>
</tr>
""");
}
sb.Append($"""
<tr style='font-weight:bold; background:#f0f0f0;'>
<td colspan='3' style='padding:10px; text-align:right;'>Grand total:</td>
<td style='text-align:right; padding:10px;'>${grandTotal:F2}</td>
</tr>
""");
sb.Append("</table>");
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(sb.ToString());
pdf.SaveAs("order-summary.pdf");
// Get bytes for a web download response
byte[] pdfData = pdf.BinaryData;Imports IronPdf
Imports System.Text
Dim orderItems = New() {
New With {.Product = "Premium License", .Quantity = 5, .Price = 399.0D},
New With {.Product = "Support Package", .Quantity = 1, .Price = 299.0D},
New With {.Product = "Training Session", .Quantity = 2, .Price = 150.0D}
}
Dim sb = New StringBuilder()
sb.Append("<h2>Order Summary</h2>")
sb.Append("<table style='width:100%; border-collapse:collapse;'>")
sb.Append("<tr style='background:#333; color:white;'>")
sb.Append("<th style='padding:10px;'>Product</th><th>Qty</th><th>Unit Price</th><th>Total</th>")
sb.Append("</tr>")
Dim grandTotal As Decimal = 0
For Each item In orderItems
Dim lineTotal = item.Quantity * item.Price
grandTotal += lineTotal
sb.Append($"
<tr>
<td style='padding:10px;'>{item.Product}</td>
<td style='text-align:center;'>{item.Quantity}</td>
<td style='text-align:right;'>${item.Price:F2}</td>
<td style='text-align:right;'>${lineTotal:F2}</td>
</tr>
")
Next
sb.Append($"
<tr style='font-weight:bold; background:#f0f0f0;'>
<td colspan='3' style='padding:10px; text-align:right;'>Grand total:</td>
<td style='text-align:right; padding:10px;'>${grandTotal:F2}</td>
</tr>
")
sb.Append("</table>")
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(sb.ToString())
pdf.SaveAs("order-summary.pdf")
' Get bytes for a web download response
Dim pdfData As Byte() = pdf.BinaryDataStringBuilder verarbeitet große HTML-Zeichenfolgen effizient. Die foreach Schleife erweitert sich auf so viele Zeilen, wie Ihre Datenquelle bereitstellt, und die laufende grandTotal Berechnung zeigt, wie sich Geschäftslogik natürlich mit HTML-Konstruktion integriert. Bei sehr großen Datensätzen passt dieser Ansatz gut zu den Mehrseiten-Rendering-Optionen von IronPDF .
Aus Datenbanken generierte Berichte enthalten oft unvorhersehbare Zeilenanzahlen. Die korrekte Handhabung automatischer Seitenumbrüche – ohne eine Zeile zu halbieren – erfordert neben den Rendering-Optionen von IronPDF spezifisches CSS. Die page-break-inside: avoid Regel, kombiniert mit korrekter Randkonfiguration, hält jede Zeile intakt, während die Tabelle über Seiten hinweg fließt.
using IronPdf;
var salesData = Enumerable.Range(1, 30).Select(i => new
{
Month = $"Month {i}",
Revenue = 10_000 + (i * 500),
Growth = 2.5 + (i * 0.3)
});
var tableHtml = """
<style>
table { width: 100%; border-collapse: collapse; page-break-inside: auto; }
th { background: #2c3e50; color: white; padding: 12px; }
td { padding: 8px; border-bottom: 1px solid #ddd; }
tr:nth-child(even) { background: #f9f9f9; }
tr { page-break-inside: avoid; page-break-after: auto; }
</style>
<h2>Sales Performance Report</h2>
<table>
<thead><tr><th>Period</th><th>Revenue</th><th>Growth %</th></tr></thead>
<tbody>
""";
foreach (var row in salesData)
{
tableHtml += $"""
<tr>
<td>{row.Month}</td>
<td>${row.Revenue:N0}</td>
<td>{row.Growth:F1}%</td>
</tr>
""";
}
tableHtml += "</tbody></table>";
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;
renderer.RenderingOptions.MarginTop = 40;
renderer.RenderingOptions.MarginBottom = 40;
renderer.RenderingOptions.TextFooter = new TextHeaderFooter
{
CenterText = "{page} of {total-pages}",
FontSize = 10
};
var pdf = renderer.RenderHtmlAsPdf(tableHtml);
pdf.SaveAs("sales-report.pdf");Imports IronPdf
Dim salesData = Enumerable.Range(1, 30).Select(Function(i) New With {
.Month = $"Month {i}",
.Revenue = 10000 + (i * 500),
.Growth = 2.5 + (i * 0.3)
})
Dim tableHtml As String = "
<style>
table { width: 100%; border-collapse: collapse; page-break-inside: auto; }
th { background: #2c3e50; color: white; padding: 12px; }
td { padding: 8px; border-bottom: 1px solid #ddd; }
tr:nth-child(even) { background: #f9f9f9; }
tr { page-break-inside: avoid; page-break-after: auto; }
</style>
<h2>Sales Performance Report</h2>
<table>
<thead><tr><th>Period</th><th>Revenue</th><th>Growth %</th></tr></thead>
<tbody>
"
For Each row In salesData
tableHtml += $"
<tr>
<td>{row.Month}</td>
<td>${row.Revenue:N0}</td>
<td>{row.Growth:F1}%</td>
</tr>
"
Next
tableHtml += "</tbody></table>"
Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4
renderer.RenderingOptions.MarginTop = 40
renderer.RenderingOptions.MarginBottom = 40
renderer.RenderingOptions.TextFooter = New TextHeaderFooter With {
.CenterText = "{page} of {total-pages}",
.FontSize = 10
}
Dim pdf = renderer.RenderHtmlAsPdf(tableHtml)
pdf.SaveAs("sales-report.pdf"){page} und {total-pages} sind die in IronPDF integrierten Token für die automatische Fußzeilennummerierung. Die Seitenränder sorgen dafür, dass der Inhalt auf jeder Seite nicht an den Rand gerät und verleihen dem fertigen Bericht ein Professional Aussehen, selbst wenn die Tabelle Dutzende von Seiten umfasst.
Hinweise zur Formatierung komplexer Tabellenlayouts, einschließlich verbundener Zellen, finden Sie in der Referenz zu den Rendering-Optionen von IronPDF .
Viele Dokumenttypen enthalten Abschnitte, die nur unter bestimmten Bedingungen angezeigt werden sollen – ein Premium-Abzeichen für Top-Kunden, ein Rabattblock bei einer Werbeaktion, eine Warnung bei einem überfälligen Konto. Die bedingte Logik in C# entspricht dieser Anforderung direkt, und da die Bedingung ausgewertet wird, bevor die HTML-Zeichenfolge erstellt wird, landen keine leeren Platzhalterelemente im endgültigen PDF.
using IronPdf;
var customer = new
{
Name = "Global Tech Solutions",
IsPremium = true,
HasDiscount = true,
DiscountPct = 15,
LoyaltyPoints = 2500
};
var html = $"""<h2>Customer Profile: {customer.Name}</h2><div style='border:1px solid #ddd; padding:20px;'>""";
if (customer.IsPremium)
{
html += """<div style='background:gold; padding:10px; margin-bottom:10px;'>PREMIUM MEMBER -- Exclusive benefits applied</div>""";
}
if (customer.HasDiscount)
{
html += $"""<div style='background:#e8f5e9; padding:10px; margin-bottom:10px;'>Special discount: {customer.DiscountPct}% off all orders</div>""";
}
if (customer.LoyaltyPoints > 0)
{
html += $"""<div style='background:#f3e5f5; padding:10px;'>Loyalty points balance: {customer.LoyaltyPoints:N0} points</div>""";
}
html += "</div>";
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("customer-profile.pdf");Imports IronPdf
Dim customer = New With {
.Name = "Global Tech Solutions",
.IsPremium = True,
.HasDiscount = True,
.DiscountPct = 15,
.LoyaltyPoints = 2500
}
Dim html = $"<h2>Customer Profile: {customer.Name}</h2><div style='border:1px solid #ddd; padding:20px;'>"
If customer.IsPremium Then
html += "<div style='background:gold; padding:10px; margin-bottom:10px;'>PREMIUM MEMBER -- Exclusive benefits applied</div>"
End If
If customer.HasDiscount Then
html += $"<div style='background:#e8f5e9; padding:10px; margin-bottom:10px;'>Special discount: {customer.DiscountPct}% off all orders</div>"
End If
If customer.LoyaltyPoints > 0 Then
html += $"<div style='background:#f3e5f5; padding:10px;'>Loyalty points balance: {customer.LoyaltyPoints:N0} points</div>"
End If
html += "</div>"
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("customer-profile.pdf")Dieses Muster lässt sich auf beliebige regelbasierte Inhalte ausweiten: beispielsweise auf länderspezifische rechtliche Hinweise, auf den Warenkorbwert abgestimmte Werbeabschnitte oder auf die Produktkategorie abgestimmte Sicherheitswarnungen. Das resultierende PDF enthält genau den Inhalt, den es enthalten soll – nicht mehr und nicht weniger.
Moderne Dashboards verwenden häufig JavaScript Bibliotheken wie Chart.js oder D3.js , um Diagramme zur Renderzeit zu erstellen. IronPDF kann JavaScript ausführen, bevor die Seite erfasst wird, sodass das Diagramm vollständig gerendert wird, bevor der PDF-Snapshot erstellt wird. Das bedeutet, dass Sie keinen separaten Screenshot-Dienst oder eine serverseitige Bibliothek zum Rendern von Diagrammen benötigen.
using IronPdf;
var chartHtml = """
<script src='https://cdn.jsdelivr.net/npm/chart.js'></script>
<canvas id='revenueChart' width='500' height='250'></canvas>
<script>
var ctx = document.getElementById('revenueChart').getContext('2d');
new Chart(ctx, {
type: 'bar',
data: {
labels: ['Q1', 'Q2', 'Q3', 'Q4'],
datasets: [{
label: 'Revenue (thousands)',
data: [120, 195, 230, 285],
backgroundColor: '#3498db'
}]
},
options: { animation: false }
});
</script>
""";
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor.RenderDelay(1500);
var pdf = renderer.RenderHtmlAsPdf(chartHtml);
pdf.SaveAs("revenue-chart.pdf");Imports IronPdf
Dim chartHtml As String = "
<script src='https://cdn.jsdelivr.net/npm/chart.js'></script>
<canvas id='revenueChart' width='500' height='250'></canvas>
<script>
var ctx = document.getElementById('revenueChart').getContext('2d');
new Chart(ctx, {
type: 'bar',
data: {
labels: ['Q1', 'Q2', 'Q3', 'Q4'],
datasets: [{
label: 'Revenue (thousands)',
data: [120, 195, 230, 285],
backgroundColor: '#3498db'
}]
},
options: { animation: false }
});
</script>
"
Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.EnableJavaScript = True
renderer.RenderingOptions.WaitFor.RenderDelay(1500)
Dim pdf = renderer.RenderHtmlAsPdf(chartHtml)
pdf.SaveAs("revenue-chart.pdf")EnableJavaScript = true aktiviert die Skriptausführung im Headless Chrome-Engine. RenderDelay(1500) fügt nach dem Laden der Seite eine Pause von 1,5 Sekunden hinzu, um asynchrones Diagramm-Rendering abzuschließen, bevor das Bild aufgenommen wird. Die Festlegung von animation: false in den Chart.js-Optionen verhindert, dass animierte Frames während des Übergangs erfasst werden.
Diese Technik funktioniert mit jeder JavaScript Bibliothek. Sie können serverseitige Daten in den <script> Block mit C#-String-Interpolation einfügen, sodass jedes Diagramm aktuelle Datenbankwerte zum Zeitpunkt der Generierung widerspiegelt. Weitere Details zur JavaScript Konfiguration finden Sie im JavaScript Rendering-Leitfaden von IronPDF .
Sobald RenderHtmlAsPdf ein PdfDocument Objekt zurückgibt, haben Sie je nach Anwendungsart mehrere Lieferoptionen. Das Speichern auf der Festplatte ist die einfachste Methode und funktioniert auch für Batch-Prozesse im Hintergrund. Bei Web-APIs und MVC-Controllern vermeidet das direkte Streaming der Bytes in die HTTP-Antwort das Schreiben temporärer Dateien und hält das Server-Dateisystem sauber.
using IronPdf;
using Microsoft.AspNetCore.Mvc;
// In an ASP.NET Core controller action:
public IActionResult DownloadInvoice(int orderId)
{
var renderer = new ChromePdfRenderer();
var html = BuildInvoiceHtml(orderId); // your data-binding method
var pdf = renderer.RenderHtmlAsPdf(html);
return File(pdf.BinaryData, "application/pdf", $"invoice-{orderId}.pdf");
}Imports IronPdf
Imports Microsoft.AspNetCore.Mvc
' In an ASP.NET Core controller action:
Public Function DownloadInvoice(orderId As Integer) As IActionResult
Dim renderer = New ChromePdfRenderer()
Dim html = BuildInvoiceHtml(orderId) ' your data-binding method
Dim pdf = renderer.RenderHtmlAsPdf(html)
Return File(pdf.BinaryData, "application/pdf", $"invoice-{orderId}.pdf")
End Functionpdf.BinaryData gibt die rohen Bytes als ein byte[] zurück, das direkt auf das File() Ergebnis von ASP.NET Core abbildet. Der Browser erhält den korrekten MIME-Typ (application/pdf) und löst einen Download-Dialog mit einem sinnvollen Dateinamen aus.
Zu den zusätzlichen Ausgabefunktionen gehören PDF-Zusammenführung , digitale Signaturen , das Archivformat PDF/A , Passwortschutz sowie Text- und Bildextraktion . Diese Funktionen arbeiten mit demselben PdfDocument Objekt, das vom Renderer zurückgegeben wird, sodass Sie Operationen verketten können, ohne Zwischenfiles zu erstellen.
Die dynamische PDF-Generierung in .NET beruht auf drei Bausteinen: einer HTML-Zeichenfolge, die sich mit Ihren Daten ändert, ChromePdfRenderer, um diese Zeichenfolge in ein PDF umzuwandeln, und dem Auslieferungsmechanismus, der zu Ihrer Anwendung passt. IronPDF kümmert sich um alles dazwischen – Seitenumbrüche, Kopf- und Fußzeilen, JavaScript Ausführung und plattformübergreifende Kompatibilität.
Um vom Lesen zum Erstellen überzugehen, installieren Sie zunächst das Paket und führen Sie eines der obigen Beispiele mit Ihren eigenen Daten aus:
Von dort aus können Sie in der IronPDF Dokumentation plattformspezifische Einrichtungshinweise (Azure, Docker, Linux), erweiterte Rendering-Optionen und die vollständige API-Referenz einsehen. Wenn Sie bereit sind, die Software einzusetzen, besuchen Sie die Lizenzierungsseite , um einen Plan auszuwählen, der zu Ihrem Produktionsvolumen passt. Mit der kostenlosen Testversion erhalten Sie vollen Zugriff auf alle Funktionen, ohne dass eine Kreditkarte erforderlich ist. So können Sie Ihre Implementierung überprüfen, bevor Sie sich endgültig entscheiden.
Weitere Leitfäden, die gut mit der dynamischen Generierung harmonieren:
Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender Handbücher.
IronPDF ist ein Teil der IRONSUITE
10 .NET-API-Produkte für Ihre Bürodokumente
Wenn Ihr PDF wie HTML aussehen soll, schnell.
