1. IronPDF
  2. Tutorials
  3. .NET Core PDF-Erzeugung
Wie man PDF-Dateien in .NET Core erzeugt

HTML in .NET Core mit C# und IronPDF in PDF konvertieren

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
Aktualisiert:
This article was translated from English: Does it need improvement?
Translated
View the article in English

Das Erstellen hochauflösender PDF-Dateien direkt aus HTML ist eine gängige Anforderung in modernen .NET-Anwendungen – Berichte, Rechnungen und Tickets benötigen alle eine pixelgenaue Ausgabe, die der Web-Benutzeroberfläche entspricht. IronPDF optimiert diesen Arbeitsablauf durch die Bereitstellung einer einzigen C#-API zum Rendern von HTML, Razor-Ansichten und ganzen Websites in standardkonforme PDF-Dokumente. Am Ende dieses Leitfadens wird ein Entwickler in der Lage sein, URLs, Roh-HTML oder MVC-Ansichten in einem .NET Core-Projekt zu konvertieren und denselben Code in Windows-, Linux-, Docker- oder serverlosen Umgebungen bereitzustellen.

TippsFür Layoutprobleme liefert IronPDF einen Headless-Chrome-Debugger mit, der dabei hilft, CSS-, JavaScript- und Media-Query-Probleme zu diagnostizieren, bevor das PDF gerendert wird. Lesen Sie den speziellen Leitfaden für pixelgenaue HTML-zu-PDF-Konvertierung, um sich mit den Techniken im Detail vertraut zu machen.

Schnellstart: Erstellen einer PDF-Datei aus HTML in .NET Core

Konvertieren Sie HTML mühelos in .NET Core mithilfe der IronPDF-Bibliothek in PDF. Dieser Leitfaden enthält ein einfaches Beispiel, mit dem Sie schnell loslegen können, indem Sie HTML-Inhalte mit minimalem Codeaufwand in ein hochwertiges PDF umwandeln. Ideal für Entwickler, die die Erstellung von PDF-Dateien mühelos in ihre Anwendungen integrieren möchten.

  1. Installieren Sie IronPDF mit NuGet Package Manager

    PM > Install-Package IronPdf

  2. Kopieren Sie diesen Codeausschnitt und führen Sie ihn aus.

    var pdf = new IronPdf.ChromePdfRenderer().RenderHtmlAsPdf("<h1>Hello World</h1>");

  3. Bereitstellen zum Testen in Ihrer Live-Umgebung

    Beginnen Sie noch heute, IronPDF in Ihrem Projekt zu verwenden, mit einer kostenlosen Testversion

    arrow pointer

Minimaler Arbeitsablauf (5 Schritte)

  1. Installieren Sie das IronPdf NuGet-Paket
  2. Konvertieren Sie eine Website-URL mit RenderUrlAsPdf
  3. Roh-HTML rendern über RenderHtmlAsPdf
  4. Eine MVC-Ansicht als PDF exportieren
  5. Papierschnitt, Ränder, Kopf- und Fußzeilen anpassen

Checkliste für den schnellen Einstieg

  1. Installieren – Install-Package IronPdf
  2. Eine URL rendern – ChromePdfRenderer.RenderUrlAsPdf()
  3. Roh-HTML rendern – ChromePdfRenderer.RenderHtmlAsPdf()
  4. Eine Razor-Ansicht exportieren – ChromePdfRenderer.RenderHtmlAsPdfAsync()
  5. Ausgabe optimieren – ChromePdfRenderer.RenderingOptions nutzen

Inhalt dieses Tutorials

  • Konvertierung von URLs, HTML-Zeichenfolgen und Razor-Ansichten
  • Konfiguration von Papier, Rand und Medientyp
  • Plattformübergreifende Bereitstellung (Windows, Linux, Docker)
  • Nachbearbeitung: Zusammenführen, Wasserzeichen einfügen, mit Passwort schützen und PDF-Dateien digital signieren
  • End-to-End-Beispiel: MVC-App zur Ticketbuchung

Wie installiere ich die PDF-Bibliothek in .NET Core?

Die Installation der Bibliothek erfolgt in jedem .NET 8-Projekt mit einem einzigen Befehl und ist weiterhin vorwärtskompatibel mit der .NET 9-Vorschau und der kommenden .NET 10-Version. Verwenden Sie die NuGet-Paketmanager-Konsole, und der Paketmanager löst automatisch alle Abhängigkeiten für Windows, Linux, Docker und serverlose Ziele auf.

PM> Install-Package IronPdf             # .NET 8 LTS and higher
PM> Install-Package IronPdf             # .NET 8 LTS and higher
SHELL

Hinweis:Benötigen Sie die CLI? Der gleiche Befehl funktioniert mit dotnet add package IronPdf in Ihrem Projektordner.

Überprüfen Sie nach der Installation, ob alles richtig funktioniert, indem Sie eine beliebige öffentliche URL konvertieren:

// Program.cs — .NET 8 LTS
using IronPdf;

var renderer = new ChromePdfRenderer();

// Render a live website to PDF
using PdfDocument pdf = renderer.RenderUrlAsPdf("https://example.com");

// Persist to disk
pdf.SaveAs("website-snapshot.pdf");
// Program.cs — .NET 8 LTS
using IronPdf;

var renderer = new ChromePdfRenderer();

// Render a live website to PDF
using PdfDocument pdf = renderer.RenderUrlAsPdf("https://example.com");

// Persist to disk
pdf.SaveAs("website-snapshot.pdf");
' Program.cs — .NET 8 LTS
Imports IronPdf

Private renderer = New ChromePdfRenderer()

' Render a live website to PDF
Private PdfDocument As using

' Persist to disk
pdf.SaveAs("website-snapshot.pdf")
$vbLabelText   $csharpLabel

So funktioniert es

  • ChromePdfRenderer startet im Hintergrund eine Sandbox-Instanz von Chromium – eine separate Chrome-Installation ist nicht erforderlich.
  • RenderUrlAsPdf erfasst das vollständig gerenderte DOM, einschließlich JavaScript-gesteuerter Inhalte, CSS-Medienabfragen und Schriftarten.
  • Das resultierende PdfDocument stellt Hilfsmethoden zum Zusammenführen, Passwortschützen oder digitalen Signieren der Ausgabe bereit – Funktionen, die später in diesem Tutorial behandelt werden.

Weitere Informationen zu den Feinheiten der Bereitstellung (Azure App Service, AWS Lambda, On-Prem-Linux) finden Sie im speziellen Installationsleitfaden und auf den Seiten zur erweiterten NuGet-Einrichtung. Interne CI/CD-Tipps für Docker- und K8s-Cluster werden in den Best Practices für die Docker-Bereitstellung behandelt.

Wie kann ein .NET Core-Dienst die URL einer Live-Website in ein PDF-Dokument konvertieren?

Ein einziger Aufruf von RenderUrlAsPdf genügt: Übergeben Sie eine beliebige öffentlich zugängliche URL, und IronPDF gibt ein vollständig gerendertes, standardkonformes PDF zurück. Der folgende Code ist for .NET 8 LTS ausgelegt und lässt sich unverändert sowohl auf der .NET 9 Preview als auch auf der für 2025 geplanten .NET 10-Version kompilieren.

Schritt-für-Schritt-Beispiel

// Program.cs — .NET 8 LTS-compatible
using IronPdf;

// 1. Activate a license (or trial key)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

// 2. Create a reusable renderer instance
var renderer = new ChromePdfRenderer
{
    RenderingOptions =
    {
        // Force A4 portrait output and apply @media print styles
        PaperSize    = PdfPaperSize.A4,
        CssMediaType = PdfCssMediaType.Print
    }
};

