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

Convert HTML to PDF in .NET Core: End-to-End Guide for URLs, Razor Views, Security & Docker

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

Hochwertige PDFs direkt aus HTML zu generieren, ist eine Routineanforderung in modernen .NET-Anwendungen – Berichte, Rechnungen und Tickets benötigen pixelgenaue Ausgaben, die mit der Web-Oberfläche übereinstimmen. IronPDF rationalisiert diesen Workflow, indem es eine einzige C#-API bereitstellt, um HTML, Razor-Ansichten und vollständige Websites in standardkonforme PDF-Dokumente umzuwandeln. Am Ende dieser Anleitung wird ein Entwickler in der Lage sein, URLs, rohes HTML oder MVC-Ansichten in einem ASP.NET Core-Projekt zu konvertieren und denselben Code auf Windows, Linux, Docker oder serverlosen Umgebungen bereitzustellen.

TippsFür Layoutprobleme liefert IronPDF einen Headless-Chrome-Debugger, der hilft, CSS-, JavaScript- und Media-Query-Feinheiten zu diagnostizieren, bevor das PDF gerendert wird. Überprüfen Sie den speziellen pixelgenauen HTML-zu-PDF-Leitfaden für tiefgehende Techniken.

als-Überschrift:2(Schnellstart: Erstellen Sie ein PDF aus HTML in .NET Core)

Mühelos HTML zu PDF in .NET Core mit der IronPDF-Bibliothek konvertieren. Diese Anleitung bietet ein einfaches Beispiel, um Ihnen schnell den Einstieg zu erleichtern, indem Sie HTML-Inhalte mit minimalem Code in ein hochwertiges PDF rendern. Perfekt für Entwickler, die die PDF-Erstellung mühelos in ihre Anwendungen integrieren möchten.

Nuget IconGet started making PDFs with NuGet now:

  1. Install IronPDF with NuGet Package Manager

    PM > Install-Package IronPdf

  2. Copy and run this code snippet.

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

  3. Deploy to test on your live environment

    Start using IronPDF in your project today with a free trial
    arrow pointer
class="hsg-featured-snippet">

Minimaler Workflow (5 Schritte)

  1. Installieren Sie das IronPdf NuGet-Paket
  2. Konvertieren Sie eine Website-URL mit RenderUrlAsPdf
  3. Rundern Sie rohes HTML mit RenderHtmlAsPdf
  4. Exportieren Sie eine MVC-Ansicht zu PDF
  5. Passen Sie Papiergröße, Ränder, Kopf- und Fußzeilen an

Schnellstart-Checkliste

  1. Installieren – Install-Package IronPdf
  2. Rendern Sie eine URL – ChromePdfRenderer.RenderUrlAsPdf()
  3. Rendern Sie rohes HTML – ChromePdfRenderer.RenderHtmlAsPdf()
  4. Exportieren Sie eine Razor-Ansicht – ChromePdfRenderer.RenderHtmlAsPdfAsync()
  5. Passen Sie die Ausgabe an – nutzen Sie ChromePdfRenderer.RenderingOptions

Was dieses Tutorial abdeckt

  • URL-, HTML-String- und Razor-Ansicht-Konvertierung
  • Papier-, Rand- und Medientyp-Konfiguration
  • Plattformübergreifende Bereitstellung (Windows, Linux, Docker)
  • Nachbearbeitung: Zusammenführen, Wasserzeichen, Passwortschutz und digitale Signatur von PDFs
  • End-to-End-Beispiel: MVC-App zur Ticketbuchung

Mit IronPDF beginnen

Nutzen Sie IronPDF heute kostenlos in Ihrem Projekt.

Erster Schritt:
green arrow pointer

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

Die Installation der Bibliothek ist eine Einzeiler in jedem .NET 8-Projekt und bleibt vorwärts kompatibel mit .NET 9-Vorschau und dem kommenden .NET 10-Release. Verwenden Sie die Paket-Manager-Konsole von NuGet und der Paketmanager löst jede Abhängigkeit automatisch für Windows, Linux, Docker und serverlose Ziele.

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

Hinweis:Benötigen Sie CLI? Derselbe Befehl funktioniert mit dotnet add package IronPdf innerhalb Ihres Projektordners.

