Wie man HTML zu PDF in C# konvertiert (Entwicklerleitfaden)

Wie man HTML-String zu PDF konvertiert

using IronPdf;

// Create the Chrome renderer
var renderer = new ChromePdfRenderer();

// Convert HTML string to PDF
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello IronPdf</h1>");

// Save the PDF
pdf.SaveAs("output.pdf");

using IronPdf;

// Create the Chrome renderer
var renderer = new ChromePdfRenderer();

// Convert HTML string to PDF
var pdf = renderer.RenderHtmlAsPdf("<h1>Hello IronPdf</h1>");

// Save the PDF
pdf.SaveAs("output.pdf");

Imports IronPdf

' Create the Chrome renderer
Dim renderer As New ChromePdfRenderer()

' Convert HTML string to PDF
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Hello IronPdf</h1>")

' Save the PDF
pdf.SaveAs("output.pdf")

using IronPdf;

var renderer = new ChromePdfRenderer();

// Convert HTML content with local image and CSS references
string html = @"
    <link rel='stylesheet' href='styles.css'>
    <img src='logo.png' alt='Company Logo'>
    <h1>Company Report</h1>
    <p>Annual report content...</p>";

// Set base path for resolving relative URLs in HTML to PDF conversion
var pdf = renderer.RenderHtmlAsPdf(html, @"C:\MyProject\Assets\");
pdf.SaveAs("report.pdf");

using IronPdf;

var renderer = new ChromePdfRenderer();

// Convert HTML content with local image and CSS references
string html = @"
    <link rel='stylesheet' href='styles.css'>
    <img src='logo.png' alt='Company Logo'>
    <h1>Company Report</h1>
    <p>Annual report content...</p>";

// Set base path for resolving relative URLs in HTML to PDF conversion
var pdf = renderer.RenderHtmlAsPdf(html, @"C:\MyProject\Assets\");
pdf.SaveAs("report.pdf");

Imports IronPdf

Dim renderer As New ChromePdfRenderer()

' Convert HTML content with local image and CSS references
Dim html As String = "
    <link rel='stylesheet' href='styles.css'>
    <img src='logo.png' alt='Company Logo'>
    <h1>Company Report</h1>
    <p>Annual report content...</p>"

' Set base path for resolving relative URLs in HTML to PDF conversion
Dim pdf = renderer.RenderHtmlAsPdf(html, "C:\MyProject\Assets\")
pdf.SaveAs("report.pdf")

Wie man eine bestehende URL in PDF exportiert

Das Rendern ganzer Webseiten zu PDFs mit C# ermöglicht es Teams, PDF-Design und Backend-Rendering-Arbeiten zu trennen. Dieser Ansatz ermöglicht es Ihnen, jede angegebene URL direkt in das PDF-Format zu konvertieren.

Print vs. Screen CSS

Sie können IronPDF so konfigurieren, dass es mit jedem CSS-Medientyp rendert.

using IronPdf;
using IronPdf.Rendering;

// Initialize HTML to PDF converter
var renderer = new ChromePdfRenderer();

// Configure CSS media type for rendering specified URLs
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;

// Screen media type shows the entire web page as displayed on screen

using IronPdf;
using IronPdf.Rendering;

// Initialize HTML to PDF converter
var renderer = new ChromePdfRenderer();

// Configure CSS media type for rendering specified URLs
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;

// Screen media type shows the entire web page as displayed on screen

Imports IronPdf
Imports IronPdf.Rendering

' Initialize HTML to PDF converter
Dim renderer As New ChromePdfRenderer()

' Configure CSS media type for rendering specified URLs
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print

' Screen media type shows the entire web page as displayed on screen

JavaScript-Unterstützung

IronPDF unterstützt JavaScript, jQuery und sogar AJAX vollständig, wenn Sie HTML in PDF konvertieren. Für dynamische HTML-Inhalte können Sie IronPDF so konfigurieren, dass es auf den Abschluss von JavaScript wartet, bevor es Webseiten in PDF rendert. Dies ist perfekt für Single-Page-Anwendungen und dynamische Websites.

using IronPdf;

// Configure JavaScript rendering for dynamic HTML content to PDF
var renderer = new ChromePdfRenderer();

// Enable JavaScript execution during PDF generation
renderer.RenderingOptions.EnableJavaScript = true;

// WaitFor.RenderDelay pauses before capturing the HTML
renderer.RenderingOptions.WaitFor.RenderDelay = 500; // milliseconds

using IronPdf;

// Configure JavaScript rendering for dynamic HTML content to PDF
var renderer = new ChromePdfRenderer();

// Enable JavaScript execution during PDF generation
renderer.RenderingOptions.EnableJavaScript = true;

// WaitFor.RenderDelay pauses before capturing the HTML
renderer.RenderingOptions.WaitFor.RenderDelay = 500; // milliseconds

Imports IronPdf

' Configure JavaScript rendering for dynamic HTML content to PDF
Dim renderer As New ChromePdfRenderer()

' Enable JavaScript execution during PDF generation
renderer.RenderingOptions.EnableJavaScript = True

' WaitFor.RenderDelay pauses before capturing the HTML
renderer.RenderingOptions.WaitFor.RenderDelay = 500 ' milliseconds

Die JavaScript-Ausführung kann auch angezeigt werden, wenn ein fortgeschrittener d3.js-Akkord-Diagramm von einer Webseite in das PDF-Format gerendert wird:

using IronPdf;

// Create renderer for JavaScript-heavy HTML
var renderer = new ChromePdfRenderer();

// Convert d3.js visualization web page to PDF
var pdf = renderer.RenderUrlAsPdf("https://bl.ocks.org/mbostock/4062006");

// Save the interactive chart as static PDF
pdf.SaveAs("chart.pdf");

using IronPdf;

// Create renderer for JavaScript-heavy HTML
var renderer = new ChromePdfRenderer();

// Convert d3.js visualization web page to PDF
var pdf = renderer.RenderUrlAsPdf("https://bl.ocks.org/mbostock/4062006");

// Save the interactive chart as static PDF
pdf.SaveAs("chart.pdf");

Imports IronPdf

' Create renderer for JavaScript-heavy HTML
Dim renderer As New ChromePdfRenderer()

' Convert d3.js visualization web page to PDF
Dim pdf = renderer.RenderUrlAsPdf("https://bl.ocks.org/mbostock/4062006")

' Save the interactive chart as static PDF
pdf.SaveAs("chart.pdf")

Responsive CSS

Da responsive Webseiten für die Anzeige in einem Browser konzipiert sind und IronPDF kein echtes Browserfenster im Betriebssystem Ihres Servers öffnet, werden responsive HTML-Elemente möglicherweise in ihrer kleinsten Größe gerendert. PdfCssMediaType.Print wird empfohlen, um dieses Problem beim Rendern ganzer Webseiten zu umgehen.

// Configure for optimal responsive design handling in HTML to PDF

renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;

// Configure for optimal responsive design handling in HTML to PDF

renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;

```vbnet
' Configure for optimal responsive design handling in HTML to PDF

renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print
```

VERWANDTER HOW-TO-ARTIKEL: Wie man URL zu PDF rendert

Wie man HTML-Datei zu PDF konvertiert

using IronPdf;

// Initialize ChromePdfRenderer for HTML file conversion
var renderer = new ChromePdfRenderer();

// Convert HTML file to PDF documents
// Preserves all relative paths and linked resources in HTML
var pdf = renderer.RenderHtmlFileAsPdf("Assets/TestInvoice1.html");

// Save the HTML file as PDF 
pdf.SaveAs("Invoice.pdf");

// All CSS, JavaScript, and images load correctly in the generated PDF

using IronPdf;

// Initialize ChromePdfRenderer for HTML file conversion
var renderer = new ChromePdfRenderer();

// Convert HTML file to PDF documents
// Preserves all relative paths and linked resources in HTML
var pdf = renderer.RenderHtmlFileAsPdf("Assets/TestInvoice1.html");

// Save the HTML file as PDF 
pdf.SaveAs("Invoice.pdf");

// All CSS, JavaScript, and images load correctly in the generated PDF

Imports IronPdf

' Initialize ChromePdfRenderer for HTML file conversion
Dim renderer As New ChromePdfRenderer()

' Convert HTML file to PDF documents
' Preserves all relative paths and linked resources in HTML
Dim pdf = renderer.RenderHtmlFileAsPdf("Assets/TestInvoice1.html")

' Save the HTML file as PDF 
pdf.SaveAs("Invoice.pdf")

' All CSS, JavaScript, and images load correctly in the generated PDF

So konvertieren Sie Razor Pages in PDF

Wenn Ihr ASP.NET Core Projekt bereits Razor Pages verwendet, können Sie diese direkt in PDF konvertieren, ohne Ihr HTML neu zu erstellen. Die Razor-Erweiterung von IronPDF fügt die Methode RenderRazorToPdf hinzu, die Ihre .cshtml-Seite – komplett mit Modell und Layout – in einem einzigen Aufruf als PDF-Dokument rendert.

PM > Install-Paket IronPdf.Extensions.Razor

PM > Install-Paket IronPdf.Extensions.Razor

using IronPdf;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.RazorPages;

public class ReportModel : PageModel
{
    public IActionResult OnGet()
    {
        var renderer = new ChromePdfRenderer();

        // Render a Razor Page directly to PDF
        PdfDocument pdf = renderer.RenderRazorToPdf(this);

        Response.Headers.Add("Content-Disposition", "inline");
        return new FileContentResult(pdf.BinaryData, "application/pdf");
    }
}

using IronPdf;
using Microsoft.AspNetCore.Mvc;
using Microsoft.AspNetCore.Mvc.RazorPages;

public class ReportModel : PageModel
{
    public IActionResult OnGet()
    {
        var renderer = new ChromePdfRenderer();

        // Render a Razor Page directly to PDF
        PdfDocument pdf = renderer.RenderRazorToPdf(this);

        Response.Headers.Add("Content-Disposition", "inline");
        return new FileContentResult(pdf.BinaryData, "application/pdf");
    }
}

Imports IronPdf
Imports Microsoft.AspNetCore.Mvc
Imports Microsoft.AspNetCore.Mvc.RazorPages

Public Class ReportModel
    Inherits PageModel

    Public Function OnGet() As IActionResult
        Dim renderer As New ChromePdfRenderer()

        ' Render a Razor Page directly to PDF
        Dim pdf As PdfDocument = renderer.RenderRazorToPdf(Me)

        Response.Headers.Add("Content-Disposition", "inline")
        Return New FileContentResult(pdf.BinaryData, "application/pdf")
    End Function
End Class

VERWANDTER ANLEITUNGSARTIKEL: So konvertieren Sie CSHTML in Razor Pages in PDF

Wie man MVC-Ansichten in PDF konvertiert

Teams, die das MVC-Muster verwenden, können PDFs direkt aus ihren bestehenden Views und Controllern generieren. Installieren Sie das MVC Core-Erweiterungspaket und rufen Sie dann RenderRazorViewToPdf mit Ihrem View-Pfad und Ihrem Modell auf – IronPDF übernimmt die Razor-Rendering-Pipeline und gibt ein fertiges PDF aus.

Dies ist besonders nützlich für Berichte, Rechnungen und alle Seiten, deren HTML-Code bereits im Browser entworfen und getestet wurde. Die generierte PDF-Datei bewahrt die vollständige Ansichtsausgabe, einschließlich Layoutseiten und Teilansichten.

PM > Install-Paket IronPdf.Extensions.Mvc.Co/re

PM > Install-Paket IronPdf.Extensions.Mvc.Co/re

Registrieren Sie zunächst den Dienst IRazorViewRenderer in Ihrer Program.cs, damit Ihre Controller ihn einbinden können:

using IronPdf.Extensions.Mvc.Co/re;

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

// Register the Razor view renderer for IronPDF
builder.Services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();
builder.Services.AddSingleton<IRazorViewRenderer, RazorViewRenderer>();

using IronPdf.Extensions.Mvc.Co/re;

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

// Register the Razor view renderer for IronPDF
builder.Services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();
builder.Services.AddSingleton<IRazorViewRenderer, RazorViewRenderer>();

Imports IronPdf.Extensions.Mvc.Core

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

' Register the Razor view renderer for IronPDF
builder.Services.AddSingleton(Of IHttpContextAccessor, HttpContextAccessor)()
builder.Services.AddSingleton(Of IRazorViewRenderer, RazorViewRenderer)()

Anschließend können Sie in Ihrer Controller-Aktion den Renderer einbinden und jede Ansicht in ein PDF konvertieren:

using IronPdf;
using IronPdf.Extensions.Mvc.Co/re;
using Microsoft.AspNetCore.Mvc;

public class ReportController : Controller
{
    private readonly IRazorViewRenderer _viewRenderService;

    // Inject the view renderer via constructor
    public ReportController(IRazorViewRenderer viewRenderService)
    {
        _viewRenderService = viewRenderService;
    }

    public IActionResult Download()
    {
        var reportModel = new { Title = "Quarterly Report", Total = 1250.00 };
        var renderer = new ChromePdfRenderer();

        // Render an MVC View with model data to PDF
        PdfDocument pdf = renderer.RenderRazorViewToPdf(
            _viewRenderService, "Views/Home/Report.cshtml", reportModel);

        Response.Headers.Add("Content-Disposition", "inline");
        return new FileContentResult(pdf.BinaryData, "application/pdf");
    }
}

using IronPdf;
using IronPdf.Extensions.Mvc.Co/re;
using Microsoft.AspNetCore.Mvc;

public class ReportController : Controller
{
    private readonly IRazorViewRenderer _viewRenderService;

    // Inject the view renderer via constructor
    public ReportController(IRazorViewRenderer viewRenderService)
    {
        _viewRenderService = viewRenderService;
    }

    public IActionResult Download()
    {
        var reportModel = new { Title = "Quarterly Report", Total = 1250.00 };
        var renderer = new ChromePdfRenderer();

        // Render an MVC View with model data to PDF
        PdfDocument pdf = renderer.RenderRazorViewToPdf(
            _viewRenderService, "Views/Home/Report.cshtml", reportModel);

        Response.Headers.Add("Content-Disposition", "inline");
        return new FileContentResult(pdf.BinaryData, "application/pdf");
    }
}

Imports IronPdf
Imports IronPdf.Extensions.Mvc.Core
Imports Microsoft.AspNetCore.Mvc

Public Class ReportController
    Inherits Controller

    Private ReadOnly _viewRenderService As IRazorViewRenderer

    ' Inject the view renderer via constructor
    Public Sub New(viewRenderService As IRazorViewRenderer)
        _viewRenderService = viewRenderService
    End Sub

    Public Function Download() As IActionResult
        Dim reportModel = New With {.Title = "Quarterly Report", .Total = 1250.0}
        Dim renderer = New ChromePdfRenderer()

        ' Render an MVC View with model data to PDF
        Dim pdf As PdfDocument = renderer.RenderRazorViewToPdf(_viewRenderService, "Views/Home/Report.cshtml", reportModel)

        Response.Headers.Add("Content-Disposition", "inline")
        Return New FileContentResult(pdf.BinaryData, "application/pdf")
    End Function
End Class

VERWANDTER ANLEITUNGSARTIKEL: So konvertieren Sie Ansichten in ASP.NET Core MVC in PDF

So legen Sie benutzerdefinierte HTTP-Header, Cookies und Anmeldeinformationen fest

Beim Rendern von URLs, die eine Authentifizierung oder spezifische Anfragemetadaten erfordern, ermöglicht IronPDF das Einbinden von Anmeldeinformationen, Session-Cookies und HTTP-Headern in die Anfrage. Dadurch können Intranet-Dashboards, eingeschränkte Berichte oder API-generierte Seiten direkt als PDF gerendert werden, ohne dass der HTML-Code separat abgerufen werden muss.

Für die Basis- oder NTLM-Authentifizierung setzen Sie ein LoginCredentials-Objekt auf dem Renderer. Für tokenbasierten oder sitzungsbasierten Zugriff übergeben Sie Cookies und Header über RenderingOptions, bevor Sie RenderUrlAsPdf aufrufen.

using IronPdf;

var renderer = new ChromePdfRenderer();

// Network authentication (Basic, Digest, NTLM)
renderer.LoginCredentials = new ChromeHttpLoginCredentials
{
    NetworkUsername = "user@domain.com",
    NetworkPassword = "securePassword"
};

// Session cookies for authenticated pages
renderer.RenderingOptions.CustomCookies["sessionId"] = "abc123";

// Custom HTTP headers (e.g., Bearer tokens, API keys)
renderer.RenderingOptions.CustomHttpRequestHeaders["Authorization"] = "Bearer eyJhbGciOi...";

var pdf = renderer.RenderUrlAsPdf("https://intranet.com/pany.com/quarterly-report");
pdf.SaveAs("quarterly-report.pdf");

using IronPdf;

var renderer = new ChromePdfRenderer();

// Network authentication (Basic, Digest, NTLM)
renderer.LoginCredentials = new ChromeHttpLoginCredentials
{
    NetworkUsername = "user@domain.com",
    NetworkPassword = "securePassword"
};

// Session cookies for authenticated pages
renderer.RenderingOptions.CustomCookies["sessionId"] = "abc123";

// Custom HTTP headers (e.g., Bearer tokens, API keys)
renderer.RenderingOptions.CustomHttpRequestHeaders["Authorization"] = "Bearer eyJhbGciOi...";

var pdf = renderer.RenderUrlAsPdf("https://intranet.com/pany.com/quarterly-report");
pdf.SaveAs("quarterly-report.pdf");

Imports IronPdf

Dim renderer As New ChromePdfRenderer()

' Network authentication (Basic, Digest, NTLM)
renderer.LoginCredentials = New ChromeHttpLoginCredentials With {
    .NetworkUsername = "user@domain.com",
    .NetworkPassword = "securePassword"
}

' Session cookies for authenticated pages
renderer.RenderingOptions.CustomCookies("sessionId") = "abc123"

' Custom HTTP headers (e.g., Bearer tokens, API keys)
renderer.RenderingOptions.CustomHttpRequestHeaders("Authorization") = "Bearer eyJhbGciOi..."

Dim pdf = renderer.RenderUrlAsPdf("https://intranet.com/pany.com/quarterly-report")
pdf.SaveAs("quarterly-report.pdf")

VERWANDTE ANLEITUNGSARTIKEL: PDFs hinter Anmeldeauthentifizierung rendern | Benutzerdefinierte HTTP-Anfrageheader

So konfigurieren Sie einen Proxy für die PDF-Darstellung

Beim Rendern von HTML, das externe Ressourcen hinter einem Unternehmensproxy lädt, übergeben Sie die Proxy-Adresse als dritten Parameter an RenderHtmlAsPdf(). Dies ist ein Methodenparameter, keine Eigenschaft von ChromePdfRenderOptions – er wird also pro Render-Aufruf gesetzt, nicht auf der Renderer-Instanz.

Bei authentifizierten Proxys sind die Anmeldedaten direkt in die URL im Format http://user:pass@host:port einzubetten. Sonderzeichen in Passwörtern mit Uri.EscapeDataString() URL-kodieren.

using IronPdf;

var renderer = new ChromePdfRenderer();

// Proxy is the third parameter — not a render option
PdfDocument pdf = renderer.RenderHtmlAsPdf(
    "<h1>Report</h1><link rel='stylesheet' href='https://cdn.example.com/styles.css'>",
    baseUrlOrPath: null,
    proxy: "http://proxy.co/rp.local:8080"
);
pdf.SaveAs("proxied-report.pdf");

using IronPdf;

var renderer = new ChromePdfRenderer();

// Proxy is the third parameter — not a render option
PdfDocument pdf = renderer.RenderHtmlAsPdf(
    "<h1>Report</h1><link rel='stylesheet' href='https://cdn.example.com/styles.css'>",
    baseUrlOrPath: null,
    proxy: "http://proxy.co/rp.local:8080"
);
pdf.SaveAs("proxied-report.pdf");

Imports IronPdf

Dim renderer As New ChromePdfRenderer()

' Proxy is the third parameter — not a render option
Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(
    "<h1>Report</h1><link rel='stylesheet' href='https://cdn.example.com/styles.css'>",
    baseUrlOrPath:=Nothing,
    proxy:="http://proxy.co/rp.local:8080"
)
pdf.SaveAs("proxied-report.pdf")

Beachten Sie, dass RenderUrlAsPdf() keinen Proxy-Parameter akzeptiert. Um eine Live-URL hinter einem Proxy darzustellen, rufen Sie zunächst den HTML-Code mit HttpClient ab, das mit einem WebProxy konfiguriert ist, und übergeben Sie ihn dann an RenderHtmlAsPdf() mit dem Proxy-Parameter zum Laden der Assets.

VERWANDTER ANLEITUNGSARTIKEL: So konfigurieren Sie Proxy-Server für die PDF-Darstellung

Wie man eine HTML-Vorlage für Batch-PDF-Erstellung generiert

Einfaches Batching von PDF-Erstellung

Batch-PDF-Erstellung ist unerlässlich für das effiziente Erzeugen mehrerer personalisierter PDF-Dokumente. Für grundlegende Szenarien eignet sich die Methode String.Format in C# am besten für einfache PDF-Bearbeitung.

// Simple HTML templating with String.Format
string htmlTemplate = String.Format("<h1>Hello {0}!</h1>", "World");

// Results in HTML content: <h1>Hello World!</h1>

// Simple HTML templating with String.Format
string htmlTemplate = String.Format("<h1>Hello {0}!</h1>", "World");

// Results in HTML content: <h1>Hello World!</h1>

' Simple HTML templating with String.Format
Dim htmlTemplate As String = String.Format("<h1>Hello {0}!</h1>", "World")

' Results in HTML content: <h1>Hello World!</h1>

Für längere Vorlagen, wenn Sie PDF-Dokumente generieren müssen, verwenden Sie Platzhalterersetzung in Ihren HTML-Inhalten:

using IronPdf;

// Define reusable HTML template for PDF files
var htmlTemplate = "<p>Dear [[NAME]],</p><p>Thank you for your order.</p>";

// Customer names for batch PDF conversion processing
var names = new[] { "John", "James", "Jenny" };

// Create personalized PDF documents for each customer
var renderer = new ChromePdfRenderer();

foreach (var name in names)
{
    // Replace placeholder with actual data in HTML string
    var htmlInstance = htmlTemplate.Replace("[[NAME]]", name);

    // Generate personalized PDF document from HTML content
    var pdf = renderer.RenderHtmlAsPdf(htmlInstance);

    // Save with customer-specific filename as PDF files
    pdf.SaveAs($"{name}-invoice.pdf");
}

using IronPdf;

// Define reusable HTML template for PDF files
var htmlTemplate = "<p>Dear [[NAME]],</p><p>Thank you for your order.</p>";

// Customer names for batch PDF conversion processing
var names = new[] { "John", "James", "Jenny" };

// Create personalized PDF documents for each customer
var renderer = new ChromePdfRenderer();

foreach (var name in names)
{
    // Replace placeholder with actual data in HTML string
    var htmlInstance = htmlTemplate.Replace("[[NAME]]", name);

    // Generate personalized PDF document from HTML content
    var pdf = renderer.RenderHtmlAsPdf(htmlInstance);

    // Save with customer-specific filename as PDF files
    pdf.SaveAs($"{name}-invoice.pdf");
}

Imports IronPdf

' Define reusable HTML template for PDF files
Dim htmlTemplate As String = "<p>Dear [[NAME]],</p><p>Thank you for your order.</p>"

' Customer names for batch PDF conversion processing
Dim names As String() = {"John", "James", "Jenny"}

' Create personalized PDF documents for each customer
Dim renderer As New ChromePdfRenderer()

For Each name In names
    ' Replace placeholder with actual data in HTML string
    Dim htmlInstance As String = htmlTemplate.Replace("[[NAME]]", name)

    ' Generate personalized PDF document from HTML content
    Dim pdf = renderer.RenderHtmlAsPdf(htmlInstance)

    ' Save with customer-specific filename as PDF files
    pdf.SaveAs($"{name}-invoice.pdf")
Next

HTML zu PDF-Vorlage mit Handlebars.NET

Verwenden Sie bei komplexen Vorlagen mit Schleifen und Bedingungen beim Konvertieren von HTML in PDF die erweiterte Vorlagenfunktion mit Handlebars.NET, um PDF-Dokumente mit dynamischen HTML-Inhalten zu erstellen.

# First, install Handlebars.NET for HTML to PDF templating
PM > Install-Paket Handlebars.NET

# First, install Handlebars.NET for HTML to PDF templating
PM > Install-Paket Handlebars.NET

using HandlebarsDotNet;
using IronPdf;

// Define Handlebars template with placeholders for HTML content
var source = 
    @"<div class=""entry"">
        <h1>{{title}}</h1>
        <div class=""body"">
            {{body}}
        </div>
    </div>";

// Compile template for reuse in PDF conversion
var template = Handlebars.Com/pile(source);

// Create data object (can be database records) for HTML to PDF directly
var data = new { 
    title = "Monthly Report", 
    body = "Sales increased by 15% this month." 
};

// Merge template with data to create HTML content
var htmlResult = template(data);

// Convert templated HTML to PDF using the PDF converter
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(htmlResult);

pdf.SaveAs("monthly-report.pdf");

using HandlebarsDotNet;
using IronPdf;

// Define Handlebars template with placeholders for HTML content
var source = 
    @"<div class=""entry"">
        <h1>{{title}}</h1>
        <div class=""body"">
            {{body}}
        </div>
    </div>";

// Compile template for reuse in PDF conversion
var template = Handlebars.Com/pile(source);

// Create data object (can be database records) for HTML to PDF directly
var data = new { 
    title = "Monthly Report", 
    body = "Sales increased by 15% this month." 
};

// Merge template with data to create HTML content
var htmlResult = template(data);

// Convert templated HTML to PDF using the PDF converter
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(htmlResult);

pdf.SaveAs("monthly-report.pdf");

Imports HandlebarsDotNet
Imports IronPdf

' Define Handlebars template with placeholders for HTML content
Dim source As String = 
    "<div class=""entry"">
        <h1>{{title}}</h1>
        <div class=""body"">
            {{body}}
        </div>
    </div>"

' Compile template for reuse in PDF conversion
Dim template = Handlebars.Compile(source)

' Create data object (can be database records) for HTML to PDF directly
Dim data = New With { 
    .title = "Monthly Report", 
    .body = "Sales increased by 15% this month." 
}

' Merge template with data to create HTML content
Dim htmlResult = template(data)

' Convert templated HTML to PDF using the PDF converter
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(htmlResult)

pdf.SaveAs("monthly-report.pdf")

VERWANDTER HOW-TO-Artikell: Erfahren Sie mehr über Handlebars.NET auf GitHub

<!DOCTYPE html>
<html>
  <head>
    <style type="text/css" media="print">
      .page {
        page-break-after: always;
        page-break-inside: avoid;
      }
    </style>
  </head>
  <body>
    <div class="page">
      <h1>Page 1 Content</h1>
    </div>
    <div class="page">
      <h1>Page 2 Content</h1>
    </div>
    <div class="page">
      <h1>Page 3 Content</h1>
    </div>
  </body>
</html>

<!DOCTYPE html>
<html>
  <head>
    <style type="text/css" media="print">
      .page {
        page-break-after: always;
        page-break-inside: avoid;
      }
    </style>
  </head>
  <body>
    <div class="page">
      <h1>Page 1 Content</h1>
    </div>
    <div class="page">
      <h1>Page 2 Content</h1>
    </div>
    <div class="page">
      <h1>Page 3 Content</h1>
    </div>
  </body>
</html>

Wie man PDF mit der Async-Methode generiert

IronPDF liefert Enterprise-Performance mit voller Async- und Multithreading-Unterstützung für Ihre Anforderungen an die HTML-zu-PDF-Konvertierung, wenn Sie PDF-Dateien in großem Maßstab erzeugen müssen.

using IronPdf;
using System.Co/llections.Generic;
using System.Linq;
using System.Threading.Tasks;

public class PdfGenerationService
{
    // Async method for non-blocking PDF generation from HTML content
    public async Task<byte[]> GeneratePdfAsync(string html)
    {
        var renderer = new ChromePdfRenderer();

        // Async HTML to PDF conversion preserves thread pool
        var pdf = await renderer.RenderHtmlAsPdfAsync(html);

        // Return PDF files as byte array for web responses
        return pdf.BinaryData;
    }

    // Concurrent batch PDF generation for multiple HTML strings
    public async Task GenerateMultiplePdfsAsync(List<string> htmlVorlagen)
    {
        var renderer = new ChromePdfRenderer();

        // Create parallel conversion tasks to generate PDF documents
        var tasks = htmlVorlagen.Select(html =>
            renderer.RenderHtmlAsPdfAsync(html)
        );

        // Await all PDF conversions simultaneously
        var pdfs = await Task.WhenAll(tasks);

        // Save generated PDF files from HTML content
        for (int i = 0; i < pdfs.Length; i++)
        {
            pdfs[i].SaveAs($"document-{i}.pdf");
        }
    }
}

using IronPdf;
using System.Co/llections.Generic;
using System.Linq;
using System.Threading.Tasks;

public class PdfGenerationService
{
    // Async method for non-blocking PDF generation from HTML content
    public async Task<byte[]> GeneratePdfAsync(string html)
    {
        var renderer = new ChromePdfRenderer();

        // Async HTML to PDF conversion preserves thread pool
        var pdf = await renderer.RenderHtmlAsPdfAsync(html);

        // Return PDF files as byte array for web responses
        return pdf.BinaryData;
    }

    // Concurrent batch PDF generation for multiple HTML strings
    public async Task GenerateMultiplePdfsAsync(List<string> htmlVorlagen)
    {
        var renderer = new ChromePdfRenderer();

        // Create parallel conversion tasks to generate PDF documents
        var tasks = htmlVorlagen.Select(html =>
            renderer.RenderHtmlAsPdfAsync(html)
        );

        // Await all PDF conversions simultaneously
        var pdfs = await Task.WhenAll(tasks);

        // Save generated PDF files from HTML content
        for (int i = 0; i < pdfs.Length; i++)
        {
            pdfs[i].SaveAs($"document-{i}.pdf");
        }
    }
}

Imports IronPdf
Imports System.Collections.Generic
Imports System.Linq
Imports System.Threading.Tasks

Public Class PdfGenerationService
    ' Async method for non-blocking PDF generation from HTML content
    Public Async Function GeneratePdfAsync(html As String) As Task(Of Byte())
        Dim renderer As New ChromePdfRenderer()

        ' Async HTML to PDF conversion preserves thread pool
        Dim pdf = Await renderer.RenderHtmlAsPdfAsync(html)

        ' Return PDF files as byte array for web responses
        Return pdf.BinaryData
    End Function

    ' Concurrent batch PDF generation for multiple HTML strings
    Public Async Function GenerateMultiplePdfsAsync(htmlVorlagen As List(Of String)) As Task
        Dim renderer As New ChromePdfRenderer()

        ' Create parallel conversion tasks to generate PDF documents
        Dim tasks = htmlVorlagen.Select(Function(html) renderer.RenderHtmlAsPdfAsync(html))

        ' Await all PDF conversions simultaneously
        Dim pdfs = Await Task.WhenAll(tasks)

        ' Save generated PDF files from HTML content
        For i As Integer = 0 To pdfs.Length - 1
            pdfs(i).SaveAs($"document-{i}.pdf")
        Next
    End Function
End Class

• Verwenden Sie 64-Bit-Systeme für optimale PDF-Erzeugungsleistung.
• Sorgen Sie für ausreichende Serverressourcen, wenn Sie PDF-Dokumente generieren (vermeiden Sie unzureichende Gratisangebote)
• Gewähren Sie ausreichende RenderDelay für komplexes JavaScript in HTML-Inhalten.
• Verwenden Sie ChromePdfRenderer-Instanzen nach Möglichkeit wieder.
• Nutzen Sie die Speicheroptimierungen von v2025.9.4 für Batch-Operationen zur Reduzierung der Ressourcennutzung; testen Sie für reduzierte Dateigrößen mit wiederkehrenden benutzerdefinierten Kopf-/Fußzeilen.

VERBUNDENE HOW-TO-Artikel: Wie man PDFs mit Async und Multithreading erzeugt

Wie man erweiterte Sicherheitsfunktionen hinzufügt

Wie man PDF-Dateien in .NET mit einem Passwort schützt

Schützen Sie empfindliche generierte PDF-Dokumente mit Passwörtern und Berechtigungen, wenn Sie HTML-Inhalte in geschütztes PDF-Format konvertieren.

using IronPdf;
var renderer = new ChromePdfRenderer();

// Convert HTML to PDF with security
var pdf = renderer.RenderHtmlAsPdf("<h1>Confidential Report</h1>");

// Configure security settings for PDF files
pdf.SecuritySettings.UserPassword = "user123";     // Password to open PDF documents
pdf.SecuritySettings.OwnerPassword = "owner456";   // Password to modify PDF files

// Set granular permissions for PDF format
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
pdf.SecuritySettings.AllowUserAnnotations = false;
pdf.SecuritySettings.AllowUserPrinting = PrintPermissions.LowQualityPrint;

// Apply strong encryption to PDF documents
pdf.SecuritySettings.EncryptionAlgorithm = PdfEncryptionAlgorithm.AES256;
pdf.SaveAs("secure-document.pdf");

using IronPdf;
var renderer = new ChromePdfRenderer();

// Convert HTML to PDF with security
var pdf = renderer.RenderHtmlAsPdf("<h1>Confidential Report</h1>");

// Configure security settings for PDF files
pdf.SecuritySettings.UserPassword = "user123";     // Password to open PDF documents
pdf.SecuritySettings.OwnerPassword = "owner456";   // Password to modify PDF files

// Set granular permissions for PDF format
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
pdf.SecuritySettings.AllowUserAnnotations = false;
pdf.SecuritySettings.AllowUserPrinting = PrintPermissions.LowQualityPrint;

// Apply strong encryption to PDF documents
pdf.SecuritySettings.EncryptionAlgorithm = PdfEncryptionAlgorithm.AES256;
pdf.SaveAs("secure-document.pdf");

Imports IronPdf

Dim renderer As New ChromePdfRenderer()

' Convert HTML to PDF with security
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Confidential Report</h1>")

' Configure security settings for PDF files
pdf.SecuritySettings.UserPassword = "user123"     ' Password to open PDF documents
pdf.SecuritySettings.OwnerPassword = "owner456"   ' Password to modify PDF files

' Set granular permissions for PDF format
pdf.SecuritySettings.AllowUserCopyPasteContent = False
pdf.SecuritySettings.AllowUserAnnotations = False
pdf.SecuritySettings.AllowUserPrinting = PrintPermissions.LowQualityPrint

' Apply strong encryption to PDF documents
pdf.SecuritySettings.EncryptionAlgorithm = PdfEncryptionAlgorithm.AES256
pdf.SaveAs("secure-document.pdf")

Wie man digitale Signaturen zu PDF-Dateien hinzufügt

Fügen Sie kryptografische Signaturen hinzu, um die Echtheit von PDF-Dokumenten zu gewährleisten, wenn Sie PDF-Dateien aus HTML-Inhalten generieren.

using IronPdf;
using IronPdf.Signing;

var renderer = new ChromePdfRenderer();

// Generate PDF from HTML page
var pdf = renderer.RenderHtmlAsPdf("<h1>Contract Agreement</h1>");

// Create digital signature with certificate for PDF files
var signature = new PdfSignature("certificate.pfx", "password")
{
    SigningContact = "legal@company.com",
    SigningLocation = "New York, NY",
    SigningReason = "Contract Approval",
    SignerName = "Authorized Signer"  // New property in v2025.8.8 for enhanced signature details
};

// Apply signature to PDF documents
pdf.Sign(signature);
pdf.SaveAs("signed-contract.pdf");

using IronPdf;
using IronPdf.Signing;

var renderer = new ChromePdfRenderer();

// Generate PDF from HTML page
var pdf = renderer.RenderHtmlAsPdf("<h1>Contract Agreement</h1>");

// Create digital signature with certificate for PDF files
var signature = new PdfSignature("certificate.pfx", "password")
{
    SigningContact = "legal@company.com",
    SigningLocation = "New York, NY",
    SigningReason = "Contract Approval",
    SignerName = "Authorized Signer"  // New property in v2025.8.8 for enhanced signature details
};

// Apply signature to PDF documents
pdf.Sign(signature);
pdf.SaveAs("signed-contract.pdf");

Imports IronPdf
Imports IronPdf.Signing

Dim renderer As New ChromePdfRenderer()

' Generate PDF from HTML page
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Contract Agreement</h1>")

' Create digital signature with certificate for PDF files
Dim signature As New PdfSignature("certificate.pfx", "password") With {
    .SigningContact = "legal@company.com",
    .SigningLocation = "New York, NY",
    .SigningReason = "Contract Approval",
    .SignerName = "Authorized Signer"  ' New property in v2025.8.8 for enhanced signature details
}

' Apply signature to PDF documents
pdf.Sign(signature)
pdf.SaveAs("signed-contract.pdf")

VERBUNDENE HOW-TO-Artikel: Digitales Signieren von PDF-Dokumenten mit C#

So konvertieren Sie HTML-Formulare in ausfüllbare PDFs

Um standardmäßige HTML-Formularelemente in interaktive, ausfüllbare PDF-Formularfelder umzuwandeln, aktivieren Sie die Rendering-Option CreatePdfFormsFromHtml. Dadurch bleiben Texteingabefelder, Kontrollkästchen, Optionsfelder und Dropdown-Menüs im generierten PDF-Dokument als bearbeitbare Felder erhalten.

using IronPdf;

var renderer = new ChromePdfRenderer();

// Enable HTML form to PDF form conversion
renderer.RenderingOptions.CreatePdfFormsFromHtml = true;

string htmlForm = @"
    <h2>Employee Onboarding Form</h2>
    <form>
        <label>Full Name:</label>
        <input type='text' name='fullName' value='' /><br/>
        <label>Department:</label>
        <select name='department'>
            <option value='engineering'>Engineering</option>
            <option value='marketing'>Marketing</option>
            <option value='sales'>Sales</option>
        </select><br/>
        <label>Agree to Terms:</label>
        <input type='checkbox' name='agreeTerms' />
    </form>";

var pdf = renderer.RenderHtmlAsPdf(htmlForm);
pdf.SaveAs("onboarding-form.pdf");

using IronPdf;

var renderer = new ChromePdfRenderer();

// Enable HTML form to PDF form conversion
renderer.RenderingOptions.CreatePdfFormsFromHtml = true;

string htmlForm = @"
    <h2>Employee Onboarding Form</h2>
    <form>
        <label>Full Name:</label>
        <input type='text' name='fullName' value='' /><br/>
        <label>Department:</label>
        <select name='department'>
            <option value='engineering'>Engineering</option>
            <option value='marketing'>Marketing</option>
            <option value='sales'>Sales</option>
        </select><br/>
        <label>Agree to Terms:</label>
        <input type='checkbox' name='agreeTerms' />
    </form>";

var pdf = renderer.RenderHtmlAsPdf(htmlForm);
pdf.SaveAs("onboarding-form.pdf");

Imports IronPdf

Dim renderer As New ChromePdfRenderer()

' Enable HTML form to PDF form conversion
renderer.RenderingOptions.CreatePdfFormsFromHtml = True

Dim htmlForm As String = "
    <h2>Employee Onboarding Form</h2>
    <form>
        <label>Full Name:</label>
        <input type='text' name='fullName' value='' /><br/>
        <label>Department:</label>
        <select name='department'>
            <option value='engineering'>Engineering</option>
            <option value='marketing'>Marketing</option>
            <option value='sales'>Sales</option>
        </select><br/>
        <label>Agree to Terms:</label>
        <input type='checkbox' name='agreeTerms' />
    </form>"

Dim pdf = renderer.RenderHtmlAsPdf(htmlForm)
pdf.SaveAs("onboarding-form.pdf")

VERWANDTER ANLEITUNGSARTIKEL: Wie man ausfüllbare PDF-Formulare in C# erstellt

Wie man bestimmte HTML-Elemente in PDF konvertiert

Um nur einen bestimmten Abschnitt einer Seite anstatt des gesamten Dokuments darzustellen, isolieren Sie das Zielelement vor dem Rendern. Der direkteste Ansatz nutzt die Rendering-Option JavaScript, um den Dokumenttext durch den Inhalt des Zielelements zu ersetzen, kombiniert mit WaitFor.HtmlQuerySelector(), um sicherzustellen, dass das Element vor der Extraktion vorhanden ist. Der folgende Ausschnitt bewahrt document.head, damit Stylesheets und Schriftarten übernommen werden – ohne diesen Schritt würden CSS-Regeln, die auf Vorfahren-Selektoren basieren, in der extrahierten PDF-Datei verloren gehen.

Für serverseitige Szenarien, in denen Sie Zugriff auf den rohen HTML-Code haben, extrahieren Sie das Zielfragment mit einem Parser wie AngleSharp und übergeben Sie es an RenderHtmlAsPdf() – eine JavaScript-Ausführung ist nicht erforderlich.

using IronPdf;

// Full page HTML containing the target element
string fullPageHtml = @"
<html>
<body>
    <header><h1>Acme Corp Invoice</h1></header>
    <div id='invoice-summary'>
        <h2>Invoice #12345</h2>
        <p>Total: $1,250.00</p>
    </div>
    <footer>Confidential</footer>
</body>
</html>";

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.EnableJavaScript = true;

// Replace the body with only the target element
renderer.RenderingOptions.JavaScript = @"
    var el = document.querySelector('#invoice-summary');
    if (el) {
        var head = document.head.innerHTML;
        document.body.innerHTML = el.outerHTML;
        document.head.innerHTML = head;
    }
";

// Wait for the target element before JS executes
renderer.RenderingOptions.WaitFor.HtmlQuerySelector("#invoice-summary", 10000);

var pdf = renderer.RenderHtmlAsPdf(fullPageHtml);
pdf.SaveAs("invoice-summary.pdf");

using IronPdf;

// Full page HTML containing the target element
string fullPageHtml = @"
<html>
<body>
    <header><h1>Acme Corp Invoice</h1></header>
    <div id='invoice-summary'>
        <h2>Invoice #12345</h2>
        <p>Total: $1,250.00</p>
    </div>
    <footer>Confidential</footer>
</body>
</html>";

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.EnableJavaScript = true;

// Replace the body with only the target element
renderer.RenderingOptions.JavaScript = @"
    var el = document.querySelector('#invoice-summary');
    if (el) {
        var head = document.head.innerHTML;
        document.body.innerHTML = el.outerHTML;
        document.head.innerHTML = head;
    }
";

// Wait for the target element before JS executes
renderer.RenderingOptions.WaitFor.HtmlQuerySelector("#invoice-summary", 10000);

var pdf = renderer.RenderHtmlAsPdf(fullPageHtml);
pdf.SaveAs("invoice-summary.pdf");

Imports IronPdf

' Full page HTML containing the target element
Dim fullPageHtml As String = "
<html>
<body>
    <header><h1>Acme Corp Invoice</h1></header>
    <div id='invoice-summary'>
        <h2>Invoice #12345</h2>
        <p>Total: $1,250.00</p>
    </div>
    <footer>Confidential</footer>
</body>
</html>"

Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.EnableJavaScript = True

' Replace the body with only the target element
renderer.RenderingOptions.JavaScript = "
    var el = document.querySelector('#invoice-summary');
    if (el) {
        var head = document.head.innerHTML;
        document.body.innerHTML = el.outerHTML;
        document.head.innerHTML = head;
    }
"

' Wait for the target element before JS executes
renderer.RenderingOptions.WaitFor.HtmlQuerySelector("#invoice-summary", 10000)

Dim pdf = renderer.RenderHtmlAsPdf(fullPageHtml)
pdf.SaveAs("invoice-summary.pdf")

VERWANDTER ANLEITUNGSARTIKEL: So konvertieren Sie HTML-Elemente und Teilseiten in PDF

Wie man authentifizierte Seiten als PDF rendert

Es gibt drei Mechanismen zum Rendern von Seiten, die eine Authentifizierung erfordern: Netzwerk-Anmeldeinformationen, benutzerdefinierte Cookies und HTTP-Anforderungsheader. Diese decken die häufigsten Authentifizierungsszenarien bei der Konvertierung geschützter Webinhalte in PDF ab.

Anmeldeinformationen

Verwenden Sie ChromeHttpLoginCredentials für die Basic-, Digest- oder NTLM-Authentifizierung, wenn Sie geschützte URLs in PDF konvertieren.

using IronPdf;

var renderer = new ChromePdfRenderer();

// Configure network authentication
renderer.LoginCredentials = new ChromeHttpLoginCredentials
{
    NetworkUsername = "user@domain.com",
    NetworkPassword = "securePassword",
    AuthenticationType = ChromeHttpLoginCredentials.AuthType.Basic
};

var pdf = renderer.RenderUrlAsPdf("https://intranet.com/pany.com/reports");
pdf.SaveAs("authenticated-report.pdf");

using IronPdf;

var renderer = new ChromePdfRenderer();

// Configure network authentication
renderer.LoginCredentials = new ChromeHttpLoginCredentials
{
    NetworkUsername = "user@domain.com",
    NetworkPassword = "securePassword",
    AuthenticationType = ChromeHttpLoginCredentials.AuthType.Basic
};

var pdf = renderer.RenderUrlAsPdf("https://intranet.com/pany.com/reports");
pdf.SaveAs("authenticated-report.pdf");

Imports IronPdf

Dim renderer As New ChromePdfRenderer()

' Configure network authentication
renderer.LoginCredentials = New ChromeHttpLoginCredentials With {
    .NetworkUsername = "user@domain.com",
    .NetworkPassword = "securePassword",
    .AuthenticationType = ChromeHttpLoginCredentials.AuthType.Basic
}

Dim pdf = renderer.RenderUrlAsPdf("https://intranet.com/pany.com/reports")
pdf.SaveAs("authenticated-report.pdf")

Cookies und HTTP-Header

Für tokenbasierte oder sitzungsbasierte Authentifizierung fügen Sie benutzerdefinierte Cookies und HTTP-Header direkt an die Rendering-Anfrage an.

using IronPdf;

var renderer = new ChromePdfRenderer();

// Add session cookies
renderer.RenderingOptions.CustomCookies["sessionId"] = "abc123token";
renderer.RenderingOptions.CustomCookies["authToken"] = "bearer-xyz";

// Add custom HTTP headers (e.g., API key or Bearer token)
renderer.RenderingOptions.CustomHttpRequestHeaders["Authorization"] = "Bearer eyJhbGciOi...";

var pdf = renderer.RenderUrlAsPdf("https://app.example.com/dashboard");
pdf.SaveAs("dashboard.pdf");

using IronPdf;

var renderer = new ChromePdfRenderer();

// Add session cookies
renderer.RenderingOptions.CustomCookies["sessionId"] = "abc123token";
renderer.RenderingOptions.CustomCookies["authToken"] = "bearer-xyz";

// Add custom HTTP headers (e.g., API key or Bearer token)
renderer.RenderingOptions.CustomHttpRequestHeaders["Authorization"] = "Bearer eyJhbGciOi...";

var pdf = renderer.RenderUrlAsPdf("https://app.example.com/dashboard");
pdf.SaveAs("dashboard.pdf");

Imports IronPdf

Dim renderer As New ChromePdfRenderer()

' Add session cookies
renderer.RenderingOptions.CustomCookies("sessionId") = "abc123token"
renderer.RenderingOptions.CustomCookies("authToken") = "bearer-xyz"

' Add custom HTTP headers (e.g., API key or Bearer token)
renderer.RenderingOptions.CustomHttpRequestHeaders("Authorization") = "Bearer eyJhbGciOi..."

Dim pdf = renderer.RenderUrlAsPdf("https://app.example.com/dashboard")
pdf.SaveAs("dashboard.pdf")

VERWANDTER ANLEITUNGSARTIKEL: So konvertieren Sie HTML hinter der Anmeldeauthentifizierung in PDF

So stellen Sie die Bereitstellung in Azure vor

Bei der Bereitstellung in Azure Functions oder App Service deaktivieren Sie die GPU-Beschleunigung und stellen Sie sicher, dass Ihre Hosting-Ebene genügend Arbeitsspeicher für das Chrome-basierte Rendering bereitstellt. Fügen Sie diese Einstellungen beim Start der Anwendung hinzu, bevor Rendering-Aufrufe erfolgen.

Azure-Sandboxes laufen ohne grafische Oberfläche und ohne GPU-Zugriff, und die kostenlosen/gemeinsamen Tarife (F1, D1) verfügen nicht über die Ressourcen, die Chrome benötigt. Streben Sie eine B1-Einstufung (Basis) oder höher an.

using IronPdf;

// Azure sandboxes block GPU access — always disable
IronPdf.Installation.ChromeGpuMode = IronPdf.Engines.Chrome.ChromeGpuModes.Disabled;
// Required on non-GUI Linux systems
IronPdf.Installation.LinuxAndDockerDependenciesAutoConfig = true;

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Azure PDF Report</h1>");
pdf.SaveAs("azure-report.pdf");

using IronPdf;

// Azure sandboxes block GPU access — always disable
IronPdf.Installation.ChromeGpuMode = IronPdf.Engines.Chrome.ChromeGpuModes.Disabled;
// Required on non-GUI Linux systems
IronPdf.Installation.LinuxAndDockerDependenciesAutoConfig = true;

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Azure PDF Report</h1>");
pdf.SaveAs("azure-report.pdf");

Imports IronPdf

' Azure sandboxes block GPU access — always disable
IronPdf.Installation.ChromeGpuMode = IronPdf.Engines.Chrome.ChromeGpuModes.Disabled
' Required on non-GUI Linux systems
IronPdf.Installation.LinuxAndDockerDependenciesAutoConfig = True

Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Azure PDF Report</h1>")
pdf.SaveAs("azure-report.pdf")

VERWANDTE EINSTIEGSLEITFADEN: So stellen Sie IronPDF auf Azure bereit

Wie man auf AWS Lambda bereitstellt

AWS Lambda erfordert eine Docker-basierte Bereitstellung für das Chrome-basierte PDF-Rendering. Das Standard-Lambda-Dateisystem ist schreibgeschützt, daher müssen alle temporären und Bereitstellungs-Pfade auf /tmp verweisen.

Konfigurieren Sie diese Einstellungen am Anfang Ihres Funktionshandlers, bevor Sie Rendering-Aufrufe durchführen.

using Amazon.Lambda.Co/re;
using IronPdf;

public class PdfFunction
{
    public string FunctionHandler(string input, ILambdaContext context)
    {
        // Lambda's only writable directory
        var tmpPath = "/tmp/";

        IronPdf.Installation.TempFolderPath = tmpPath;
        IronPdf.Installation.CustomDeploymentDirectory = tmpPath;
        IronPdf.Installation.ChromeGpuMode = IronPdf.Engines.Chrome.ChromeGpuModes.Disabled;
        // Let IronPDF install Chrome dependencies on first cold start
        IronPdf.Installation.LinuxAndDockerDependenciesAutoConfig = true;

        context.Logger.LogLine("Rendering PDF...");

        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(input);

        // Save to /tmp before uploading to S3 or returning
        var outputPath = $"{tmpPath}output.pdf";
        pdf.SaveAs(outputPath);

        return outputPath;
    }
}

using Amazon.Lambda.Co/re;
using IronPdf;

public class PdfFunction
{
    public string FunctionHandler(string input, ILambdaContext context)
    {
        // Lambda's only writable directory
        var tmpPath = "/tmp/";

        IronPdf.Installation.TempFolderPath = tmpPath;
        IronPdf.Installation.CustomDeploymentDirectory = tmpPath;
        IronPdf.Installation.ChromeGpuMode = IronPdf.Engines.Chrome.ChromeGpuModes.Disabled;
        // Let IronPDF install Chrome dependencies on first cold start
        IronPdf.Installation.LinuxAndDockerDependenciesAutoConfig = true;

        context.Logger.LogLine("Rendering PDF...");

        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf(input);

        // Save to /tmp before uploading to S3 or returning
        var outputPath = $"{tmpPath}output.pdf";
        pdf.SaveAs(outputPath);

        return outputPath;
    }
}

Imports Amazon.Lambda.Core
Imports IronPdf

Public Class PdfFunction
    Public Function FunctionHandler(input As String, context As ILambdaContext) As String
        ' Lambda's only writable directory
        Dim tmpPath As String = "/tmp/"

        IronPdf.Installation.TempFolderPath = tmpPath
        IronPdf.Installation.CustomDeploymentDirectory = tmpPath
        IronPdf.Installation.ChromeGpuMode = IronPdf.Engines.Chrome.ChromeGpuModes.Disabled
        ' Let IronPDF install Chrome dependencies on first cold start
        IronPdf.Installation.LinuxAndDockerDependenciesAutoConfig = True

        context.Logger.LogLine("Rendering PDF...")

        Dim renderer As New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf(input)

        ' Save to /tmp before uploading to S3 or returning
        Dim outputPath As String = $"{tmpPath}output.pdf"
        pdf.SaveAs(outputPath)

        Return outputPath
    End Function
End Class

VERWANDTE EINSTIEGSLEITFADEN: So stellen Sie IronPDF auf AWS Lambda bereit

Wie man mit Docker bereitstellt

Verwenden Sie für Docker-Bereitstellungen das NuGet-Paket IronPdf.Linux, um die Image-Größe zu reduzieren und das Herunterladen von Assets zur Laufzeit zu vermeiden. Dieses Paket enthält vorkonfigurierte, Linux-native Binärdateien, die für containerisierte Umgebungen optimiert sind.

Setzen Sie LinuxAndDockerDependenciesAutoConfig = false, wenn Ihre Dockerfile die Abhängigkeiten der gemeinsam genutzten Bibliotheken von Chrome bereits über apt-get installiert. Die automatische Installation zur Laufzeit ist in diesem Fall überflüssig und kann zu Berechtigungsfehlern oder längeren Kaltstarts führen.

Ein minimales mehrstufiges Dockerfile für ein Ubuntu/Debian-basiertes Image:

FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /app
COPY . .
RUN dotnet publish -c Release -o /out

FROM mcr.microsoft.com/dotnet/aspnet:8.0
# Install Chrome dependencies for PDF rendering
RUN apt-get update && apt-get install -y \
    libglib2.0-0 libnss3 libatk1.0-0 libatk-bridge2.0-0 \
    libcups2 libdrm2 libxkbcommon0 libxcomposite1 \
    libxdamage1 libxrandr2 libgbm1 libpango-1.0-0 \
    libcairo2 libasound2 libxshmfence1 && \
    rm -rf /var/lib/apt/lists/*
WORKDIR /app
COPY --from=build /out .
ENTRYPOINT ["dotnet", "MyApp.dll"]

using IronPdf;

// Dependencies handled by Dockerfile apt-get — disable runtime install
IronPdf.Installation.LinuxAndDockerDependenciesAutoConfig = false;
// No GPU in containers
IronPdf.Installation.ChromeGpuMode = IronPdf.Engines.Chrome.ChromeGpuModes.Disabled;

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Dockerized PDF</h1>");
pdf.SaveAs("output.pdf");

using IronPdf;

// Dependencies handled by Dockerfile apt-get — disable runtime install
IronPdf.Installation.LinuxAndDockerDependenciesAutoConfig = false;
// No GPU in containers
IronPdf.Installation.ChromeGpuMode = IronPdf.Engines.Chrome.ChromeGpuModes.Disabled;

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf("<h1>Dockerized PDF</h1>");
pdf.SaveAs("output.pdf");

Imports IronPdf

' Dependencies handled by Dockerfile apt-get — disable runtime install
IronPdf.Installation.LinuxAndDockerDependenciesAutoConfig = False
' No GPU in containers
IronPdf.Installation.ChromeGpuMode = IronPdf.Engines.Chrome.ChromeGpuModes.Disabled

Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Dockerized PDF</h1>")
pdf.SaveAs("output.pdf")

VERWANDTE EINSTIEGSLEITFADEN: So verwenden Sie IronPDF mit Docker

Schnelle Entscheidungsmatrix: IronPDF gegenüber anderen .NET PDF-Konvertern

VERWANDTE VERGLEICHE:

• Vergleich IronPDF und Syncfusion
• Vergleich IronPDF und Aspose

Detaillierter Vergleich: IronPDF gegenüber anderen .NET PDF-Konvertern

Vergleich der HTML-zu-PDF-Konvertierung im echten Leben: Rendering der Reddit-Startseite

Um die Qualität der Ausgabe-PDF zu bewerten, haben wir diese Bibliotheken mit der Startseite von Reddit getestet, die dynamische Webinhalte, modernes CSS und HTML-Elemente von JavaScript enthält. Diese Seite dient als ideales Testbeispiel für die Ausgabe-PDF-Erstellung.

https://www.reddit.com/

IronPDF

IronPDF liefert pixelgenaue Ergebnisse, indem es alle dynamischen Webinhalte, modernen Webfonts, Styling und interaktive Elemente genau so erhält, wie sie in Chrome angezeigt werden - alles in nur wenigen Codezeilen.

Syncfusion

Syncfusion gerenderte PDF mit den meisten Abschnitten und Stylings fehlt, insbesondere mit dynamischen Inhalten. Ursprünglich durch Reddits Sicherheit blockiert. Bessere Ergebnisse erfordern umfangreiche Anpassungen der Befehlszeile, dennoch bleibt das Ergebnis unvollständig.

Aspose.PDF

Aspose.PDF erforderte zunächst einen manuellen HTML-Download (keine direkte URL-Unterstützung). Nach der Konvertierung fehlte es der Ausgabe an ordentlichem Format und fast alle Inhaltsabschnitte fehlten, was sie für moderne Webs mit dynamischen Inhalten ungeeignet machte.

wkhtmltopdf

wkhtmltopdf wurde schnell abgeschlossen, erzeugte aber eine einfache, statische Seite, die wichtige Inhalte wie Live-Updates, dynamische Elemente und interaktive Abschnitte vermisste. Dies demonstriert die Inkompatibilität von wkhtmltopdf mit modernen, JavaScript-gesteuerten Websites.

Schlussfolgerung zur Leistung und Ausgabe-PDF-Qualität

Für .NET-Entwickler, die einen zuverlässigen HTML-zu-PDF-Konverter benötigen, sticht IronPDF mit minimalem Code, einfach zu verwendenden APIs und häufigen Produktverbesserungen heraus.

In einem realen Test mit Webinhalten lieferte es die schnellsten und genausten Ergebnisse, während Syncfusion hinterherhinkte, Aspose zusätzliche Schritte erforderte und wkhtmltopdf moderne Stylings verpasste. IronPDF bietet das beste Gleichgewicht zwischen Geschwindigkeit, Genauigkeit und Einfachheit für heutige HTML-zu-PDF-Konvertierungsworkflows.

Bitte beachten: Aspose, Syncfusion und wkhtmltopdf sind Warenzeichen ihrer jeweiligen Eigentümer. Diese Seite ist nicht mit ihnen verbunden oder wird von ihnen unterstützt. Alle Namen, Logos und Marken gehören ihren Eigentümern und Vergleiche basieren auf öffentlich verfügbaren Informationen zum Zeitpunkt des Schreibens.

Zusammenfassung

Diese Anleitung deckte alles ab, was zum Konvertieren von HTML zu PDF in .NET erforderlich ist: von der grundlegenden Zeichenfolgenkonvertierung bis zu erweiterten Funktionen wie asynchrone Verarbeitung, digitale Signaturen und Stapelerzeugung. Wir haben drei Konvertierungsmethoden demonstriert, wesentliche Konfigurationen, erweiterte Funktionen und Sicherheitseinstellungen sowie IronPDF mit anderen Bibliotheken im Rahmen eines realen Tests der dynamischen Dokumenterzeugung verglichen.

Während Konkurrenten Schwierigkeiten mit modernen Websites hatten oder komplexe Umgehungsmöglichkeiten erforderlich waren, lieferte IronPDF fehlerfreie Ergebnisse mit minimalem Code und einer leistungsstarken Rendering-Engine.

Bereit, Ihren PDF-Workflow zu vereinfachen und vielseitige PDF-Erstellung mit nur wenigen Codezeilen zu erleben? Installieren Sie IronPDF über den NuGet-Paket-Manager (oder wählen Sie NuGet-Paket verwalten in Visual Studio) und konvertieren Sie noch heute Ihr erstes HTML zu PDF.

Starten Sie Ihre kostenlose 30-tägige Testversion für Produkttests ohne Wasserzeichen. Flexible Lizenzierung beginnt bei $999 mit transparenten Team-Preisen, die sich Ihren Anforderungen anpassen.

IronPDF-Lizenzierung anzeigen

Schnelle Lösungen für häufige Fehler

• Langsames erstes Rendering? Normal. Chrome initialisiert in 2-3s, dann beschleunigt es.
• Cloud-Probleme? Verwenden Sie mindestens Azure B1 oder gleichwertige Ressourcen.
• Fehlende Assets? Basiswege setzen oder als Base64 einbetten.
• Fehlende Elemente? Fügen Sie RenderDelay für die JavaScript-Ausführung hinzu.
• Speicher beim Rendern? Aktualisieren Sie auf v2025.9.4 für Korrekturen bei HTML-zu-PDF, Stempeln und Kopfzeilen/Fußzeilen.
• Formularfeldprobleme (z. B. lange Textbereiche, Kontrollkästchen)? Behoben in v2025.7.17; sichere einzigartige Namen für Kontrollkästchen.
• Benutzerspezifisches Header/Footer-Überlappen oder spezielle Zeichen beschädigt? Gelöst in v2025.8.8; testen Sie Wortumbruch und Metadaten.

Hilfe von den Ingenieuren, die IronPDF entwickelt haben, 24/7

• Umfassender Leitfaden zur Fehlersuche
• Leistungsoptimierungsstrategien
• Engineering Support-Anfragen
• Schnell-Checkliste zur Fehlersuche

Nächste Schritte