// 3. Convert Microsoft Docs home page to PDF
using PdfDocument pdf = renderer.RenderUrlAsPdf("https://learn.microsoft.com/");

// 4. Save the PDF or stream it from a Web API
pdf.SaveAs("docs-offline-copy.pdf");
// Program.cs — .NET 8 LTS-compatible
using IronPdf;

// 1. Activate a license (or trial key)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

// 2. Create a reusable renderer instance
var renderer = new ChromePdfRenderer
{
    RenderingOptions =
    {
        // Force A4 portrait output and apply @media print styles
        PaperSize    = PdfPaperSize.A4,
        CssMediaType = PdfCssMediaType.Print
    }
};

// 3. Convert Microsoft Docs home page to PDF
using PdfDocument pdf = renderer.RenderUrlAsPdf("https://learn.microsoft.com/");

// 4. Save the PDF or stream it from a Web API
pdf.SaveAs("docs-offline-copy.pdf");
' Program.cs — .NET 8 LTS-compatible
Imports IronPdf

' 1. Activate a license (or trial key)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

' 2. Create a reusable renderer instance
Dim renderer = New ChromePdfRenderer With {
	.RenderingOptions = {
		PaperSize = PdfPaperSize.A4,
		CssMediaType = PdfCssMediaType.Print
	}
}

' 3. Convert Microsoft Docs home page to PDF
Using pdf As PdfDocument = renderer.RenderUrlAsPdf("https://learn.microsoft.com/")
	
	' 4. Save the PDF or stream it from a Web API
	pdf.SaveAs("docs-offline-copy.pdf")
End Using
$vbLabelText   $csharpLabel

Warum es funktioniert

  • ChromePdfRenderer startet eine Sandbox-Instanz von Chromium – ohne Abhängigkeit vom systemeigenen Chrome, wodurch die Docker-Images schlank bleiben.
  • RenderUrlAsPdf wartet, bis das DOM und JavaScript fertig sind, bevor ein Snapshot erstellt wird, damit Single-Page-Apps korrekt gerendert werden.
  • Wenn CssMediaType auf "PRINT" gesetzt wird, weist dies die Engine an, druckspezifische Regeln zu verwenden, die der Ausgabe des Browsers unter "PRINT → Als PDF speichern" entsprechen.
  • Das resultierende PdfDocument kann verschlüsselt, digital signiert, zusammengeführt oder gerastert werden – diese Funktionen werden in späteren Abschnitten behandelt.

TippsPixelgenaues Debugging: Aktivieren Sie renderer.LoggingOptions.DebugMode = true und befolgen Sie die Anleitung zum Debuggen mit Headless Chrome, um DevTools während des Renderings live zu überprüfen.

Verwandte Ressourcen

Wie konvertiere ich rohen HTML-Code in .NET Core in eine PDF-Datei?

Die Übergabe einer HTML-Zeichenkette – oder des gerenderten Markups einer Razor-Ansicht – an ChromePdfRenderer.RenderHtmlAsPdf erzeugt sofort eine standardkonforme PDF-Datei. Die Methode startet die in IronPDF integrierte Chromium-Engine, sodass keine Installation eines externen Browsers oder eine Abhängigkeit von WebView erforderlich ist. Der unten gezeigte Code lässt sich heute unter .NET 8 LTS kompilieren und ist weiterhin vorwärtskompatibel mit .NET 9 und der für November 2025 geplanten Version .NET 10.

Beispiel – Erstellen einer PDF-Datei aus einem HTML-Fragment

// Program.cs — compatible with .NET 8 and newer
using IronPdf;

// Sample HTML fragment (could also be read from a file, Razor view, or CMS)
const string html = """
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Quarterly Report</title>
  <style>
     body { font-family:'Segoe UI', sans-serif; margin:1.2rem; }
     header { margin-bottom:2rem; }
     h1 { color:#3056d3; }
     table { width:100%; border-collapse:collapse; margin-top:1rem; }
     th,td { border:1px solid #ddd; padding:0.5rem; text-align:right; }
     tr:nth-child(even){ background-color:#f8f9fa; }
  </style>
</head>
<body>
  <header><h1>Q2 Revenue Summary</h1></header>
  <table>
    <thead><tr><th>Product</th><th>Revenue ($)</th></tr></thead>
    <tbody>
      <tr><td>IronPDF for .NET</td><td>1,200,000</td></tr>
      <tr><td>IronOCR for .NET</td><td>890,000</td></tr>
      <tr><td>IronXL for .NET</td><td>610,000</td></tr>
    </tbody>
  </table>
</body>
</html>
""";

// 1. Create a renderer once and reuse it across conversions
var renderer = new ChromePdfRenderer
{
    RenderingOptions =
    {
        PaperSize    = PdfPaperSize.A4,                  // ISO-standard paper size
        PaperOrientation = PdfPaperOrientation.Portrait,
        CssMediaType = PdfCssMediaType.Screen,           // Respect on-screen CSS
        RenderDelay  = 100,                              // Wait 100 ms for JS/animations
        FallbackEncoding = "utf-8"                       // Handle non-ASCII correctly
    }
};

// 2. Render the HTML fragment
using PdfDocument pdf = renderer.RenderHtmlAsPdf(html);

// 3. Persist to disk or return via ASP.NET Core FileStreamResult
pdf.SaveAs("q2-report.pdf");
// Program.cs — compatible with .NET 8 and newer
using IronPdf;

// Sample HTML fragment (could also be read from a file, Razor view, or CMS)
const string html = """
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Quarterly Report</title>
  <style>
     body { font-family:'Segoe UI', sans-serif; margin:1.2rem; }
     header { margin-bottom:2rem; }
     h1 { color:#3056d3; }
     table { width:100%; border-collapse:collapse; margin-top:1rem; }
     th,td { border:1px solid #ddd; padding:0.5rem; text-align:right; }
     tr:nth-child(even){ background-color:#f8f9fa; }
  </style>
</head>
<body>
  <header><h1>Q2 Revenue Summary</h1></header>
  <table>
    <thead><tr><th>Product</th><th>Revenue ($)</th></tr></thead>
    <tbody>
      <tr><td>IronPDF for .NET</td><td>1,200,000</td></tr>
      <tr><td>IronOCR for .NET</td><td>890,000</td></tr>
      <tr><td>IronXL for .NET</td><td>610,000</td></tr>
    </tbody>
  </table>
</body>
</html>
""";

// 1. Create a renderer once and reuse it across conversions
var renderer = new ChromePdfRenderer
{
    RenderingOptions =
    {
        PaperSize    = PdfPaperSize.A4,                  // ISO-standard paper size
        PaperOrientation = PdfPaperOrientation.Portrait,
        CssMediaType = PdfCssMediaType.Screen,           // Respect on-screen CSS
        RenderDelay  = 100,                              // Wait 100 ms for JS/animations
        FallbackEncoding = "utf-8"                       // Handle non-ASCII correctly
    }
};

// 2. Render the HTML fragment
using PdfDocument pdf = renderer.RenderHtmlAsPdf(html);

// 3. Persist to disk or return via ASP.NET Core FileStreamResult
pdf.SaveAs("q2-report.pdf");
' Program.cs — compatible with .NET 8 and newer
Imports IronPdf

