ASP.NET Core: PDF unterwegs mit IronPDF erstellen

Was bedeutet "PDFs spontan erstellen"?

"On the fly" bedeutet, dass das Dokument zum Zeitpunkt der HTTP-Anfrage im Speicher erstellt und direkt an den Aufrufer gesendet wird. Es wird keine PDF-Datei im Dateisystem gespeichert, kein Hintergrundprozess reiht die Arbeit in die Warteschlange ein und kein Cache speichert das Ergebnis zwischen den Anfragen.

Dieser Ansatz ist aus mehreren Gründen wichtig. Erstens laufen Cloud-Bereitstellungsziele – Azure App Service, AWS Lambda, Docker-Container – oft in Umgebungen, in denen das lokale Dateisystem ephemer oder schreibgeschützt ist. Das Generieren einer PDF-Datei in einem temporären Ordner und das anschließende Wiedereinlesen ist in diesen Umgebungen fehleranfällig. Zweitens verringert das Vermeiden von Festplattenschreibvorgängen die Angriffsfläche: Es gibt keine Restdatei, die eine nachfolgende Anfrage versehentlich an den falschen Benutzer ausliefern könnte. Drittens ist die reine Speichergenerierung in der Regel schneller, da sie zwei E/A-Operationen (Schreiben und Lesen) im kritischen Pfad eliminiert.

Der ChromePdfRenderer von IronPDF stellt in jedem generierten Dokument eine .BinaryData-Eigenschaft und eine .Stream-Eigenschaft bereit. Beide können direkt an einen ASP.NET Core FileResult übergeben werden, wodurch das Streaming in der Praxis zu einer Einzeiler-Lösung wird.

Starten Sie jetzt mit IronPDF.

Jetzt kostenlos starten

Wie installiert man IronPDF in einem ASP.NET Core -Projekt?

Fügen Sie das NuGet Paket entweder über die Paket-Manager-Konsole oder die .NET Befehlszeilenschnittstelle hinzu:

Install-Package IronPdf
dotnet add package IronPdf

Install-Package IronPdf
dotnet add package IronPdf

Sobald das Paket installiert ist, legen Sie Ihren Lizenzschlüssel beim Start der Anwendung fest – typischerweise in Program.cs, bevor der erste Renderer erstellt wird:

using IronPdf;

// Place license activation before any IronPDF call
License.LicenseKey = "YOUR-LICENSE-KEY";

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllersWithViews();

// Register ChromePdfRenderer as a singleton so the Chromium engine
// is initialised once and reused across all requests.
builder.Services.AddSingleton<ChromePdfRenderer>();

var app = builder.Build();
app.MapDefaultControllerRoute();
app.Run();

using IronPdf;

// Place license activation before any IronPDF call
License.LicenseKey = "YOUR-LICENSE-KEY";

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllersWithViews();

// Register ChromePdfRenderer as a singleton so the Chromium engine
// is initialised once and reused across all requests.
builder.Services.AddSingleton<ChromePdfRenderer>();

var app = builder.Build();
app.MapDefaultControllerRoute();
app.Run();

Imports IronPdf

' Place license activation before any IronPDF call
License.LicenseKey = "YOUR-LICENSE-KEY"

Dim builder = WebApplication.CreateBuilder(args)
builder.Services.AddControllersWithViews()

' Register ChromePdfRenderer as a singleton so the Chromium engine
' is initialised once and reused across all requests.
builder.Services.AddSingleton(Of ChromePdfRenderer)()

Dim app = builder.Build()
app.MapDefaultControllerRoute()
app.Run()

Es ist wichtig, ChromePdfRenderer als Singleton zu registrieren. Der Renderer startet beim ersten Aufruf einen internen Chromium-Unterprozess. Wenn Sie für jede Anfrage eine neue Instanz erstellen, zahlen Sie diese Anlaufkosten bei jedem Aufruf, was unter Last zu einer zusätzlichen Latenz von Hunderten von Millisekunden führt. Eine Singleton-Instanz ist threadsicher und verarbeitet gleichzeitige Rendering-Anfragen ohne zusätzliche Konfiguration.

Einen umfassenderen Überblick über die Installationsoptionen, einschließlich NuGet.config-Setups für private Feeds, finden Sie in der Installationsübersicht .

Wie generiert man eine PDF-Rechnung aus einem HTML-String?

