Wie man mit IronPDF dynamisch PDF in .NET generiert

Was ist dynamische PDF-Generierung in .NET?

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:

• Rechnungserstellung – Einzelposten, Summen, Steuersätze und Zahlungsbedingungen unterscheiden sich für jede Transaktion.
• Finanzberichte – Diagramme und Übersichtstabellen greifen auf eine Datenbank zu, die den ganzen Tag über aktualisiert wird.
• Zertifikate und Diplome – Namen der Empfänger, Abschlussdaten und Kursdetails variieren je nach Datensatz.
• Rechtsdokumente – Verträge enthalten kundenspezifische Klauseln und Gerichtsstandsregeln.
• Medizinische Unterlagen – Patientendaten, Testergebnisse und Behandlungspläne erfordern eine individuelle Formatierung

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 for .NET 6 und höher ausgelegt und unterstützt sowohl die neuesten .NET Versionen als auch Versionen mit Langzeitunterstützung.

Wie installiert und konfiguriert man die Bibliothek?

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:

Install-Package IronPdf
dotnet add package IronPdf

Install-Package IronPdf
dotnet add package IronPdf

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 das gesamte Rendering 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;

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

ChromePdfRenderer übernimmt die gesamte Rendering-Komplexität intern. String-Interpolation ($"""...""") fügt C#-Variablen an der Aufrufstelle in HTML ein, wodurch die Vorlagen lesbar bleiben und für einfache Fälle eine separate 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 .

Wie wendet man die vorlagenbasierte PDF-Generierung an?

Die vorlagenbasierte Generierung trennt das Dokumentdesign von der Datenbindung. Ein Designer erstellt das HTML-Layout einmalig und platziert benannte Platzhalter ({{TOKEN}}) an allen Stellen, an denen Laufzeitwerte erscheinen sollen. Ihre Anwendung ersetzt diese Platzhalter vor dem Rendern. 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");

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 Tokens ({{...}}) markieren genau die Stellen, an denen Daten in das Dokument gelangen, wodurch die Vorlagen auch für Nicht-Entwickler lesbar werden. 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 .

Wie erstellt man programmgesteuert PDFs aus Daten?

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;

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

StringBuilder verarbeitet große HTML-Zeichenketten effizient. Die Schleife foreach wird auf die Anzahl der Zeilen erweitert, die Ihre Datenquelle liefert, und die laufende Berechnung grandTotal zeigt, wie sich Geschäftslogik auf natürliche Weise in die HTML-Konstruktion integriert. Bei sehr großen Datensätzen passt dieser Ansatz gut zu den Mehrseiten-Rendering-Optionen von IronPDF .

Wie geht man mit dynamischen Tabellen um, die sich über mehrere Seiten erstrecken?

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 Regel page-break-inside: avoid sorgt in Kombination mit der korrekten Randkonfiguration dafür, dass jede Zeile beim Seitenumbruch der Tabelle erhalten bleibt.

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");

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

Wie fügt man bedingten Inhalt zu einer PDF-Datei hinzu?

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");

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.

Wie rendert man JavaScript-basierte Diagramme in einem PDF?

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");

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-Modus. RenderDelay(1500) fügt nach dem Laden der Seite eine 1,5-sekündige Pause ein, um dem asynchronen Rendern des Diagramms Zeit zu geben, bevor der Snapshot erstellt wird. Durch die Einstellung animation: false in den Chart.js-Optionen wird verhindert, dass animierte Frames während des Übergangs erfasst werden.

Diese Technik funktioniert mit jeder JavaScript Bibliothek. Sie können serverseitige Daten mithilfe von C#-Stringinterpolation in den <script>-Block einfügen, sodass jedes Diagramm die aktuellen Datenbankwerte zum Zeitpunkt der Generierung widerspiegelt. Weitere Details zur JavaScript Konfiguration finden Sie im JavaScript Rendering-Leitfaden von IronPDF .

Wie exportiert und liefert man die generierte PDF-Datei?

Sobald RenderHtmlAsPdf ein PdfDocument-Objekt zurückgibt, stehen Ihnen je nach Anwendungstyp verschiedene Zustellungsoptionen zur Verfügung. 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");
}

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 Function

pdf.BinaryData gibt die Rohbytes als byte[] zurück, was direkt dem Ergebnis File() von ASP.NET Core entspricht. Der Browser empfängt den korrekten MIME-Typ (application/pdf) und löst einen Download-Dialog mit einem aussagekräftigen 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 Zwischendateien zu erstellen.

Was sind Ihre nächsten Schritte?

Die dynamische PDF-Generierung in .NET lässt sich auf drei Bausteine ​​reduzieren: eine HTML-Zeichenkette, die sich mit Ihren Daten ändert, ChromePdfRenderer, um diese Zeichenkette in ein PDF umzuwandeln, und den Zustellungsmechanismus, 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:

dotnet add package IronPdf

dotnet add package IronPdf

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:

• In C# aus einer HTML-Vorlage ein PDF generieren
• URL in PDF konvertieren
• PDF-Dokumente zusammenführen und aufteilen
• Digitale Signaturen zu PDFs hinzufügen
• PDF/A-Konformität für Archivdokumente