HTML in C# in PDF konvertieren (Entwicklerhandbuch)

Wie man HTML-String zu PDF konvertiert

Die grundlegendste Operation ist der HTML-String zu PDF. Diese Methode ist perfekt für dynamisch generierte HTML-Inhalte. Die Methode RenderHtmlAsPdf unterstützt HTML5, CSS3, JavaScript und Bilder vollständig, wenn Sie HTML direkt in PDF konvertieren.

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

Wenn Ihre HTML-Zeichenfolge auf lokale Ressourcen wie Bilder oder Stylesheets verweist, verwenden Sie den Parameter BaseUrlPath, um HTML-Inhalte mit allen Ressourcen korrekt zu konvertieren:

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

RELATED HOW-TO ARTICLE: How to Convert HTML String to PDF in C#

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 im Browser konzipiert sind und IronPDF kein echtes Browserfenster auf dem Server-Betriebssystem öffnet, werden responsive HTML-Elemente möglicherweise in ihrer kleinsten Größe dargestellt. Es wird empfohlen, dieses Problem beim Rendern ganzer Webseiten zu beheben (siehe PdfCssMediaType.Print).

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

RELATED HOW-TO ARTICLE: How to Render URL to PDF

Wie man HTML-Datei zu PDF konvertiert

Das Konvertieren lokaler HTML-Dateien in PDF bewahrt alle relativen Ressourcen, einschließlich CSS, Bilder und JavaScript, als ob sie mit dem file://-Protokoll geöffnet würden. Diese HTML-zu-PDF-Methode eignet sich am besten zum Konvertieren von Vorlagen oder vordesignierten HTML-Seiten in PDF-Dokumente.

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

RELATED HOW-TO Article: Render HTML File to 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-Package IronPdf.Extensions.Razor

PM > Install-Package IronPdf.Extensions.Razor

using IronPDF;

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;

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

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

RELATED HOW-TO Article: How to Convert CSHTML to PDF in Razor Pages

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 Ansichtspfad und 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-Package IronPdf.Extensions.Mvc.Core

PM > Install-Package IronPdf.Extensions.Mvc.Core

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

using IronPdf.Extensions.Mvc.Core;

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

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

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

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

Dim renderer As 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")

RELATED HOW-TO Article: How to Convert Views to PDF in ASP.NET Core MVC

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 muss ein LoginCredentials-Objekt auf dem Renderer festgelegt werden. Für token- oder sitzungsbasierten Zugriff müssen Cookies und Header über RenderingOptions weitergeleitet werden, bevor RenderUrlAsPdf aufgerufen wird.

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.company.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.company.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.company.com/quarterly-report")
pdf.SaveAs("quarterly-report.pdf")

VERWANDTE HOW-TO-ARTIKEL: Render PDFs Behind Login Authentication | Custom HTTP Request Headers

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 Renderaufruf festgelegt, nicht auf der Renderer-Instanz.

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

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.corp.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.corp.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.corp.local:8080"
)
pdf.SaveAs("proxied-report.pdf")

Beachten Sie, dass RenderUrlAsPdf() keinen Proxy-Parameter akzeptiert. Um eine Live-URL hinter einem Proxy zu rendern, rufen Sie zuerst das HTML mit HttpClient ab, das mit WebProxy konfiguriert ist, und übergeben Sie es dann mit dem Proxy-Parameter zum Laden der Assets an RenderHtmlAsPdf().

RELATED HOW-TO Article: How to Configure Proxy Servers for PDF Rendering

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 einfache Szenarien eignet sich die String.Format-Methode in C# am besten für die einfache PDF-Manipulation.

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

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

' 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

Für komplexe Vorlagen mit Schleifen und Bedingungen beim Konvertieren von HTML in PDF verwenden Sie die erweiterte Vorlagenfunktion mit Handlebars.NET, um PDF-Dokumente mit dynamischem HTML-Inhalt zu generieren.

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

# First, install Handlebars.NET for HTML to PDF templating
PM > Install-Package 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.Compile(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.Compile(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")

RELATED HOW-TO ARTICLE: Learn more about Handlebars.NET on 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.Threading.Tasks;

// 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.Threading.Tasks;

// 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.Threading.Tasks

' 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

• 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.
• ChromePdfRenderer Instanzen nach Möglichkeit wiederverwenden.
• 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.

RELATED HOW-TO Article: How to Generate PDFs with Async and Multithreading

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

RELATED HOW-TO Article: Digitally Signing PDF Documents with C#

So konvertieren Sie HTML-Formulare in ausfüllbare PDFs

Um Standard-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 = 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")

RELATED HOW-TO Article: How to Create Fillable PDF Forms in C#

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 verwendet die Rendering-Option JavaScript, um den Dokumentkörper durch den Inhalt des Zielelements zu ersetzen, kombiniert mit WaitFor.HtmlQuerySelector(), um sicherzustellen, dass das Element vor der Extraktion vorhanden ist. Der unten stehende Codeausschnitt erhält document.head, sodass Stylesheets und Schriftarten übernommen werden – ohne diesen Schritt würden CSS-Regeln, die auf Vorfahrenselektoren basieren, im extrahierten PDF verloren gehen.

Für serverseitige Szenarien, in denen Sie Zugriff auf das rohe HTML haben, extrahieren Sie das Zielfragment mit einem Parser wie AngleSharp und übergeben Sie es an RenderHtmlAsPdf() — keine JavaScript Ausführung erforderlich.

using IronPDF;

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;

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

Dim 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)

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

RELATED HOW-TO Article: How to Convert HTML Elements and Partial Pages to 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 beim Konvertieren geschützter URLs in 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.company.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.company.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.company.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")

RELATED HOW-TO Article: How to Convert HTML Behind Login Authentication to 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")

RELATED GET-STARTED Guide: How to Deploy IronPDF on Azure

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 Bereitstellungspfade auf /tmp verweisen.

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

using Amazon.Lambda.Core;
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.Core;
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

RELATED GET-STARTED Guide: How to Deploy IronPDF on AWS Lambda

Wie man mit Docker bereitstellt

Für Docker-Bereitstellungen verwenden Sie 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 Shared-Library-Abhängigkeiten 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")

RELATED GET-STARTED Guide: How to Use IronPDF with 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 $799 mit transparenter Teampreisgestaltung, die mit Ihren Bedürfnissen skaliert.

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? RenderDelay für die Ausführung von JavaScript hinzufügen.
• 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

• Umfassende Anleitung zur Fehlersuche
• Leistungsoptimierungsstrategien
• Engineering Support-Anfragen
• Schnell-Checkliste zur Fehlersuche

Nächste Schritte