Der häufigste Anwendungsfall für die Ad-hoc-Erstellung ist die Generierung von Transaktionsdokumenten – Rechnungen, Quittungen, Auftragsbestätigungen –, bei denen sich der Inhalt pro Anfrage ändert, das Layout aber konstant bleibt.

Das Muster ist: einen HTML-String mit interpolierten Daten erstellen, diesen an RenderHtmlAsPdf übergeben und das Binärergebnis als Datei-Download zurückgeben.

using IronPdf;
using Microsoft.AspNetCore.Mvc;

public class DocumentController : Controller
{
    private readonly ChromePdfRenderer _renderer;

    public DocumentController(ChromePdfRenderer renderer)
    {
        _renderer = renderer;
    }

    [HttpGet("invoice/{orderId:int}")]
    public IActionResult GetInvoice(int orderId)
    {
        // In a real application, fetch this from your database or order service.
        var order = GetOrderData(orderId);

        string html = $"""
            <!DOCTYPE html>
            <html lang="en">
            <head>
                <meta charset="utf-8">
                <style>
                    body  {{ font-family: Arial, sans-serif; margin: 40px; color: #333; }}
                    h1   {{ color: #1a56db; }}
                    table {{ width: 100%; border-collapse: collapse; margin-top: 24px; }}
                    th, td {{ padding: 10px 14px; border: 1px solid #d1d5db; text-align: left; }}
                    th   {{ background: #f3f4f6; }}
                    tfoot td {{ font-weight: bold; }}
                </style>
            </head>
            <body>
                <h1>Invoice #{order.InvoiceNumber}</h1>
                <p>Date: {DateTime.UtcNow:yyyy-MM-dd} &nbsp;|&nbsp; Customer: {order.CustomerName}</p>
                <table>
                    <thead><tr><th>Item</th><th>Qty</th><th>Unit Price</th><th>Subtotal</th></tr></thead>
                    <tbody>
                        {string.Join("", order.Items.Select(i =>
                            $"<tr><td>{i.Name}</td><td>{i.Quantity}</td>" +
                            $"<td>${i.UnitPrice:F2}</td><td>${i.Quantity * i.UnitPrice:F2}</td></tr>"))}
                    </tbody>
                    <tfoot>
                        <tr><td colspan="3">Total</td><td>${order.Items.Sum(i => i.Quantity * i.UnitPrice):F2}</td></tr>
                    </tfoot>
                </table>
            </body>
            </html>
            """;

        var pdf = _renderer.RenderHtmlAsPdf(html);
        return File(pdf.BinaryData, "application/pdf", $"invoice-{orderId}.pdf");
    }
}

using IronPdf;
using Microsoft.AspNetCore.Mvc;

public class DocumentController : Controller
{
    private readonly ChromePdfRenderer _renderer;

    public DocumentController(ChromePdfRenderer renderer)
    {
        _renderer = renderer;
    }

    [HttpGet("invoice/{orderId:int}")]
    public IActionResult GetInvoice(int orderId)
    {
        // In a real application, fetch this from your database or order service.
        var order = GetOrderData(orderId);

        string html = $"""
            <!DOCTYPE html>
            <html lang="en">
            <head>
                <meta charset="utf-8">
                <style>
                    body  {{ font-family: Arial, sans-serif; margin: 40px; color: #333; }}
                    h1   {{ color: #1a56db; }}
                    table {{ width: 100%; border-collapse: collapse; margin-top: 24px; }}
                    th, td {{ padding: 10px 14px; border: 1px solid #d1d5db; text-align: left; }}
                    th   {{ background: #f3f4f6; }}
                    tfoot td {{ font-weight: bold; }}
                </style>
            </head>
            <body>
                <h1>Invoice #{order.InvoiceNumber}</h1>
                <p>Date: {DateTime.UtcNow:yyyy-MM-dd} &nbsp;|&nbsp; Customer: {order.CustomerName}</p>
                <table>
                    <thead><tr><th>Item</th><th>Qty</th><th>Unit Price</th><th>Subtotal</th></tr></thead>
                    <tbody>
                        {string.Join("", order.Items.Select(i =>
                            $"<tr><td>{i.Name}</td><td>{i.Quantity}</td>" +
                            $"<td>${i.UnitPrice:F2}</td><td>${i.Quantity * i.UnitPrice:F2}</td></tr>"))}
                    </tbody>
                    <tfoot>
                        <tr><td colspan="3">Total</td><td>${order.Items.Sum(i => i.Quantity * i.UnitPrice):F2}</td></tr>
                    </tfoot>
                </table>
            </body>
            </html>
            """;

        var pdf = _renderer.RenderHtmlAsPdf(html);
        return File(pdf.BinaryData, "application/pdf", $"invoice-{orderId}.pdf");
    }
}