' Sample HTML fragment (could also be read from a file, Razor view, or CMS)
Private Const html As String = "<!DOCTYPE html>
<html lang=""en"">
<head>
  <meta charset=""utf-8"">
  <title>Quarterly Report</title>
  <style>
     body { font-family:'Segoe UI', sans-serif; margin:1.2rem; }
     header { margin-bottom:2rem; }
     h1 { color:#3056d3; }
     table { width:100%; border-collapse:collapse; margin-top:1rem; }
     th,td { border:1px solid #ddd; padding:0.5rem; text-align:right; }
     tr:nth-child(even){ background-color:#f8f9fa; }
  </style>
</head>
<body>
  <header><h1>Q2 Revenue Summary</h1></header>
  <table>
    <thead><tr><th>Product</th><th>Revenue ($)</th></tr></thead>
    <tbody>
      <tr><td>IronPDF for .NET</td><td>1,200,000</td></tr>
      <tr><td>IronOCR for .NET</td><td>890,000</td></tr>
      <tr><td>IronXL for .NET</td><td>610,000</td></tr>
    </tbody>
  </table>
</body>
</html>"

' 1. Create a renderer once and reuse it across conversions
Private renderer = New ChromePdfRenderer With {
	.RenderingOptions = {
		PaperSize = PdfPaperSize.A4,
		PaperOrientation = PdfPaperOrientation.Portrait,
		CssMediaType = PdfCssMediaType.Screen,
		RenderDelay = 100,
		FallbackEncoding = "utf-8"
	}
}

' 2. Render the HTML fragment
Private PdfDocument As using

' 3. Persist to disk or return via ASP.NET Core FileStreamResult
pdf.SaveAs("q2-report.pdf")
$vbLabelText   $csharpLabel

Was der Code veranschaulicht

  • Integriertes Chromium — IronPDF bündelt die Chromium-Engine und gewährleistet so die Kompatibilität mit HTML5, CSS3 und JavaScript in modernen Browsern.
  • Ein einziges Abhängigkeitsmodul – Eine schlanke NuGet-Installation deckt Windows, Linux, Docker und Azure/AWS ab, ohne dass zusätzliche Systembibliotheken erforderlich sind.
  • Darstellungsoptionen — PaperSize, CssMediaType und RenderDelay spiegeln die PRINT-Einstellungen des Browsers wider, sodass PDFs dem Layout auf dem Bildschirm entsprechen.
  • Zukunftssichere Ausrichtung — Die API-Oberfläche ist in .NET 8, .NET 9 STS und dem kommenden .NET 10 identisch, sodass der langfristige Wartungsaufwand minimal ist.
  • Hooks für die Nachbearbeitung — PdfDocument stellt Hilfsfunktionen für das Zusammenführen, den Passwortschutz und digitale Signaturen bereit – diese werden später in diesem Leitfaden behandelt.

Weiterführende Informationen: Siehe das Schritt-für-Schritt-Tutorial "HTML-String-to-PDF" und die vollständige ChromePdfRenderer API-Dokumentation.

Wie kann eine ASP .NET Core MVC-Ansicht als PDF exportiert werden?

IronPDF rendert eine vollständig verarbeitete Razor-Ansicht ( .cshtml ) genauso wie ein Browser und streamt das Ergebnis als PdfDocument. Der unten beschriebene Workflow sorgt für eine übersichtliche Controller-Logik, erfordert keine Browser-Plugins und funktioniert unter .NET 8 LTS, der .NET 9-Vorschau sowie der für November 2025 geplanten .NET 10-Version.

Beispiel für einen End-to-End-Controller

// TicketsController.cs — .NET 8 LTS / MVC
using IronPdf;
using Microsoft.AspNetCore.Mvc;
using YourApp.Models;           // TicketViewModel

public class TicketsController : Controller
{
    private readonly ChromePdfRenderer _renderer;

    public TicketsController()
    {
        _renderer = new ChromePdfRenderer
        {
            RenderingOptions =
            {
                PaperSize        = PdfPaperSize.A5,            // Compact ticket size
                PaperOrientation = PdfPdfOrientation.Portrait,
                FitToPaperWidth  = true,
                CssMediaType     = PdfCssMediaType.Print,
                Margins = new PdfMargins(5, 10, 5, 10)         // mm
            }
        };
    }

    // GET /Tickets/Print/42
    public async Task<IActionResult> Print(int id)
    {
        TicketViewModel vm = await _service.GetTicketAsync(id);

        // 1. Render the Razor view to an HTML string
        string html  = await RazorTemplateEngine.RenderViewAsync(
                           HttpContext, "~/Views/Tickets/Print.cshtml", vm);

        // 2. Convert HTML → PDF
        using PdfDocument pdf = _renderer.RenderHtmlAsPdf(html);

        // 3. Stream back as a file
        return File(pdf.BinaryData, "application/pdf",
                    $"ticket-{id}.pdf");
    }
}
// TicketsController.cs — .NET 8 LTS / MVC
using IronPdf;
using Microsoft.AspNetCore.Mvc;
using YourApp.Models;           // TicketViewModel

public class TicketsController : Controller
{
    private readonly ChromePdfRenderer _renderer;

    public TicketsController()
    {
        _renderer = new ChromePdfRenderer
        {
            RenderingOptions =
            {
                PaperSize        = PdfPaperSize.A5,            // Compact ticket size
                PaperOrientation = PdfPdfOrientation.Portrait,
                FitToPaperWidth  = true,
                CssMediaType     = PdfCssMediaType.Print,
                Margins = new PdfMargins(5, 10, 5, 10)         // mm
            }
        };
    }

    // GET /Tickets/Print/42
    public async Task<IActionResult> Print(int id)
    {
        TicketViewModel vm = await _service.GetTicketAsync(id);

        // 1. Render the Razor view to an HTML string
        string html  = await RazorTemplateEngine.RenderViewAsync(
                           HttpContext, "~/Views/Tickets/Print.cshtml", vm);

        // 2. Convert HTML → PDF
        using PdfDocument pdf = _renderer.RenderHtmlAsPdf(html);

        // 3. Stream back as a file
        return File(pdf.BinaryData, "application/pdf",
                    $"ticket-{id}.pdf");
    }
}
Imports IronPdf
Imports Microsoft.AspNetCore.Mvc
Imports YourApp.Models ' TicketViewModel

Public Class TicketsController
    Inherits Controller

    Private ReadOnly _renderer As ChromePdfRenderer

    Public Sub New()
        _renderer = New ChromePdfRenderer With {
            .RenderingOptions = New PdfRenderingOptions With {
                .PaperSize = PdfPaperSize.A5, ' Compact ticket size
                .PaperOrientation = PdfPdfOrientation.Portrait,
                .FitToPaperWidth = True,
                .CssMediaType = PdfCssMediaType.Print,
                .Margins = New PdfMargins(5, 10, 5, 10) ' mm
            }
        }
    End Sub

    ' GET /Tickets/Print/42
    Public Async Function Print(id As Integer) As Task(Of IActionResult)
        Dim vm As TicketViewModel = Await _service.GetTicketAsync(id)

        ' 1. Render the Razor view to an HTML string
        Dim html As String = Await RazorTemplateEngine.RenderViewAsync(
            HttpContext, "~/Views/Tickets/Print.cshtml", vm)

        ' 2. Convert HTML → PDF
        Using pdf As PdfDocument = _renderer.RenderHtmlAsPdf(html)
            ' 3. Stream back as a file
            Return File(pdf.BinaryData, "application/pdf", $"ticket-{id}.pdf")
        End Using
    End Function
End Class
$vbLabelText   $csharpLabel

Was dieser Code veranschaulicht

  • Keine temporären Dateien – die Razor-Ansicht wird im Arbeitsspeicher gerendert und dann direkt an RenderHtmlAsPdf übergeben, wodurch Festplatten-E/A und Race-Conditions im temporären Ordner vermieden werden.
  • Ausgabe im Ticketformat — PaperSize = A5 und schmale Ränder sorgen dafür, dass selbst ausgedruckte Tickets kompakt bleiben.
  • Einheitliche PRINT-Formate — CssMediaType = Print wendet dieselben @media print CSS-Regeln an, die auch Browser verwenden.
  • Binäres Streaming — pdf.BinaryData überträgt das Dokument, ohne das Dateisystem zu berühren; ideal für API-Endpunkte und Lambda-Funktionen.
  • Wiederverwendbarer Renderer — ChromePdfRenderer wird einmal pro Controller instanziiert und anschließend wiederverwendet, wodurch der Overhead beim Erzeugen von Prozessen minimiert wird.

PaperSize, PaperOrientation, FitToPaperWidth

Margins, Header, Footer, Watermark

Nächster Schritt: Fügen Sie Verschlüsselung und digitale Signaturen hinzu oder führen Sie mehrere Tickets zu einer einzigen Datei zusammen. Siehe das Beispiel zum Zusammenführen und die Anleitung zur digitalen Signatur.

Wie kann ich Papierformat, Ränder, Kopfzeilen, Wasserzeichen und Sicherheitseinstellungen vor dem Drucken feinabstimmen?

IronPDF stellt ein einziges ChromePdfRenderOptions-Objekt bereit, das jeden Aspekt der Ausgabe steuert – Papierformat, Ausrichtung, Kopf- und Fußzeilen, JavaScript-Timing, Wasserzeichen, Verschlüsselung und digitale Signaturen – und das alles ohne zusätzliche Browser-Plugins.

Code-Beispiel – mehrere Optionen gleichzeitig anwenden

// AdvancedOptions.cs — .NET 8 compatible
using IronPdf;

var renderer = new ChromePdfRenderer();

// Configure everything in one place
renderer.RenderingOptions = new ChromePdfRenderOptions
{
    // 1. Page layout
    PaperSize        = PdfPaperSize.A4,                     // ISO size
    PaperOrientation = PdfPdfOrientation.Portrait,
    Margins          = new PdfMargins { Top = 20, Bottom = 25, Left = 15, Right = 15 }, // mm

    // 2. Timing & media
    CssMediaType     = PdfCssMediaType.Print,               // Respect @media print
    EnableJavaScript = true,
    RenderDelay      = 200,                                 // Wait 200 ms for animations

    // 3. Headers & footers (HTML gives full design freedom)
    HtmlHeader       = "<header style='font:14px Segoe UI'>Invoice — {{date}}</header>",
    HtmlFooter       = "<footer style='text-align:right;font-size:10px'>Page {{page}} / {{total-pages}}</footer>",

    // 4. Watermark
    Watermark        = new HtmlStamp
    {
        HtmlTemplate = "<div style='font-size:50px;color:#cccccc;opacity:0.3;'>CONFIDENTIAL</div>",
        VerticalAlignment = VerticalAlignment.Center,
        HorizontalAlignment = HorizontalAlignment.Center
    },

    // 5. Security
    SecurityOptions = new PdfSecurityOptions
    {
        OwnerPassword = "StrongOwnerPwd!",
        UserPassword  = "ReadOnly",
        AllowUserPrinting = false,
        AllowUserCopyPasteContent = false
    }
};

// Render any HTML
using PdfDocument pdf = renderer.RenderHtmlAsPdf("<h1>Advanced Options Demo</h1>");

// Digitally sign with a PFX certificate (optional)
pdf.SignAndStamp("./certs/company.pfx", "Iron Software", "Bangkok", "Approval");

// Save
pdf.SaveAs("advanced-options-demo.pdf");
// AdvancedOptions.cs — .NET 8 compatible
using IronPdf;

var renderer = new ChromePdfRenderer();

// Configure everything in one place
renderer.RenderingOptions = new ChromePdfRenderOptions
{
    // 1. Page layout
    PaperSize        = PdfPaperSize.A4,                     // ISO size
    PaperOrientation = PdfPdfOrientation.Portrait,
    Margins          = new PdfMargins { Top = 20, Bottom = 25, Left = 15, Right = 15 }, // mm

    // 2. Timing & media
    CssMediaType     = PdfCssMediaType.Print,               // Respect @media print
    EnableJavaScript = true,
    RenderDelay      = 200,                                 // Wait 200 ms for animations

    // 3. Headers & footers (HTML gives full design freedom)
    HtmlHeader       = "<header style='font:14px Segoe UI'>Invoice — {{date}}</header>",
    HtmlFooter       = "<footer style='text-align:right;font-size:10px'>Page {{page}} / {{total-pages}}</footer>",

    // 4. Watermark
    Watermark        = new HtmlStamp
    {
        HtmlTemplate = "<div style='font-size:50px;color:#cccccc;opacity:0.3;'>CONFIDENTIAL</div>",
        VerticalAlignment = VerticalAlignment.Center,
        HorizontalAlignment = HorizontalAlignment.Center
    },

    // 5. Security
    SecurityOptions = new PdfSecurityOptions
    {
        OwnerPassword = "StrongOwnerPwd!",
        UserPassword  = "ReadOnly",
        AllowUserPrinting = false,
        AllowUserCopyPasteContent = false
    }
};

// Render any HTML
using PdfDocument pdf = renderer.RenderHtmlAsPdf("<h1>Advanced Options Demo</h1>");

// Digitally sign with a PFX certificate (optional)
pdf.SignAndStamp("./certs/company.pfx", "Iron Software", "Bangkok", "Approval");

// Save
pdf.SaveAs("advanced-options-demo.pdf");
Imports IronPdf

Dim renderer As New ChromePdfRenderer()

' Configure everything in one place
renderer.RenderingOptions = New ChromePdfRenderOptions With {
    ' 1. Page layout
    .PaperSize = PdfPaperSize.A4, ' ISO size
    .PaperOrientation = PdfPdfOrientation.Portrait,
    .Margins = New PdfMargins With {.Top = 20, .Bottom = 25, .Left = 15, .Right = 15}, ' mm

    ' 2. Timing & media
    .CssMediaType = PdfCssMediaType.Print, ' Respect @media print
    .EnableJavaScript = True,
    .RenderDelay = 200, ' Wait 200 ms for animations

    ' 3. Headers & footers (HTML gives full design freedom)
    .HtmlHeader = "<header style='font:14px Segoe UI'>Invoice — {{date}}</header>",
    .HtmlFooter = "<footer style='text-align:right;font-size:10px'>Page {{page}} / {{total-pages}}</footer>",

    ' 4. Watermark
    .Watermark = New HtmlStamp With {
        .HtmlTemplate = "<div style='font-size:50px;color:#cccccc;opacity:0.3;'>CONFIDENTIAL</div>",
        .VerticalAlignment = VerticalAlignment.Center,
        .HorizontalAlignment = HorizontalAlignment.Center
    },

    ' 5. Security
    .SecurityOptions = New PdfSecurityOptions With {
        .OwnerPassword = "StrongOwnerPwd!",
        .UserPassword = "ReadOnly",
        .AllowUserPrinting = False,
        .AllowUserCopyPasteContent = False
    }
}

' Render any HTML
Using pdf As PdfDocument = renderer.RenderHtmlAsPdf("<h1>Advanced Options Demo</h1>")
    ' Digitally sign with a PFX certificate (optional)
    pdf.SignAndStamp("./certs/company.pfx", "Iron Software", "Bangkok", "Approval")

    ' Save
    pdf.SaveAs("advanced-options-demo.pdf")
End Using
$vbLabelText   $csharpLabel

Warum diese Optionen wichtig sind

  • PaperSize, Margins und CssMediaType bilden den Druckdialog eines Browsers nach, sodass das Layout auf dem Bildschirm und im PDF unter Windows, Linux und Docker identisch bleibt.
  • HTML-Kopf- und Fußzeilen unterstützen Razor-Tokens, CSS und JavaScript – praktisch für dynamische Seitenzahlen oder Branding.
  • HtmlStamp ermöglicht es, mit einer einzigen Zeile Marken-Wasserzeichen mit vollständiger HTML- und CSS-Kontrolle zu erstellen.
  • Sicherheitsoptionen ermöglichen 128-Bit-Verschlüsselung, Eigentümer-/Benutzerkennwörter und detaillierte Berechtigungen ohne Tools von Drittanbietern.
  • Digitale Signaturen fügen direkt im Code ein kryptografisches Siegel ein, wodurch die rechtliche Authentizität und Manipulationssicherheit gewährleistet werden.
  • Extraktionshilfen wie ExtractAllText und ExtractAllImages kehren den Prozess um, wenn eine Analyse erforderlich ist.

Schnellübersicht – Beliebte Einstellungen

##

PaperSize, PaperOrientation, Margins, CssMediaType, RenderDelay

##

`HtmlHeader`, `HtmlFooter`, dynamische Razor-Platzhalter, Seitennummern-Tokens

##

`Watermark`, `HtmlStamp`, Deckkraft, Ausrichtung

##

`SecurityOptions`, `SignAndStamp`, Eigentümer-/Benutzerkennwörter, Zertifikatsversiegelung

Nächste Aufgaben: Mehrere PDF-Dateien zusammenführen, Text und Bilder extrahieren und auf Docker oder serverlos bereitstellen. Fahren Sie mit dem Abschnitt zur Bereitstellung fort, um plattformübergreifende Kompatibilität sicherzustellen.

Wie kann ich Code zur PDF-Erstellung auf Docker unter Linux und Windows bereitstellen?

IronPdf wird als einzelnes, in sich geschlossenes NuGet-Paket ausgeliefert, sodass die Containerisierung einer ASP.NET Core- (oder Konsolen-)Anwendung sowohl unter Windows als auch unter Linux unkompliziert ist. Der Schlüssel liegt darin, die veröffentlichten Binärdateien in ein schlankes Laufzeit-Image zu kopieren und unter Linux die beiden von IronPDF benötigten nativen Bibliotheken (libnss3 und libatk1.0-0) hinzuzufügen.

Mehrstufiges Dockerfile (Ubuntu 22.04)

Hinweis:Warum mehrstufig? Das SDK-Image (Stufe 1) kompiliert das Projekt; Das endgültige Laufzeit-Image (Phase 2) bleibt schlank – < 120 MB –, da Build-Tools verworfen werden.

####### ---------- stage 1 ----------
FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src
COPY ["MyPdfApp.csproj", "."]
RUN dotnet restore

COPY . .
RUN dotnet publish -c Release -o /app/publish

####### ---------- stage 2 ----------
FROM mcr.microsoft.com/dotnet/aspnet:8.0-jammy
######## Install two native libs required by Chromium
RUN apt-get update && \
    apt-get install -y --no-install-recommends libnss3 libatk1.0-0 && \
    rm -rf /var/lib/apt/lists/*

WORKDIR /app
COPY --from=build /app/publish .
ENTRYPOINT ["dotnet", "MyPdfApp.dll"]

Hinweis:Windows-Container? Ersetzen Sie die zweite Stufe durch mcr.microsoft.com/dotnet/aspnet:8.0-windowsservercore-ltsc2022 – es sind keine zusätzlichen Pakete erforderlich, da die Chromium-DLLs bereits enthalten sind.

End-to-End-Validierungsskript

docker build -t pdf-demo .
docker run --rm -p 8080:80 pdf-demo
######### ↳ Navigate to http://localhost:8080/api/pdf?url=https://example.com
docker build -t pdf-demo .
docker run --rm -p 8080:80 pdf-demo
######### ↳ Navigate to http://localhost:8080/api/pdf?url=https://example.com
SHELL
  • Die API-Aktion ruft intern ChromePdfRenderer.RenderUrlAsPdf auf, genau wie in Abschnitt 2.
  • IronPDF startet seinen sandboxed Chromium-Prozess innerhalb des Containers – ein X-Server ist nicht erforderlich, da die Darstellung headless erfolgt.
  • Der Speicherbedarf bleibt selbst bei umfangreichen Renderings unter 200 MB.

TippsTipp zur Fehlerbehebung: Wenn die Container-Protokolle den Fehler "libnss3.so not found" anzeigen, überprüfen Sie, ob sowohl libnss3 als auch libatk1.0-0 vorhanden sind. Alpine-Images werden nicht unterstützt, da der musl-C-Bibliothek erforderliche Symbole fehlen.

Interne Ressourcen

Wie kann ich in .NET Core vorhandene PDF-Dateien öffnen, zusammenführen, mit einem Wasserzeichen versehen und Inhalte daraus extrahieren?

IronPDF behandelt jede PDF-Datei – egal, ob sie von IronPDF, Adobe® Acrobat oder Tools von Drittanbietern erstellt wurde – als erstklassiges PdfDocument-Objekt, das ohne Qualitätsverlust geöffnet, bearbeitet, gesichert und erneut gespeichert werden kann. Die gleiche API-Oberfläche funktioniert heute unter .NET 8 LTS und lässt sich unverändert unter der .NET 9-Vorschau sowie der kommenden .NET 10-Version kompilieren.

Einheitliches Beispiel – öffnen → zusammenführen → Wasserzeichen → extrahieren

// ManipulateExistingPdf.cs — .NET 8 LTS compatible
using IronPdf;
using System.Linq;

// Step 1: Open two existing files (password-protected PDFs are supported)
PdfDocument invoice  = PdfDocument.FromFile("invoice.pdf", "ReadOnly");   // open with user pwd
PdfDocument tAndCs   = PdfDocument.FromFile("terms.pdf");                 // no pwd required

// Step 2: Merge them (invoice pages first, then T&Cs)
PdfDocument mergedPdf = PdfDocument.Merge(invoice, tAndCs);               // 1-liner merge

// Step 3: Apply a diagonal CONFIDENTIAL watermark to every page
mergedPdf.ApplyStamp(
    "<div style='font-size:60px;color:#d9534f;opacity:0.2;transform:rotate(-45deg);"
  + "width:100%;text-align:center;'>CONFIDENTIAL</div>",
    verticalAlignment   : VerticalAlignment.Center,
    horizontalAlignment : HorizontalAlignment.Center);

// Step 4: Extract all text and the first image for audit purposes
string fullText = mergedPdf.ExtractAllText();
var    image    = mergedPdf.ExtractAllImages().FirstOrDefault();

// Step 5: Save or stream
mergedPdf.SaveAs("invoice-with-terms.pdf");
// ManipulateExistingPdf.cs — .NET 8 LTS compatible
using IronPdf;
using System.Linq;

// Step 1: Open two existing files (password-protected PDFs are supported)
PdfDocument invoice  = PdfDocument.FromFile("invoice.pdf", "ReadOnly");   // open with user pwd
PdfDocument tAndCs   = PdfDocument.FromFile("terms.pdf");                 // no pwd required

// Step 2: Merge them (invoice pages first, then T&Cs)
PdfDocument mergedPdf = PdfDocument.Merge(invoice, tAndCs);               // 1-liner merge

// Step 3: Apply a diagonal CONFIDENTIAL watermark to every page
mergedPdf.ApplyStamp(
    "<div style='font-size:60px;color:#d9534f;opacity:0.2;transform:rotate(-45deg);"
  + "width:100%;text-align:center;'>CONFIDENTIAL</div>",
    verticalAlignment   : VerticalAlignment.Center,
    horizontalAlignment : HorizontalAlignment.Center);

// Step 4: Extract all text and the first image for audit purposes
string fullText = mergedPdf.ExtractAllText();
var    image    = mergedPdf.ExtractAllImages().FirstOrDefault();

// Step 5: Save or stream
mergedPdf.SaveAs("invoice-with-terms.pdf");
' ManipulateExistingPdf.cs — .NET 8 LTS compatible
Imports IronPdf
Imports System.Linq

' Step 1: Open two existing files (password-protected PDFs are supported)
Private invoice As PdfDocument = PdfDocument.FromFile("invoice.pdf", "ReadOnly") ' open with user pwd
Private tAndCs As PdfDocument = PdfDocument.FromFile("terms.pdf") ' no pwd required

' Step 2: Merge them (invoice pages first, then T&Cs)
Private mergedPdf As PdfDocument = PdfDocument.Merge(invoice, tAndCs) ' 1-liner merge

' Step 3: Apply a diagonal CONFIDENTIAL watermark to every page
mergedPdf.ApplyStamp("<div style='font-size:60px;color:#d9534f;opacity:0.2;transform:rotate(-45deg);" & "width:100%;text-align:center;'>CONFIDENTIAL</div>", verticalAlignment := VerticalAlignment.Center, horizontalAlignment := HorizontalAlignment.Center)

' Step 4: Extract all text and the first image for audit purposes
Dim fullText As String = mergedPdf.ExtractAllText()
Dim image = mergedPdf.ExtractAllImages().FirstOrDefault()

' Step 5: Save or stream
mergedPdf.SaveAs("invoice-with-terms.pdf")
$vbLabelText   $csharpLabel

Warum dies wichtig ist

  • Öffnen & Zusammenführen – PdfDocument.FromFile lädt alle standardkonformen PDF-Dateien, einschließlich verschlüsselter Dateien, während PdfDocument.Merge eine beliebige Anzahl von Dokumenten in einem einzigen Aufruf zusammenfügt.
  • Watermark – ApplyStamp (alias HtmlStamp) bettet vollständig formatierte HTML/CSS-Overlays – Logo, QR-Code oder diagonaler Text – auf ausgewählten Seiten ohne Rasterisierung ein.
  • Extraktion von Inhalten – ExtractAllText und ExtractAllImages extrahieren rohen UTF-8-Text oder binäre Bildströme für die nachgelagerte Archivierung oder KI-Pipelines.
  • Bereit für digitale Signaturen – dieselbe PdfDocument-Instanz kann mit SignAndStamp versiegelt werden, wodurch RFC 3161-konforme Hashes erzeugt werden, die den Anforderungen für digitale Signaturen gemäß ISO 32000-2 entsprechen.
  • Einhaltung offener Standards – IronPDF bewahrt die ursprüngliche PDF-Struktur (Schriftarten, Ebenen, XMP-Metadaten), sodass die Ausgabe mit Adobe® Reader und anderen ISO 32000-1-Viewern kompatibel bleibt.
  • Zukunftssicher – Die API vermeidet Interop-Assemblies und Win32-GDI-Aufrufe, sodass der Code unverändert unter Windows, Linux, Docker und den kommenden serverlosen .NET 10-SKUs läuft.

Möchten Sie Seiten teilen, drehen oder löschen? Im Tutorial zur Bearbeitung auf Seitenebene finden Sie detaillierte Anleitungen für diese Vorgänge.

Wie können PDF-Dateien in .NET Core verschlüsselt und digital signiert werden?

IronPDF sichert ein Dokument in zwei Schritten: AES-basierte Verschlüsselung (Benutzer-/Eigentümerkennwörter + detaillierte Berechtigungen) und digitale X.509-Signaturen, die die Datei mit einem kryptografischen Hash versiegeln. Beide APIs befinden sich auf demselben PdfDocument-Objekt, sodass der Workflow heute unter .NET 8 LTS identisch ist und sich unverändert unter der .NET 9-Vorschau sowie der kommenden .NET 10-Version kompilieren lässt.

Beispiel – 256-Bit-AES anwenden, PRINT-Rechte sperren und eine sichtbare Signatur hinzufügen

// SecureAndSign.cs — .NET 8 LTS compatible
using IronPdf;

// Step 1: Load an existing PDF (or produce one with RenderHtmlAsPdf)
PdfDocument pdf = PdfDocument.FromFile("financial-report.pdf");

// Step 2: Configure AES-256 encryption & permissions
pdf.SecuritySettings = new PdfSecuritySettings
{
    EncryptionAlgorithm   = PdfEncryptionAlgorithm.AES256Bit,
    OwnerPassword         = "IronAdmin!2025",
    UserPassword          = "ReadOnly",
    AllowUserPrinting     = PdfPrintSecurity.Disabled,
    AllowUserCopyPasteContent = false,
    AllowUserAnnotations  = false
};

// Step 3: Digitally sign with a PFX certificate
pdf.SignAndStamp(
    certificatePath : "./certs/ironsoftware.pfx",
    authority       : "Iron Software Ltd.",
    location        : "Chicago, IL",
    reason          : "Final approval"
);

// Step 4: Persist or stream
pdf.SaveAs("financial-report-secured-signed.pdf");
// SecureAndSign.cs — .NET 8 LTS compatible
using IronPdf;

// Step 1: Load an existing PDF (or produce one with RenderHtmlAsPdf)
PdfDocument pdf = PdfDocument.FromFile("financial-report.pdf");

// Step 2: Configure AES-256 encryption & permissions
pdf.SecuritySettings = new PdfSecuritySettings
{
    EncryptionAlgorithm   = PdfEncryptionAlgorithm.AES256Bit,
    OwnerPassword         = "IronAdmin!2025",
    UserPassword          = "ReadOnly",
    AllowUserPrinting     = PdfPrintSecurity.Disabled,
    AllowUserCopyPasteContent = false,
    AllowUserAnnotations  = false
};

// Step 3: Digitally sign with a PFX certificate
pdf.SignAndStamp(
    certificatePath : "./certs/ironsoftware.pfx",
    authority       : "Iron Software Ltd.",
    location        : "Chicago, IL",
    reason          : "Final approval"
);

// Step 4: Persist or stream
pdf.SaveAs("financial-report-secured-signed.pdf");
' SecureAndSign.cs — .NET 8 LTS compatible
Imports IronPdf

' Step 1: Load an existing PDF (or produce one with RenderHtmlAsPdf)
Private pdf As PdfDocument = PdfDocument.FromFile("financial-report.pdf")

' Step 2: Configure AES-256 encryption & permissions
pdf.SecuritySettings = New PdfSecuritySettings With {
	.EncryptionAlgorithm = PdfEncryptionAlgorithm.AES256Bit,
	.OwnerPassword = "IronAdmin!2025",
	.UserPassword = "ReadOnly",
	.AllowUserPrinting = PdfPrintSecurity.Disabled,
	.AllowUserCopyPasteContent = False,
	.AllowUserAnnotations = False
}

' Step 3: Digitally sign with a PFX certificate
pdf.SignAndStamp(certificatePath := "./certs/ironsoftware.pfx", authority := "Iron Software Ltd.", location := "Chicago, IL", reason := "Final approval")

' Step 4: Persist or stream
pdf.SaveAs("financial-report-secured-signed.pdf")
$vbLabelText   $csharpLabel

Hinter den Kulissen

  • AES-256-Verschlüsselung — IronPDF verschlüsselt die Nutzdaten mit NIST-zertifizierten AES-Schlüsseln und verhindert so unbefugtes Öffnen, Drucken oder Kopieren und Einfügen.
  • Granularität der Berechtigungen – Eigenschaften wie AllowUserPrinting und AllowUserFormData schalten Rechte pro Aktion um; Ein Eigentümerpasswort ist erforderlich, damit Einschränkungen wirksam werden.
  • Digitale Signaturen — SignAndStamp bettet einen RFC 3161-Zeitstempel und eine Zertifikatskette ein und erstellt so manipulationssichere Hashes, die von Adobe® Acrobat und anderen ISO 32000-2-Viewern erkannt werden.
  • API aus einer Hand – sowohl die Verschlüsselung als auch die Signierung bearbeiten dieselbe PdfDocument-Instanz, wodurch mehrere Dateidurchläufe vermieden und interne Schriftarten, Ebenen und Metadaten erhalten bleiben.

TippsTipp zur Fehlerbehebung: Wenn Adobe Reader eine "ungültige Signatur" meldet, stellen Sie sicher, dass die PFX-Datei ein vertrauenswürdiges Stammzertifikat enthält und die Zeichenfolgen location ASCII-konform sind.

Wichtige Sicherheitseinstellungen

##

`PdfSecuritySettings` → `OwnerPassword`, `UserPassword`, `EncryptionAlgorithm`, `AllowUserPrinting`

##

`PdfDocument.SignAndStamp` — PFX-Pfad, Berechtigung, Speicherort, Grund, Zeitstempel

Interne Ressourcen für tiefergehende Einblicke

Wie lässt sich die HTML-zu-PDF-Leistung in .NET Core optimieren und skalieren?

Die Chromium-Engine von IronPDF rendert die meisten Seiten auf moderner Hardware bereits in weniger als einer Sekunde, doch der Durchsatz lässt sich durch Batch-Rendering, die Aktivierung von Multithreading und die Reduzierung des Headless-Chrome-Overheads noch weiter steigern. Die folgenden Tipps gelten gleichermaßen für alle .NET-Versionen.

1. Batch-Rendering in einem Hintergrund-Thread-Pool

// BatchRender.cs — Thread-safe on .NET 8+
using IronPdf;
using System.Threading.Tasks;

var htmlSources = Directory.GetFiles("./html", "*.html");
var renderer    = new ChromePdfRenderer();                 // reuse 1 instance

Parallel.ForEach(htmlSources, new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount }, file =>
{
    string html = File.ReadAllText(file);
    using PdfDocument pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs(Path.ChangeExtension(file, ".pdf"));
});
// BatchRender.cs — Thread-safe on .NET 8+
using IronPdf;
using System.Threading.Tasks;

var htmlSources = Directory.GetFiles("./html", "*.html");
var renderer    = new ChromePdfRenderer();                 // reuse 1 instance

Parallel.ForEach(htmlSources, new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount }, file =>
{
    string html = File.ReadAllText(file);
    using PdfDocument pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs(Path.ChangeExtension(file, ".pdf"));
});
' BatchRender.cs — Thread-safe on .NET 8+
Imports IronPdf
Imports System.Threading.Tasks

Private htmlSources = Directory.GetFiles("./html", "*.html")
Private renderer = New ChromePdfRenderer() ' reuse 1 instance

Parallel.ForEach(htmlSources, New ParallelOptions With {.MaxDegreeOfParallelism = Environment.ProcessorCount}, Sub(file)
	Dim html As String = File.ReadAllText(file)
	Using pdf As PdfDocument = renderer.RenderHtmlAsPdf(html)
		pdf.SaveAs(Path.ChangeExtension(file, ".pdf"))
	End Using
End Sub)
$vbLabelText   $csharpLabel

2. Startkosten von Headless Chrome reduzieren

IronPDF liefert eine eigene Chromium-Version mit, doch jede Darstellung verursacht eine geringe Startverzögerung. Pooling ist hilfreich, und Linux-Container müssen zwei native Bibliotheken enthalten:

RUN apt-get update && \
    apt-get install -y --no-install-recommends libnss3 libatk1.0-0

Das Fehlen einer der beiden Bibliotheken führt zu einem libnss3.so not found-Fehler in den Docker-Protokollen.

Zu den empfohlenen Chrome-Flags (die von IronPDF automatisch angewendet werden) gehören --disable-gpu und --no-sandbox, um Speicher- und Root-User-Probleme in Containern zu reduzieren.

3. Warten auf spätes JavaScript mit RenderDelay oder WaitFor

Seiten, die Zähler animieren oder Daten nach DOMContentLoaded abrufen, benötigen möglicherweise eine kurze Verzögerung:

renderer.RenderingOptions.RenderDelay = 200;        // ms
// OR: renderer.RenderingOptions.JavaScript = "WaitFor('window.doneLoading')";
renderer.RenderingOptions.RenderDelay = 200;        // ms
// OR: renderer.RenderingOptions.JavaScript = "WaitFor('window.doneLoading')";
renderer.RenderingOptions.RenderDelay = 200 ' ms
' OR: renderer.RenderingOptions.JavaScript = "WaitFor('window.doneLoading')";
$vbLabelText   $csharpLabel

Siehe das spezielle WaitFor-Tutorial zu benutzerdefinierten Promises und DOM-Polling.

4. Debug-Protokollierung für eine Anfrage aktivieren

renderer.LoggingOptions.DebugMode        = true;
renderer.LoggingOptions.LogsToConsole    = true;
renderer.LoggingOptions.LogFilePath      = "./logs/ironpdf-debug.log";
renderer.LoggingOptions.DebugMode        = true;
renderer.LoggingOptions.LogsToConsole    = true;
renderer.LoggingOptions.LogFilePath      = "./logs/ironpdf-debug.log";
renderer.LoggingOptions.DebugMode = True
renderer.LoggingOptions.LogsToConsole = True
renderer.LoggingOptions.LogFilePath = "./logs/ironpdf-debug.log"
$vbLabelText   $csharpLabel

Live DevTools-Traces zeigen fehlende Schriftarten, 404-Fehler bei Bildern und Zeitereignisse an, ohne dass der Code neu kompiliert werden muss.

5. Wiederverwendung von PDF-Vorlagen anstelle einer erneuten Darstellung

Erstellen Sie für Rechnungsläufe eine PDF-Vorlage mit Platzhaltern wie [[name]] und führen Sie eine Textersetzung durch, anstatt komplexes HTML neu zu erstellen. Sie ist 10-mal schneller und speicherfreundlich.

Checkliste für die Schnelloptimierung

##

`Parallel.ForEach`, `async/await`, wiederverwenden Sie ein einziges `ChromePdfRenderer`

##

Verwenden Sie `aspnet:8.0-jammy`; installiere `libnss3` + `libatk1.0-0`; Flags `--no-sandbox`, `--disable-gpu`

##

`RenderDelay`, `WaitFor()`, DevTools-Timeline für langsame SPA-Hydrationen protokollieren

Weiterführende Literatur

Wo kann ich eine kostenlose Testversion herunterladen, eine Lizenz auswählen und kompetenten Support erhalten? {#anchor-10-resources}

Ein Schlüssel für die 30-Tage-Testversion wird sofort über das Formular "Kostenlose Testversion starten" ausgestellt und schaltet alle Funktionen frei – einschließlich HTML-zu-PDF, digitale Signaturen und Verschlüsselung – ohne Wasserzeichen.

Wählen Sie nach der Evaluierung der Bibliothek eine unbefristete Entwickler-, Bereitstellungs- oder Enterprise-Lizenz aus; Jeder Tarif umfasst kostenlose kleinere Updates, Nutzungsrechte für Dev/Staging/Produktion sowie eine 30-tägige Geld-zurück-Garantie. Die Anwendung des Schlüssels erfolgt über eine einzige Codezeile (IronPdf.License.LicenseKey = "YOUR-KEY";) und kann in CI/CD-Pipelines automatisiert werden.

Umfassende Dokumentation – Schnellstartanleitungen, API Referenz und Tutorial-Videos – ist im Dokumentationsportal verfügbar und wird bei jeder .NET-Veröffentlichung aktualisiert.

Technische Fragen werden innerhalb eines Werktags per Live-Chat, E-Mail oder Telefon vom Support-Team in Chicago beantwortet.

Häufig gestellte Fragen zur Leistungsoptimierung und Bereitstellung sind im Performance Assistance Centre zusammengefasst.

Schnellzugriff

Ressource URL Warum das wichtig ist
Holen Sie sich eine 30-Tage-Testversion https://ironpdf.com/demos/ Schaltet alle Funktionen ohne Wasserzeichen frei
Lizenzierung & Preise https://ironpdf.com/licensing/ Unbefristete Lizenzen oder Abonnements; Iron Suite bündelt 10 Bibliotheken
API Referenz https://ironpdf.com/object-reference/api/ Vollständige Klassendokumentation, z. B. ChromePdfRenderer
Dokumentenportal https://ironpdf.com/docs/ Anleitungen, Tutorials, Beispielprojekte
Unterstützung bei der Leistungsoptimierung https://ironpdf.com/troubleshooting/ironpdf-performance-assistance/ Tipps zur Optimierung und Skalierung
Support kontaktieren https://ironsoftware.com/contact-us/ Live-Chat, E-Mail-Support, telefonischer Support

Nächste Schritte

  1. Klonen Sie das Beispiel-Repo, das alle wichtigen Funktionen demonstriert – vom MVC-View-Rendering bis zur AES-256-Verschlüsselung.
  2. Fügen Sie den Testschlüssel in eine bestehende Lösung ein und führen Sie die Unit-Tests durch, um die plattformübergreifende Kompatibilität zu überprüfen.
  3. Vereinbaren Sie eine Live-Demo mit dem Entwicklerteam, um projektspezifische Empfehlungen zu erhalten.

Mit diesen Ressourcen kann jedes .NET-Team pixelgenaue PDFs innerhalb eines einzigen Sprints in die Produktion bringen – vor Ort, in Docker oder serverlos.

Häufig gestellte Fragen

Wie kann ich HTML in .NET Core in PDF umwandeln?

Sie können HTML in .NET Core mit der IronPDF-Bibliothek in PDF umwandeln. Installieren Sie zuerst das IronPDF NuGet-Paket und erstellen Sie dann eine ChromePdfRenderer-Instanz. Verwenden Sie die RenderHtmlAsPdf-Methode, um HTML-Strings in PDFs umzuwandeln.

Wie konvertiere ich eine Website-URL in ein PDF-Dokument?

Um eine Website-URL in ein PDF-Dokument zu konvertieren, installieren Sie das IronPDF NuGet-Paket, erstellen Sie eine ChromePdfRenderer-Instanz und verwenden Sie die RenderUrlAsPdf-Methode, um die URL in ein PDF zu rendern. Das Ergebnis kann mit der SaveAs-Methode gespeichert werden.

Was ist der beste Weg, um Razor-Ansichten in PDFs zu konvertieren?

Der beste Weg, um Razor-Ansichten in PDFs zu konvertieren, ist die Verwendung von IronPDF. Rendern Sie zuerst die Razor-Ansicht in einen HTML-String und übergeben Sie diesen String dann an die RenderHtmlAsPdf-Methode, um ein PDF-Dokument zu erstellen.

Wie kann ich die Sicherheit meiner PDF-Dokumente erhöhen?

Verbessern Sie die PDF-Sicherheit durch die Verwendung von IronPDF, indem Sie AES-256-Verschlüsselung anwenden, Passwörter setzen und Benutzerberechtigungen steuern. Konfigurieren Sie diese Einstellungen über die SecuritySettings-Eigenschaft, um Aktionen wie Drucken und Bearbeiten einzuschränken.

Welche Optionen gibt es zur Anpassung der PDF-Renderung?

IronPDF bietet verschiedene Renderoptionen über die ChromePdfRenderOptions-Klasse, einschließlich der Einstellung von Papiergröße, Ausrichtung, Rändern und der Anwendung von CSS-Medien-Typen. Sie können auch Kopf- und Fußzeilen sowie Wasserzeichen für einen individuell gestalteten Dokumentenausgang hinzufügen.

Wie deploye ich eine PDF-Generierungsanwendung in einem Docker-Container?

Um eine PDF-Generierungsanwendung in einem Docker-Container zu deployen, konfigurieren Sie Linux-Abhängigkeiten in Ihrer Dockerfile und setzen Sie Benutzerberechtigungen. Verwenden Sie IronPdf.Installation.LinuxAndDockerDependenciesAutoConfig für die automatische Verwaltung von Abhängigkeiten.

Wie kann ich Wasserzeichen mit C# zu einem PDF hinzufügen?

Sie können Wasserzeichen zu PDFs mit IronPDF hinzufügen, indem Sie die Watermark-Eigenschaft mit HtmlStamp-Objekten nutzen. Für erweiterte Optionen erlaubt die HtmlStamper-Klasse benutzerdefinierte Positionierung und Transparenzeffekte.

Kann ich digitale Signaturen zu PDF-Dokumenten hinzufügen?

Ja, Sie können digitale Signaturen zu PDFs mit der PdfSignature-Klasse von IronPDF hinzufügen. Verwenden Sie die Sign-Methode an einem PdfDocument und geben Sie eine Zertifikatsdatei an, um die Integrität und Authentizität des Dokuments sicherzustellen.

Wie kann ich die Leistung der PDF-Generierung in .NET Core optimieren?

Optimieren Sie die PDF-Generierungsleistung, indem Sie eine threadsichere ChromePdfRenderer-Instanz wiederverwenden, Multithreading aktivieren und unnötige Headless-Chrome-Start-Flags entfernen. Diese Praktiken tragen zur Effizienzsteigerung Ihrer Anwendung bei.

Funktioniert das .NET Core HTML-zu-PDF-Beispiel in diesem Tutorial auch mit .NET 10?

Ja. IronPDF ist vollständig kompatibel mit .NET 10, sodass Sie das ChromePdfRenderer HTML-zu-PDF-Beispiel aus diesem Tutorial in .NET 10 Projekten verwenden können, ohne den Kerncode zu ändern. Der Hauptunterschied besteht darin, dass Sie .NET 10 beim Erstellen des Projekts anvisieren, dann das neueste IronPDF-Paket von NuGet installieren, um pixelgenaue PDFs aus HTML, Razor-Ansichten oder URLs zu erstellen.

Jacob Mellor, Chief Technology Officer @ Team Iron
Jacob Mellor
  Jetzt mit dem Ingenieurteam chatten
Chief Technology Officer

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

Weiterlesen
Rezensiert von
Jeff Fritz
Jeffrey T. Fritz
Principal Program Manager - .NET Community Team
Jeff ist außerdem Principal Program Manager für das .NET- und Visual Studio-Team. Er ist der ausführende Produzent der .NET Conf Virtual Conference Series und moderiert ‚Fritz and Friends‘, einen Livestream für Entwickler, der zweimal wöchentlich ausgestrahlt wird. Dort spricht er über Technik und schreibt gemeinsam mit den Zuschauern Code. Jeff schreibt Workshops, Präsentationen und plant Inhalte für die größten Microsoft-Entwicklerveranstaltungen, einschließlich Microsoft Build, Microsoft Ignite, .NET Conf und dem Microsoft MVP Summit.
Bereit anzufangen?
Nuget Downloads 19,014,616 | Version: 2026.5 just released
Still Scrolling Icon

Scrollst du immer noch?

Sie brauchen schnell einen Beweis? PM > Install-Package IronPdf
Führen Sie eine Probe aus Sehen Sie zu, wie Ihr HTML-Code in eine PDF-Datei umgewandelt wird.