Nach der Installation bestätigen Sie, dass alles verbunden ist, indem Sie eine öffentlicheURLin PDF 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

Wie es funktioniert

  • ChromePdfRenderer startet eine sandboxed Chromium-Instanz im Hintergrund – keine separate Chrome-Installation erforderlich.
  • RenderUrlAsPdf erfasst das voll gerenderte DOM, einschließlich JavaScript-gesteuerten Inhalten, CSS-Media-Queries und Schriftarten.
  • Das resultierende PdfDocument bietet Hilfsmethoden zum Zusammenführen, Passwortschutz oder digitalen Signieren der Ausgabe– dies wird später in diesem Tutorial behandelt.

For more detail on deployment nuances (Azure App Service, AWS Lambda, on-prem Linux), see the dedicated installation guide and the advanced NuGet setup pages. Interne CI/CD-Tipps für Docker und K8s-Cluster werden in den Best Practices für Docker-Bereitstellungen behandelt.

Wie kann ein .NET Core-Dienst eine Live-Website-URL in PDF umwandeln?

Ein einzelner Aufruf von RenderUrlAsPdf reicht aus: Übergeben Sie eine öffentlich erreichbareURLund IronPDF liefert ein vollständig gerendertes, standardskonformes PDF zurück. Der unten stehende Code zielt auf .NET 8 LTS ab und kompiliert unverändert auf .NET 9-Vorschau sowie das kommende .NET 10-Release im Jahr 2025.

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 sandboxed Chromium-Instanz – keine System-Chrome-Abhängigkeit, wodurch Docker-Images schlank bleiben.
  • RenderUrlAsPdf wartet, bis DOM und JavaScript fertig sind, bevor ein Schnappschuss erstellt wird, sodass Einzelseitige-Apps korrekt gerendert werden.
  • Das Setzen von CssMediaType auf Drucken fordert die Engine auf, druckspezifische Regeln zu verwenden, die der Drucken → Als PDF speichern-Ausgabe eines Browsers entsprechen.
  • Das resultierende PdfDocument kann verschlüsselt, digital signiert, zusammengeführt oder gerastert werden – diese Fähigkeiten werden in späteren Abschnitten behandelt.

TippsPixelgenaues Debuggen: Aktivieren Sie renderer.LoggingOptions.DebugMode = true und folgen Sie dem Headless-Chrome-Debug-Leitfaden um Live-DevTools während des Renderings zu inspizieren.

Verwandte Ressourcen

Wie kann ich rohes HTML in .NET Core in ein PDF konvertieren?

Das Übergeben eines HTML-Strings – oder das gerenderte Markup einer Razor-Ansicht – an ChromePdfRenderer.RenderHtmlAsPdf erzeugt sofort ein standardskonformes PDF. Die Methode startet IronPDFs eingebettete Chromium-Engine, sodass keine externe Browser-Installation oder WebView-Abhängigkeit erforderlich ist. Der unten gezeigte Code kompiliert heute auf .NET 8 LTS und bleibt vorwärts kompatibel mit .NET 9 und dem angesetzten .NET 10-Release im November 2025.

Beispiel — ein PDF aus einem HTML-Fragment generieren

// 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 demonstriert

  • Embedded Chromium -- IronPDF bundles the Chromium engine, guaranteeing HTML5, CSS3, and JavaScript parity with modern browsers.
  • Einzelne Abhängigkeit – Eine leichtgewichtige NuGet-Installation deckt Windows, Linux, Docker und Azure/AWS ohne zusätzliche Systembibliotheken ab.
  • Render-Optionen – PaperSize, CssMediaType und RenderDelay spiegeln die Druckeinstellungen des Browsers wider, sodass PDFs den Bildschirmlayouts entsprechen.
  • Zukunftssicheres Targeting – Die API-Oberfläche ist identisch in .NET 8, .NET 9 STS und dem kommenden .NET 10, sodass langfristiger Wartungsaufwand minimal ist.
  • Nachbearbeitungshooks – PdfDocument bietet Helfer für Zusammenführen, Passwortschutz und digitale Signaturen–jede wird später in diesem Leitfaden behandelt.

Further reading: see the step-by-step HTML-string-to-PDF tutorial and the full ChromePdfRenderer API documentation.

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