Imports IronPdf
Imports Microsoft.AspNetCore.Mvc

Public Class DocumentController
    Inherits Controller

    Private ReadOnly _renderer As ChromePdfRenderer

    Public Sub New(renderer As ChromePdfRenderer)
        _renderer = renderer
    End Sub

    <HttpGet("invoice/{orderId:int}")>
    Public Function GetInvoice(orderId As Integer) As IActionResult
        ' In a real application, fetch this from your database or order service.
        Dim order = GetOrderData(orderId)

        Dim html As String = $"
            <!DOCTYPE html>
            <html lang=""en"">
            <head>
                <meta charset=""utf-8"">
                <style>
                    body  {{ font-family: Arial, sans-serif; margin: 40px; color: #333; }}
                    h1   {{ color: #1a56db; }}
                    table {{ width: 100%; border-collapse: collapse; margin-top: 24px; }}
                    th, td {{ padding: 10px 14px; border: 1px solid #d1d5db; text-align: left; }}
                    th   {{ background: #f3f4f6; }}
                    tfoot td {{ font-weight: bold; }}
                </style>
            </head>
            <body>
                <h1>Invoice #{order.InvoiceNumber}</h1>
                <p>Date: {DateTime.UtcNow:yyyy-MM-dd} &nbsp;|&nbsp; Customer: {order.CustomerName}</p>
                <table>
                    <thead><tr><th>Item</th><th>Qty</th><th>Unit Price</th><th>Subtotal</th></tr></thead>
                    <tbody>
                        {String.Join("", order.Items.Select(Function(i) $"<tr><td>{i.Name}</td><td>{i.Quantity}</td>" +
                            $"<td>${i.UnitPrice:F2}</td><td>${i.Quantity * i.UnitPrice:F2}</td></tr>"))}
                    </tbody>
                    <tfoot>
                        <tr><td colspan=""3"">Total</td><td>${order.Items.Sum(Function(i) i.Quantity * i.UnitPrice):F2}</td></tr>
                    </tfoot>
                </table>
            </body>
            </html>
            "

        Dim pdf = _renderer.RenderHtmlAsPdf(html)
        Return File(pdf.BinaryData, "application/pdf", $"invoice-{orderId}.pdf")
    End Function
End Class

RenderHtmlAsPdf verarbeitet das gesamte HTML-Dokument – ​​CSS-Grid, Flexbox, Webfonts, sogar Inline-SVG – mit derselben Chromium-Engine, die auch Google Chrome antreibt. Der zurückgegebene Code PdfDocument legt BinaryData (ein byte[]) und Stream (ein MemoryStream) offen. Durch die Übergabe von BinaryData an File() mit "application/pdf" und einem Dateinamen wird ein Browser-Download ausgelöst.

Für Layouts, die pixelgenaue Wiedergabe erfordern, konsultieren Sie den Leitfaden zur HTML-zu-PDF-Konvertierung, der responsives CSS, benutzerdefinierte Schriftarten und JavaScript Rendering behandelt.

Wie kann man eine PDF-Datei direkt in den Browser streamen, ohne dass ein Download-Dialog angezeigt wird?

Das Inline-Bereitstellen einer PDF-Datei – also das Öffnen im integrierten Viewer des Browsers anstatt das Herunterladen – erfordert zwei kleine Änderungen: Content-Disposition muss auf inline gesetzt werden, und der Dateiname muss beim Aufruf von File() weggelassen werden.

[HttpPost("report/preview")]
public async Task<IActionResult> PreviewReport([FromBody] ReportRequest request)
{
    string html = BuildReportHtml(request);

    var pdfDocument = await _renderer.RenderHtmlAsPdfAsync(html);

    // "inline" tells the browser to display rather than download.
    Response.Headers["Content-Disposition"] = "inline; filename=report.pdf";

    return new FileContentResult(pdfDocument.BinaryData, "application/pdf");
}

[HttpPost("report/preview")]
public async Task<IActionResult> PreviewReport([FromBody] ReportRequest request)
{
    string html = BuildReportHtml(request);

    var pdfDocument = await _renderer.RenderHtmlAsPdfAsync(html);

    // "inline" tells the browser to display rather than download.
    Response.Headers["Content-Disposition"] = "inline; filename=report.pdf";

    return new FileContentResult(pdfDocument.BinaryData, "application/pdf");
}

Imports Microsoft.AspNetCore.Mvc

<HttpPost("report/preview")>
Public Async Function PreviewReport(<FromBody> request As ReportRequest) As Task(Of IActionResult)
    Dim html As String = BuildReportHtml(request)

    Dim pdfDocument = Await _renderer.RenderHtmlAsPdfAsync(html)

    ' "inline" tells the browser to display rather than download.
    Response.Headers("Content-Disposition") = "inline; filename=report.pdf"

    Return New FileContentResult(pdfDocument.BinaryData, "application/pdf")
End Function

Die Verwendung der asynchronen Überladung RenderHtmlAsPdfAsync wird für ASP.NET Core Controller empfohlen, da sie den Threadpool-Thread freigibt, während Chromium rendert, wodurch der Server auch bei gleichzeitiger Last reaktionsfähig bleibt.

Wie generiert man PDFs aus den Abfrageergebnissen von Entity Framework Core?

Die meisten Geschäftsanwendungen rufen Berichtsdaten aus einer Datenbank ab, anstatt sie beim Aufruf zu erstellen. Das folgende Beispiel fragt Entity Framework Core ab, erstellt eine HTML-Tabelle und gibt ein PDF zurück – alles innerhalb einer einzigen Controller-Aktion.

[HttpGet("report/monthly")]
public async Task<IActionResult> MonthlyReport(int year, int month)
{
    // Pull aggregated transaction data from EF Core.
    var rows = await _dbContext.Transactions
        .Where(t => t.Date.Year == year && t.Date.Month == month)
        .GroupBy(t => t.Category)
        .Select(g => new { Category = g.Key, Count = g.Count(), Total = g.Sum(t => t.Amount) })
        .OrderByDescending(g => g.Total)
        .ToListAsync();

    string tableRows = string.Join("", rows.Select(r =>
        $"<tr><td>{r.Category}</td><td>{r.Count}</td><td>${r.Total:F2}</td></tr>"));

    string html = $"""
        <html><body style="font-family:Arial,sans-serif;padding:32px">
        <h1>Monthly Report -- {month:D2}/{year}</h1>
        <table style="width:100%;border-collapse:collapse">
          <thead>
            <tr style="background:#e5e7eb">
              <th style="padding:8px;border:1px solid #d1d5db">Category</th>
              <th style="padding:8px;border:1px solid #d1d5db">Transactions</th>
              <th style="padding:8px;border:1px solid #d1d5db">Total</th>
            </tr>
          </thead>
          <tbody>{tableRows}</tbody>
        </table>
        </body></html>
        """;

    var pdf = _renderer.RenderHtmlAsPdf(html);
    pdf.MetaData.Title  = $"Monthly Report {month:D2}/{year}";
    pdf.MetaData.Author = "Reporting System";

    return File(pdf.BinaryData, "application/pdf", $"report-{year}-{month:D2}.pdf");
}

[HttpGet("report/monthly")]
public async Task<IActionResult> MonthlyReport(int year, int month)
{
    // Pull aggregated transaction data from EF Core.
    var rows = await _dbContext.Transactions
        .Where(t => t.Date.Year == year && t.Date.Month == month)
        .GroupBy(t => t.Category)
        .Select(g => new { Category = g.Key, Count = g.Count(), Total = g.Sum(t => t.Amount) })
        .OrderByDescending(g => g.Total)
        .ToListAsync();

    string tableRows = string.Join("", rows.Select(r =>
        $"<tr><td>{r.Category}</td><td>{r.Count}</td><td>${r.Total:F2}</td></tr>"));

    string html = $"""
        <html><body style="font-family:Arial,sans-serif;padding:32px">
        <h1>Monthly Report -- {month:D2}/{year}</h1>
        <table style="width:100%;border-collapse:collapse">
          <thead>
            <tr style="background:#e5e7eb">
              <th style="padding:8px;border:1px solid #d1d5db">Category</th>
              <th style="padding:8px;border:1px solid #d1d5db">Transactions</th>
              <th style="padding:8px;border:1px solid #d1d5db">Total</th>
            </tr>
          </thead>
          <tbody>{tableRows}</tbody>
        </table>
        </body></html>
        """;

    var pdf = _renderer.RenderHtmlAsPdf(html);
    pdf.MetaData.Title  = $"Monthly Report {month:D2}/{year}";
    pdf.MetaData.Author = "Reporting System";

    return File(pdf.BinaryData, "application/pdf", $"report-{year}-{month:D2}.pdf");
}

Imports Microsoft.AspNetCore.Mvc
Imports System.Threading.Tasks
Imports System.Linq

<HttpGet("report/monthly")>
Public Async Function MonthlyReport(year As Integer, month As Integer) As Task(Of IActionResult)
    ' Pull aggregated transaction data from EF Core.
    Dim rows = Await _dbContext.Transactions _
        .Where(Function(t) t.Date.Year = year AndAlso t.Date.Month = month) _
        .GroupBy(Function(t) t.Category) _
        .Select(Function(g) New With {Key .Category = g.Key, Key .Count = g.Count(), Key .Total = g.Sum(Function(t) t.Amount)}) _
        .OrderByDescending(Function(g) g.Total) _
        .ToListAsync()

    Dim tableRows As String = String.Join("", rows.Select(Function(r) $"<tr><td>{r.Category}</td><td>{r.Count}</td><td>${r.Total:F2}</td></tr>"))

    Dim html As String = $"
        <html><body style='font-family:Arial,sans-serif;padding:32px'>
        <h1>Monthly Report -- {month:D2}/{year}</h1>
        <table style='width:100%;border-collapse:collapse'>
          <thead>
            <tr style='background:#e5e7eb'>
              <th style='padding:8px;border:1px solid #d1d5db'>Category</th>
              <th style='padding:8px;border:1px solid #d1d5db'>Transactions</th>
              <th style='padding:8px;border:1px solid #d1d5db'>Total</th>
            </tr>
          </thead>
          <tbody>{tableRows}</tbody>
        </table>
        </body></html>
        "

    Dim pdf = _renderer.RenderHtmlAsPdf(html)
    pdf.MetaData.Title = $"Monthly Report {month:D2}/{year}"
    pdf.MetaData.Author = "Reporting System"

    Return File(pdf.BinaryData, "application/pdf", $"report-{year}-{month:D2}.pdf")
End Function

Durch die Einstellung pdf.MetaData.Title und pdf.MetaData.Author werden diese Informationen in die Dokumenteigenschaften der PDF-Datei eingebettet, was für Compliance-Tracking- und Dokumentenmanagementsysteme nützlich ist. Für anspruchsvollere Berichtslayouts sollten Sie CSS-Druckstile , explizite Seitenumbrüche und eingebettete Diagrammbilder in Betracht ziehen.

Wie wendet man Kopf- und Fußzeilen sowie Sicherheitseinstellungen auf generierte PDFs an?

Produktionsdokumente benötigen häufig Kopfzeilen mit dem Dokumenttitel, Fußzeilen mit Seitenzahlen und Zugriffskontrollen, die unbefugtes Drucken oder Kopieren verhindern. IronPDFs ChromePdfRenderOptions erfüllt alle diese Anforderungen.

[HttpPost("document/secured")]
public async Task<IActionResult> GenerateSecuredDocument([FromBody] SecuredDocRequest request)
{
    var renderOptions = new ChromePdfRenderOptions
    {
        PaperSize       = PdfPaperSize.A4,
        MarginTop       = 45,
        MarginBottom    = 45,
        MarginLeft      = 25,
        MarginRight     = 25,
        EnableJavaScript = true,
        WaitFor         = new WaitFor { RenderDelay = 500 }
    };

    renderOptions.TextHeader = new TextHeaderFooter
    {
        CenterText       = request.DocumentTitle,
        DrawDividerLine  = true,
        FontSize         = 11
    };

    renderOptions.TextFooter = new TextHeaderFooter
    {
        LeftText  = "{date} {time}",
        RightText = "Page {page} of {total-pages}",
        FontSize  = 9
    };

    _renderer.RenderingOptions = renderOptions;

    var pdf = await _renderer.RenderHtmlAsPdfAsync(request.HtmlContent);

    if (request.RequirePassword)
    {
        pdf.SecuritySettings.OwnerPassword         = request.OwnerPassword;
        pdf.SecuritySettings.UserPassword          = request.UserPassword;
        pdf.SecuritySettings.AllowUserPrinting     = PdfPrintSecurity.NoPrint;
        pdf.SecuritySettings.AllowUserCopyPasteContent = false;
    }

    return File(pdf.BinaryData, "application/pdf", $"{request.FileName}.pdf");
}

[HttpPost("document/secured")]
public async Task<IActionResult> GenerateSecuredDocument([FromBody] SecuredDocRequest request)
{
    var renderOptions = new ChromePdfRenderOptions
    {
        PaperSize       = PdfPaperSize.A4,
        MarginTop       = 45,
        MarginBottom    = 45,
        MarginLeft      = 25,
        MarginRight     = 25,
        EnableJavaScript = true,
        WaitFor         = new WaitFor { RenderDelay = 500 }
    };

    renderOptions.TextHeader = new TextHeaderFooter
    {
        CenterText       = request.DocumentTitle,
        DrawDividerLine  = true,
        FontSize         = 11
    };

    renderOptions.TextFooter = new TextHeaderFooter
    {
        LeftText  = "{date} {time}",
        RightText = "Page {page} of {total-pages}",
        FontSize  = 9
    };

    _renderer.RenderingOptions = renderOptions;

    var pdf = await _renderer.RenderHtmlAsPdfAsync(request.HtmlContent);

    if (request.RequirePassword)
    {
        pdf.SecuritySettings.OwnerPassword         = request.OwnerPassword;
        pdf.SecuritySettings.UserPassword          = request.UserPassword;
        pdf.SecuritySettings.AllowUserPrinting     = PdfPrintSecurity.NoPrint;
        pdf.SecuritySettings.AllowUserCopyPasteContent = false;
    }

    return File(pdf.BinaryData, "application/pdf", $"{request.FileName}.pdf");
}

Imports System.Threading.Tasks
Imports Microsoft.AspNetCore.Mvc

<HttpPost("document/secured")>
Public Async Function GenerateSecuredDocument(<FromBody> request As SecuredDocRequest) As Task(Of IActionResult)
    Dim renderOptions As New ChromePdfRenderOptions With {
        .PaperSize = PdfPaperSize.A4,
        .MarginTop = 45,
        .MarginBottom = 45,
        .MarginLeft = 25,
        .MarginRight = 25,
        .EnableJavaScript = True,
        .WaitFor = New WaitFor With {.RenderDelay = 500}
    }

    renderOptions.TextHeader = New TextHeaderFooter With {
        .CenterText = request.DocumentTitle,
        .DrawDividerLine = True,
        .FontSize = 11
    }

    renderOptions.TextFooter = New TextHeaderFooter With {
        .LeftText = "{date} {time}",
        .RightText = "Page {page} of {total-pages}",
        .FontSize = 9
    }

    _renderer.RenderingOptions = renderOptions

    Dim pdf = Await _renderer.RenderHtmlAsPdfAsync(request.HtmlContent)

    If request.RequirePassword Then
        pdf.SecuritySettings.OwnerPassword = request.OwnerPassword
        pdf.SecuritySettings.UserPassword = request.UserPassword
        pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.NoPrint
        pdf.SecuritySettings.AllowUserCopyPasteContent = False
    End If

    Return File(pdf.BinaryData, "application/pdf", $"{request.FileName}.pdf")
End Function

Die Einstellung WaitFor.RenderDelay ist besonders nützlich, wenn Ihr HTML Diagrammbibliotheken wie Chart.js oder ApexCharts enthält, die das Zeichnen asynchron abschließen. Durch die Einstellung einer Verzögerung von 300-500 ms wird sichergestellt, dass Chromium den endgültigen gerenderten Zustand erfasst. Für Dokumente, die Archivierungsstandards genügen müssen, kombinieren Sie den oben genannten Ansatz mit PDF/A-Konformität und digitalen Signaturen .

Die Platzhalter {page} und {total-pages} im Fußzeilentext werden von IronPDF automatisch zur Renderzeit aufgelöst. Zu den zusätzlichen Kopf- und Fußzeilenoptionen gehören HTML-basierte Header für die Logoplatzierung und die Möglichkeit, diese abschnittsweise anzupassen.

Welche Best Practices gibt es für die Leistungsoptimierung bei der Erstellung großer Mengen von PDFs?

Wenn ein einzelner Server Hunderte von gleichzeitigen PDF-Anfragen bearbeiten muss, haben einige wenige architektonische Entscheidungen einen überproportionalen Einfluss auf Durchsatz und Latenz.

Registrierung des Singleton-Renderers. Wie im Installationsabschnitt beschrieben, vermeidet die Registrierung von ChromePdfRenderer als Singleton im DI-Container die Kosten für das Starten eines neuen Chromium-Subprozesses pro Anfrage. Laut Microsofts ASP.NET Core -Leistungsrichtlinien sind die Minimierung von Objektzuweisungen und die Wiederverwendung teurer Ressourcen die beiden wirkungsvollsten Optimierungen.

Verwenden Sie immer async. RenderHtmlAsPdfAsync gibt einen Task<PdfDocument> zurück und hält den Controller-Thread an, während Chromium arbeitet. Dadurch wird der Thread-Pool freigegeben, um andere eingehende Anfragen parallel zu bearbeiten. Aus diesem Grund empfiehlt die asynchrone Dokumentation diese Überladung für Webhoster. Die synchrone Überladung ist nur für Konsolentools oder Hintergrunddienste geeignet, bei denen die Blockierung von Threads akzeptabel ist.

Direkt streamen, das Zwischenarray nach Möglichkeit überspringen. Bei großen PDFs kann .Stream direkt in den Antworttext geschrieben werden, ohne das vollständige Byte-Array zu materialisieren:

[HttpGet("document/large")]
public IActionResult StreamLargeDocument(int documentId)
{
    string html = BuildLargeDocumentHtml(documentId);
    var pdf = _renderer.RenderHtmlAsPdf(html);

    // Stream.Position is already at 0; no seek needed.
    return File(pdf.Stream, "application/pdf", $"document-{documentId}.pdf");
}

[HttpGet("document/large")]
public IActionResult StreamLargeDocument(int documentId)
{
    string html = BuildLargeDocumentHtml(documentId);
    var pdf = _renderer.RenderHtmlAsPdf(html);

    // Stream.Position is already at 0; no seek needed.
    return File(pdf.Stream, "application/pdf", $"document-{documentId}.pdf");
}

Imports Microsoft.AspNetCore.Mvc

<HttpGet("document/large")>
Public Function StreamLargeDocument(documentId As Integer) As IActionResult
    Dim html As String = BuildLargeDocumentHtml(documentId)
    Dim pdf = _renderer.RenderHtmlAsPdf(html)

    ' Stream.Position is already at 0; no seek needed.
    Return File(pdf.Stream, "application/pdf", $"document-{documentId}.pdf")
End Function

Nach Gebrauch entsorgen. PdfDocument implementiert IDisposable. Durch das Einbetten in eine using Anweisung wird der zugrunde liegende Speicherpuffer umgehend freigegeben, was wichtig ist, wenn viele große PDFs nacheinander generiert werden:

using var pdf = _renderer.RenderHtmlAsPdf(html);
byte[] data = pdf.BinaryData;
// pdf is disposed here; data is safely copied to the local array.
return File(data, "application/pdf", "output.pdf");

using var pdf = _renderer.RenderHtmlAsPdf(html);
byte[] data = pdf.BinaryData;
// pdf is disposed here; data is safely copied to the local array.
return File(data, "application/pdf", "output.pdf");

Imports System.IO

Using pdf = _renderer.RenderHtmlAsPdf(html)
    Dim data As Byte() = pdf.BinaryData
    ' pdf is disposed here; data is safely copied to the local array.
    Return File(data, "application/pdf", "output.pdf")
End Using

Für Anleitungen zur Cloud-Bereitstellung in Azure- , AWS-, Docker- und Linux-Umgebungen bietet die IronPDF Dokumentation umgebungsspezifische Konfigurationshinweise. Falls das erste Rendern nach dem Start langsam ist, konsultieren Sie den Leitfaden zum Aufwärmen und Caching, um Strategien zur Vorinitialisierung des Renderers vor dem Eintreffen der ersten Benutzeranfrage zu erhalten.

Wie fügt man einem generierten PDF ein Wasserzeichen hinzu?

Vor dem Streaming kann jeder Seite des generierten Dokuments ein Text- oder Bildwasserzeichen hinzugefügt werden:

[HttpGet("document/draft/{id:int}")]
public IActionResult GetDraftDocument(int id)
{
    string html = BuildDocumentHtml(id);
    var pdf = _renderer.RenderHtmlAsPdf(html);

    // Stamp "DRAFT" diagonally across every page.
    pdf.ApplyWatermark(
        "<h1 style='color:rgba(200,0,0,0.25);transform:rotate(-45deg)'>DRAFT</h1>",
        rotation: 45,
        opacity: 30
    );

    return File(pdf.BinaryData, "application/pdf", $"draft-{id}.pdf");
}

[HttpGet("document/draft/{id:int}")]
public IActionResult GetDraftDocument(int id)
{
    string html = BuildDocumentHtml(id);
    var pdf = _renderer.RenderHtmlAsPdf(html);

    // Stamp "DRAFT" diagonally across every page.
    pdf.ApplyWatermark(
        "<h1 style='color:rgba(200,0,0,0.25);transform:rotate(-45deg)'>DRAFT</h1>",
        rotation: 45,
        opacity: 30
    );

    return File(pdf.BinaryData, "application/pdf", $"draft-{id}.pdf");
}

<AttributeUsage(AttributeTargets.Method, Inherited:=True, AllowMultiple:=False)>
Public Class HttpGetAttribute
    Inherits Attribute

    Public Sub New(route As String)
    End Sub
End Class

<HttpGet("document/draft/{id:int}")>
Public Function GetDraftDocument(id As Integer) As IActionResult
    Dim html As String = BuildDocumentHtml(id)
    Dim pdf = _renderer.RenderHtmlAsPdf(html)

    ' Stamp "DRAFT" diagonally across every page.
    pdf.ApplyWatermark(
        "<h1 style='color:rgba(200,0,0,0.25);transform:rotate(-45deg)'>DRAFT</h1>",
        rotation:=45,
        opacity:=30
    )

    Return File(pdf.BinaryData, "application/pdf", $"draft-{id}.pdf")
End Function

$vbLabelText   $csharpLabel

Die vollständigen Konfigurationsoptionen für Wasserzeichen, einschließlich Bildwasserzeichen und seitenweiser Steuerung, finden Sie in der Wasserzeichendokumentation .

Mit NuGet installieren

PM >  Install-Package IronPdf

Schauen Sie sich IronPDF auf NuGet für eine schnelle Installation an. Mit über 10 Millionen Downloads transformiert es die PDF-Entwicklung mit C#. Sie können auch das DLL oder den Windows Installer herunterladen.

Was sind Ihre nächsten Schritte?

Die dynamische PDF-Generierung in ASP.NET Core folgt einem einheitlichen Muster: Erstellen Sie Ihr HTML, rufen Sie RenderHtmlAsPdf oder dessen asynchrone Überladung auf und geben Sie das Ergebnis über FileResult zurück. IronPDF übernimmt alles dazwischen – Chromium-Rendering, CSS-Anwendung, JavaScript -Ausführung – ohne dass zu irgendeinem Zeitpunkt Festplattenzugriffe erforderlich sind.

Von hier aus können Sie je nach Ihren Anwendungsanforderungen verschiedene Wege erkunden. Falls Ihre PDFs mehrere Quelldokumente kombinieren müssen, beschreibt der Leitfaden zum Zusammenführen und Aufteilen das Zusammenfügen bestehender PDFs mit neu gerenderten Seiten. Falls Sie von Ihren Benutzern das Ausfüllen und Absenden von in ein PDF eingebetteten Formularen verlangen, zeigt Ihnen die Dokumentation zu interaktiven Formularen , wie Sie Feldwerte erstellen und auslesen. Für regulierte Branchen gewährleisten die Einhaltung der PDF/A- und PDF/UA-Richtlinien , dass Dokumente den Archivierungs- und Zugänglichkeitsstandards entsprechen.

Wenn Sie IronPDF mit Alternativen vergleichen, bietet Ihnen der Vergleich zwischen iText und IronPDF eine detaillierte technische Aufschlüsselung auf beiden Seiten. Wenn Sie bereit sind, in die Produktion zu gehen, erwerben Sie eine Lizenz , um alle Funktionen freizuschalten und Zugang zu prioritärem technischen Support zu erhalten. Die vollständige API-Referenz dokumentiert jede in diesem Leitfaden besprochene Klasse und Methode.

Bei Fragen oder Problemen während der Implementierung steht Ihnen das technische Supportteam gerne zur Verfügung. Plattformspezifische Hinweise zu Blazor Server oder MAUI sowie die Konfigurationsunterschiede für jedes Hostmodell finden Sie in den entsprechenden Anleitungen.