IronPDF rendert eine vollständig verarbeitete Razor-Ansicht ( .cshtml ) auf dieselbe Weise, wie es ein Browser tun würde und streamt das Ergebnis als PdfDocument. Der folgende Workflow hält die Controller-Logik sauber, erfordert keine Browser-Plugins und funktioniert in .NET 8 LTS, .NET 9-Vorschau und dem angesetzten .NET 10-Release im November 2025.

End-to-End-Controller-Beispiel

// 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 = PdfPaperOrientation.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 = PdfPaperOrientation.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
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 = {
				PaperSize = PdfPaperSize.A5,
				PaperOrientation = PdfPaperOrientation.Portrait,
				FitToPaperWidth = True,
				CssMediaType = PdfCssMediaType.Print,
				Margins = New PdfMargins(5, 10, 5, 10)
			}
		}
	End Sub

	' GET /Tickets/Print/42
	Public Async Function Print(ByVal 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 illustriert

  • No temporary files -- the Razor view is rendered in-memory, then passed directly to RenderHtmlAsPdf, avoiding disk I/O and temp-folder race conditions.
  • Ticket-gerechte Ausgabe – PaperSize = A5 und schmale Ränder halten Heimdruck-Tickets kompakt.
  • Konsequente Druckstile – CssMediaType = Print wendet dieselben @media print-CSS-Regeln an, die Browser verwenden.
  • Binärdatenstream – pdf.BinaryData streamt das Dokument, ohne das Dateisystem zu berühren; ideal für API-Endpunkte und Lambda-Funktionen.
  • Wiederverwendbarer Renderer – ChromePdfRenderer wird pro Controller einmal instanziiert und dann wiederverwendet, was den Prozess-Spawn-Overhead minimiert.
id="pdfOptionsAcc">
class="accordion-item">

id="optPaper">

data-bs-parent="#pdfOptionsAcc">
class="accordion-body">

PaperSize, PaperOrientation, FitToPaperWidth

class="accordion-item">

id="optMargins">

data-bs-parent="#pdfOptionsAcc">
class="accordion-body">

Margins, Header, Footer, Watermark

Next step: add encryption, digital signatures, or merge multiple tickets into a single file. See the merge example and the digital-signature how-to.

Wie kann ich Papiergröße, Ränder, Kopfzeilen, Wasserzeichen und Sicherheit vor dem Rendern anpassen?

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

Codebeispiel – Wenden Sie mehrere Optionen gleichzeitig an

// 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 = PdfPaperOrientation.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 = PdfPaperOrientation.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
Imports IronPdf

Private renderer = New ChromePdfRenderer()

' Configure everything in one place
renderer.RenderingOptions = New ChromePdfRenderOptions With {
	.PaperSize = PdfPaperSize.A4,
	.PaperOrientation = PdfPaperOrientation.Portrait,
	.Margins = New PdfMargins With {
		.Top = 20,
		.Bottom = 25,
		.Left = 15,
		.Right = 15
	},
	.CssMediaType = PdfCssMediaType.Print,
	.EnableJavaScript = True,
	.RenderDelay = 200,
	.HtmlHeader = "<header style='font:14px Segoe UI'>Invoice — {{date}}</header>",
	.HtmlFooter = "<footer style='text-align:right;font-size:10px'>Page {{page}} / {{total-pages}}</footer>",
	.Watermark = New HtmlStamp With {
		.HtmlTemplate = "<div style='font-size:50px;color:#cccccc;opacity:0.3;'>CONFIDENTIAL</div>",
		.VerticalAlignment = VerticalAlignment.Center,
		.HorizontalAlignment = HorizontalAlignment.Center
	},
	.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 spiegeln den Druckdialog eines Browsers wider, sodass Bildschirmlayouts und das PDF identisch auf Windows, Linux und Docker bleiben.
  • HTML-Kopf- und Fußzeilen unterstützen Razor-Token, CSS und JavaScript – nützlich für dynamische Seitennummern oder Branding.
  • HtmlStamp lässt sich mit einer einzigen Zeile ein gebrande Wasserzeichen mit voller HTML+CSS-Kontrolle erstellen.
  • Sicherheitsoptionen ermöglichen 128-Bit-Verschlüsselung, Besitzer-/Benutzerpasswörter und granulare Berechtigungen ohne Drittanbieter-Tools.
  • Digitale Signaturen fügen einen kryptografischen Siegel direkt im Code hinzu und bewahren die rechtliche Authentizität und Manipulationsbeweise.
  • Extraktions-Helfer wie ExtractAllText und ExtractAllImages kehren den Prozess um, wenn eine Analyse erforderlich ist.

Schnellreferenz — Beliebte Einstellungen

id="advRenderAcc">
class="accordion-item">

id="layHead">

data-bs-parent="#advRenderAcc">
class="accordion-body">

PaperSize, PaperOrientation, Margins, CssMediaType, RenderDelay

class="accordion-item">

id="headFoot">

data-bs-parent="#advRenderAcc">
class="accordion-body">

HtmlHeader, HtmlFooter, dynamische Razor-Platzhalter, Seitennummer-Token

class="accordion-item">

id="wmHead">

data-bs-parent="#advRenderAcc">
class="accordion-body">

Watermark, HtmlStamp, Deckkraft, Ausrichtung

class="accordion-item">

id="secHead">

data-bs-parent="#advRenderAcc">
class="accordion-body">

SecurityOptions, SignAndStamp, Besitzer-/Benutzerpasswörter, 128-Bit-AES, Zertifikatversiegelung

Nächste Aufgaben: Mehrere PDFs zusammenführen, Text & Bilder extrahieren und an Docker oder serverlos bereitstellen. Fahren Sie mit dem Bereitstellungsabschnitt fort, um plattformübergreifende Kompatibilität sicherzustellen.

Wie kann ich PDF-Erstellungscode in Docker unter Linux und Windows bereitstellen?

IronPDF wird als einzelnes selbstenthaltenes NuGet-Paket geliefert, daher ist das Containerisieren einer ASP.NET Core- (oder Konsolen-App) auf sowohl Windows als auch Linux unkompliziert. Der Schlüssel ist, die veröffentlichten Binärdateien in ein schlankes Laufzeit-Image zu kopieren und unter Linux die beiden nativen Bibliotheken hinzuzufügen, die IronPDF benötigt (libnss3 und libatk1.0-0).

Multi-Stage-Dockerfile (Ubuntu 22.04)

Hinweis:Warum Multi-Stage? Das SDK-Image (Stufe 1) kompiliert das Projekt; das finale Laufzeit-Image (Stufe 2) bleibt schlank – < 120 MB – weil 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 Chromium-DLLs mitgeliefert werden.

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 genau wie in Abschnitt 2 auf.
  • IronPDF startet seinen sandboxed Chromium-Prozess im Container – kein X-Server erforderlich, da es im Headless-Modus rendert.
  • Der Speicherbedarf bleibt auch bei großen Renderings unter 200 MB.

TippsFehlerbehebungstipp: Wenn die Containerprotokolle einen “libnss3.so nicht gefunden”-Fehler anzeigen, stellen Sie sicher, dass sowohl libnss3 als auch libatk1.0-0 vorhanden sind. Alpine-Images werden nicht unterstützt, da die musl C-Bibliothek erforderliche Symbole fehlt.

Interne Ressourcen

Wie kann ich bestehende PDFs in .NET Core öffnen, zusammenführen, mit Wasserzeichen versehen und Inhalte extrahieren?

IronPDF behandelt jedes PDF – ob von IronPDF, Adobe® Acrobat oder Drittanbieter-Tools generiert – als erstklassiges PdfDocument-Objekt, das geöffnet, bearbeitet, gesichert und ohne Qualitätsverlust erneut gespeichert werden kann. Die gleiche API-Oberfläche funktioniert heute auf .NET 8 LTS und kompiliert unverändert auf die .NET 9-Vorschau und das kommende .NET 10-Release.

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 das wichtig ist

  • Öffnen & Zusammenführen – PdfDocument.FromFile lädt jedes standardkonforme PDF, einschließlich verschlüsselter Dateien, während PdfDocument.Merge eine beliebige Anzahl von Dokumenten in einem einzigen Aufruf concatenates.
  • Wasserzeichen – ApplyStamp (Alias HtmlStamp) bettet vollständig gestylte HTML/CSS Overlays – Logo, QR-Code oder diagonalen Text – auf ausgewählten Seiten ein, ohne dass Rastern erforderlich ist.
  • Inhaltsextraktion – ExtractAllText und ExtractAllImages ziehen UTF-8-Rohtext oder binäre Bildströme für nachgelagerte Archivierung oder KI-Pipelines.
  • Digital signaturbereit – dieselbe PdfDocument-Instanz kann mit SignAndStamp versiegelt werden und erzeugt RFC 3161-konforme Hashes, die mit ISO 32000-2-Anforderungen an digitale Signaturen übereinstimmen.
  • Off-Standard-Konformität – IronPDF behält die ursprüngliche PDF-Struktur (Schriften, Ebenen, XMP-Metadaten) bei, sodass die Ausgabe mit Adobe® Reader und anderen ISO 32000-1 Betrachtern kompatibel bleibt.
  • Zukunftssicher – Die API vermeidet Interop-Assemblies und Win32-GDI-Aufrufe, sodass der Code unverändert auf Windows, Linux, Docker und kommenden .NET 10-serverlosen SKUs läuft.

Benötigen Sie Seitenaufteilung, Drehen oder Löschen? Siehe das seitenspezifische Bearbeitungs-Tutorial für granulare Operationen.

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

IronPDF sichert ein Dokument in zwei Schritten: AES-basierte Verschlüsselung (Benutzer-/Besitzerpasswörter + granulare Berechtigungen) und X.509 digitale Signaturen, die die Datei mit einem kryptografischen Hash versiegeln. Beide APIs befinden sich auf demselben PdfDocument-Objekt, sodass der Workflow heute auf .NET 8 LTS identisch ist und unverändert auf .NET 9 Vorschau und das kommende .NET 10-Release kompiliert.

Beispiel — 256-Bit-AES anwenden, Druckrechte 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 umhüllt die Nutzlast mit NIST-geprüften AES-Schlüsseln, blockiert unbefugtes Öffnen, Drucken oder Copy-Paste.
  • Berechtigungsgranularität – Eigenschaften wie AllowUserPrinting und AllowUserFormData schalten Pro-Aktivitätsrechte um; ein Besitzerpasswort ist erforderlich, damit eine Einschränkung wirksam wird.
  • Digitale Signaturen – SignAndStamp bettet einen RFC 3161-Zeitstempel und eine Zertifikatskette ein, wodurch manipulationssichere Hashes erzeugt werden, die von Adobe® Acrobat und anderen ISO 32000-2 Betrachtern erkannt werden.
  • Einheitliche API – sowohl Verschlüsselung als auch Signierung ändern dieselbe PdfDocument-Instanz, vermeiden mehrere Dateipässe und erhalten interne Schriften, Ebenen und Metadaten.

TippsFehlerbehebungstipp: Wenn Adobe Reader “ungültige Signatur” meldet, stellen Sie sicher, dass die PFX ein vertrauenswürdiges Stammzertifikat enthält und die reason/location-Strings sind ASCII-sauber.

Kern-Sicherheitseinstellungen

id="secAcc">
class="accordion-item">

id="encHead">

data-bs-parent="#secAcc">
class="accordion-body">

PdfSecuritySettings → OwnerPassword, UserPassword, EncryptionAlgorithm, AllowUserPrinting

class="accordion-item">

id="sigHead">

data-bs-parent="#secAcc">
class="accordion-body">

PdfDocument.SignAndStamp — PFX-Pfad, Behörde, Standort, Grund, Zeitstempel

Interne Ressourcen for deeper dives

Wie kann die HTML-zu-PDF-Leistung in .NET Core optimiert und skaliert werden?

IronPDFs Chromium-Engine rendert die meisten Seiten bereits in < 1 s auf moderner Hardware, aber der Durchsatz kann durch Batch-Renders, Multithreading und den Abbau von Headless-Chrome-Overhead vervielfacht werden. Die folgenden Tipps gelten gleichermaßen für alle .NET-Versionen.

1. Renderaufgaben im Hintergrund-Threadpool stapeln

// 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. Headless-Chrome-Startkosten trimmen

IronPDF liefert sein eigenes Chromium-Build, aber jeder Render verursacht eine kleine Startsteuer. Pooling hilft, und Linux-Container müssen zwei native libs enthalten: 

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

Wenn eine dieser Bibliotheken fehlt, äußert sich dies als “libnss3.so nicht gefunden”-Fehler in Docker-Protokollen.

Recommended Chrome flags (automatically applied by IronPDF) include --disable-gpu and --no-sandbox to reduce Speicher- und Root-Benutzerproblemen in Containern zu reduzieren.

3. Warten Sie auf späte 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 dedizierte WaitFor-Tutorial für benutzerdefinierte Versprechen und DOM-Abfragen.

4. Debug-Logging 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-Spuren zeigen fehlende Schriftarten, 404-Bilder und Zeitsereignisse ohne erneutes Kompilieren des Codes.

5. PDF-Vorlagen wiederverwenden anstatt neu zu rendern

Für Rechnungsdurchläufe erstellen Sie ein Vorlagen-PDF mit Platzhaltern wie [[name]] und führen Sie einen Textaustausch durch, anstatt komplexes HTML neu zu erstellen. Es ist 10× schneller und speicherschonend.

Schnellabstimmungs-Checkliste

id="perfAcc">
class="accordion-item">

id="threadsHead">

data-bs-parent="#perfAcc">
class="accordion-body">

Parallel.ForEach, async/await, Wiederverwendung eines einzelnen ChromePdfRenderer

class="accordion-item">

id="dockerHead">

data-bs-parent="#perfAcc">
class="accordion-body">

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

class="accordion-item">

id="jsHead">

data-bs-parent="#perfAcc">
class="accordion-body">

RenderDelay, WaitFor(), DevTools-Timeline-Protokoll für langsame SPA-Hydrierungen

Weiterführende Lektüre

Wo kann ich eine kostenlose Testversion herunterladen, eine Lizenz auswählen und Expertenunterstützung finden? {#anchor-10-resources}

A 30-day trial key is issued instantly from the Start Free Trial form and unlocks every feature—including HTML-to-PDF, digital signatures, and encryption—without watermarking.

Nach der Bewertung der Bibliothek wählen Sie eine unbefristete Entwickler-, Bereitstellungs- oder Unternehmens-Lizenz; jeder Plan beinhaltet kostenlose kleinere Updates, Nutzungsrechte für Entwicklung/Test/Produktion und eine 30-tägige Geld-zurück-Garantie. Die Anwendung des Schlüssels ist eine einzelne Zeile Code (IronPdf.License.LicenseKey = "YOUR-KEY";) und kann in CI/CD-Pipelines automatisiert werden.

Comprehensive documentation—quick-start guides, API reference, and tutorial videos—lives at the docs portal and is updated for every .NET release.

Engineering questions receive one-business-day responses via live chat, email, or phone from the Chicago-based support team.

Leistungsoptimierung und Bereitstellungs-FAQs sind im Performance Assistance Centre zusammengefasst.

Ressource URL Warum es wichtig ist
Erhalten Sie einen 30-tägigen Testschlüssel https://ironpdf.com/demos/ Schaltet alle Funktionen ohne Wasserzeichen frei
Lizenzierung & Preisgestaltung https://ironpdf.com/licensing/ Unbefristete oder Abonnementpläne; 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
Performance-Unterstützung https://ironpdf.com/troubleshooting/ironpdf-performance-assistance/ Optimierungs- und Skalierungstipps
Kontaktiere den Support https://ironsoftware.com/contact-us/ Live-Chat, E-Mail, Telefonsupport

Nächste Schritte

  1. Klone das Beispiel-Repo, das jede Hauptfunktion demonstriert—von MVC-Ansicht-Rendering bis hin zu AES-256-Verschlüsselung.
  2. Probeschlüssel einstecken in eine bestehende Lösung und die Modultests ausführen, um plattformübergreifende Kompatibilität zu validieren.
  3. Buchen Sie eine Live-Demo mit dem Engineering-Team für projektspezifische Empfehlungen.

Mit diesen Ressourcen in der Hand kann jedes .NET-Team pixelgenaue PDFs in der Produktion bereitstellen—on-prem, in Docker oder serverlos—innerhalb eines einzigen Sprints.

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 führend in der C# PDF-Technologie ist. Als ursprünglicher Entwickler der Iron Software-Kerncodebasis hat er die Produktarchitektur des Unternehmens seit seiner Gründung gestaltet und zusammen mit CEO Cameron Rimington in ein Unternehmen ...

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 16,154,058 | Version: 2025.11 gerade veröffentlicht