Comment convertir HTML en PDF en C# (Guide du développeur)

Comment convertir une chaîne HTML en PDF

L'opération la plus fondamentale est la conversion de chaîne HTML en PDF. Cette méthode est parfaite pour le contenu HTML généré dynamiquement. La méthode RenderHtmlAsPdf prend entièrement en charge HTML5, CSS3, JavaScript et les images lors de la conversion directe de HTML en 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");

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

Lorsque votre chaîne HTML fait référence à des ressources locales telles que des images ou des feuilles de style, utilisez le paramètre BaseUrlPath pour convertir correctement le contenu HTML avec toutes les ressources :

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#

Comment exporter une URL existante en PDF

Le rendu de pages web entières en PDFs avec C# permet aux équipes de séparer le design PDF et le travail de rendu côté serveur. Cette approche vous permet de convertir toute URL spécifiée directement au format PDF.

CSS Impression vs Écran

Vous pouvez configurer IronPDF pour rendre à l'aide de l'un ou l'autre type de média CSS.

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

Support JavaScript

IronPDF prend entièrement en charge JavaScript, jQuery, et même AJAX lorsque vous convertissez HTML en PDF. Pour le contenu HTML dynamique, vous pouvez configurer IronPDF pour attendre la fin de JavaScript avant de rendre les pages web en PDF. C'est parfait pour les applications à page unique et les sites web dynamiques.

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

L'exécution JavaScript peut également être montrée lors du rendu d'un graphique d3.js avancé en format PDF depuis une page web :

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

CSS Réactif

Les pages web adaptatives étant conçues pour être visualisées dans un navigateur, et IronPDF n'ouvrant pas de véritable fenêtre de navigateur sur le système d'exploitation de votre serveur, les éléments HTML adaptatifs peuvent s'afficher à leur taille minimale. Il est recommandé de résoudre ce problème lors du rendu de pages web complètes.

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

Comment convertir un fichier HTML en PDF

La conversion de fichiers HTML locaux en PDF préserve tous les actifs relatifs, y compris le CSS, les images et le JavaScript, comme s'ils étaient ouverts en utilisant le protocole file://. Cette méthode de conversion HTML en PDF est le mieux pour convertir des modèles ou des pages HTML pré-conçues en documents 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

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

Comment convertir des pages Razor en PDF

Si votre projet ASP.NET Core utilise déjà des pages Razor, vous pouvez les convertir directement en PDF sans reconstruire votre HTML. L'extension Razor d'IronPDF ajoute la méthode RenderRazorToPdf, qui prend votre page .cshtml — complète avec son modèle et sa mise en page — et la rend en tant que document PDF en un seul appel.

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

Comment convertir des vues MVC en PDF

Les équipes utilisant le modèle MVC peuvent générer des PDF directement à partir de leurs vues et contrôleurs existants. Installez le package d'extension MVC Core, puis appelez RenderRazorViewToPdf avec votre chemin de vue et votre modèle — IronPDF gère le pipeline de rendu Razor et produit un PDF finalisé.

C'est particulièrement utile pour les rapports, les factures, et toute page où le HTML est déjà conçu et testé dans le navigateur. Le PDF généré préserve la sortie complète de la Vue, y compris les pages de mise en page et les vues partielles.

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

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

Commencez par enregistrer le service IRazorViewRenderer dans votre fichier Program.cs afin que vos contrôleurs puissent l'injecter :

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

Ensuite, dans votre action de contrôleur, injectez le renderer et convertissez n'importe quelle Vue en 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");

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

Comment définir des en-têtes HTTP personnalisés, des cookies et des identifiants de connexion

Lors du rendu d'URL nécessitant une authentification ou des métadonnées de requête spécifiques, IronPDF vous permet d'inclure les identifiants de connexion, les cookies de session, et les en-têtes HTTP avec la requête. Cela permet de rendre des tableaux de bord intranet, des rapports restreints, ou des pages générées par une API directement en PDF sans avoir besoin de récupérer séparément le HTML.

Pour l'authentification de base ou NTLM, définissez un objet LoginCredentials sur le moteur de rendu. Pour un accès basé sur un jeton ou une session, transmettez les cookies et les en-têtes via RenderingOptions avant d'appeler RenderUrlAsPdf.

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

ARTICLES RELIÉS SUR COMMENT FAIRE : Render PDFs Behind Login Authentication | Custom HTTP Request Headers

Comment configurer un proxy pour le rendu PDF

Lors du rendu HTML qui charge des ressources externes derrière un proxy d'entreprise, transmettez l'adresse du proxy comme troisième paramètre sur RenderHtmlAsPdf(). Il s'agit d'un paramètre de méthode, et non d'une propriété sur ChromePdfRenderOptions — il est donc défini par appel de rendu, et non sur l'instance du moteur de rendu.

Pour les proxys authentifiés, intégrez les informations d'identification directement dans l'URL en utilisant le format http://user:pass@host:port. Encodez les caractères spéciaux des mots de passe en URL avec 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")

Notez que RenderUrlAsPdf() n'accepte pas de paramètre proxy. Pour afficher une URL en direct derrière un proxy, récupérez d'abord le HTML avec HttpClient configuré avec un WebProxy, puis transmettez-le à RenderHtmlAsPdf() avec le paramètre proxy pour le chargement des ressources.

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

Comment générer un modèle HTML pour la création de PDF par lot

Création de PDF par lot de base

La création de PDF par lot est essentielle pour générer efficacement plusieurs documents PDF personnalisés. Pour les scénarios de base, la méthode String.Format en C# fonctionne le mieux pour la manipulation simple de PDF.

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

Pour les modèles plus longs lorsque vous devez générer des documents PDF, utilisez le remplacement de repères dans votre contenu HTML : 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

Modélisation HTML en PDF avec Handlebars.NET

Pour les modèles complexes avec des boucles et des conditions lors de la conversion de HTML en PDF, utilisez la modélisation avancée avec Handlebars.NET pour générer des documents PDF avec un contenu HTML dynamique.

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

Comment générer un PDF en utilisant la méthode asynchrone

IronPDF offre des performances de niveau entreprise avec un support complet asynchrone et multithread pour vos besoins de conversion HTML en PDF lorsque vous devez générer des fichiers PDF à grande échelle.

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> htmlModèles)
{
    var renderer = new ChromePdfRenderer();

    // Create parallel conversion tasks to generate PDF documents
    var tasks = htmlModèles.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> htmlModèles)
{
    var renderer = new ChromePdfRenderer();

    // Create parallel conversion tasks to generate PDF documents
    var tasks = htmlModèles.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(htmlModèles As List(Of String)) As Task
    Dim renderer As New ChromePdfRenderer()

    ' Create parallel conversion tasks to generate PDF documents
    Dim tasks = htmlModèles.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

• Utilisez des systèmes 64 bits pour une performance optimale de génération de PDF.
• Assurez des ressources serveur adéquates lorsque vous générez des documents PDF (évitez les niveaux gratuits sous-capacitaires)
• Permettez un délai de rendu suffisant pour un JavaScript complexe dans le contenu HTML.
• Réutilisez les instances ChromePdfRenderer lorsque cela est possible.
• Exploitez les corrections de mémoire v2025.9.4 pour les opérations par lot/asynchrones pour réduire l'utilisation des ressources ; testez pour des tailles de fichiers réduites avec des en-têtes/pieds de page personnalisés répétés.

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

Comment ajouter des fonctionnalités de sécurité avancées

Comment ajouter une protection par mot de passe pour les fichiers PDF en .NET

Sécurisez les documents PDF générés sensibles avec des mots de passe et des permissions lorsque vous convertissez le contenu HTML au format PDF protégé.

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

Comment ajouter des signatures numériques aux fichiers PDF

Ajoutez des signatures cryptographiques pour assurer l'authenticité des documents PDF lorsque vous générez des fichiers PDF à partir du contenu HTML.

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#

Comment convertir des formulaires HTML en PDF remplissables

Pour convertir les éléments de formulaire HTML standard en champs de formulaire PDF interactifs et remplissables, activez l'option de rendu CreatePdfFormsFromHtml. Cela préserve les entrées de texte, les cases à cocher, les boutons radio et les menus déroulants comme champs modifiables dans le document PDF généré.

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#

Comment convertir des éléments HTML spécifiques en PDF

Pour rendre une section spécifique d'une page plutôt que le document complet, isolez l'élément cible avant de le rendre. L'approche la plus directe utilise l'option de rendu JavaScript pour remplacer le corps du document par le contenu de l'élément cible, combinée avec WaitFor.HtmlQuerySelector() pour garantir que l'élément existe avant l'extraction. L'extrait ci-dessous préserve document.head afin que les feuilles de style et les polices soient conservées — sans cette étape, les règles CSS reposant sur des sélecteurs ancêtres seraient perdues dans le PDF extrait.

Pour les scénarios côté serveur où vous avez accès au HTML brut, extrayez le fragment cible avec un analyseur comme AngleSharp et transmettez-le à RenderHtmlAsPdf() — aucune exécution JavaScript n'est nécessaire.

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

Comment rendre des pages authentifiées en PDF

Il existe trois mécanismes pour rendre les pages qui se trouvent derrière une authentification : les identifiants de connexion réseau, les cookies personnalisés et les en-têtes de requête HTTP. Ceux-ci couvrent les scénarios d'authentification les plus courants lors de la conversion de contenu web protégé en PDF.

Identifiants de connexion

Utilisez ChromeHttpLoginCredentials pour l'authentification de base, digest ou NTLM lors de la conversion d'URL protégées en 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 et en-têtes HTTP

Pour l'authentification basée sur les tokens ou les sessions, attachez directement les cookies et les en-têtes HTTP personnalisés à la requête de rendu.

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

Pour les connexions via formulaire HTML (POST nom d'utilisateur/mot de passe), il est recommandé d'utiliser d'abord le code 1356 pour l'authentification, puis de transmettre les cookies obtenus au dictionnaire CustomCookies afin d'afficher la page protégée.

RELATED HOW-TO Article: How to Convert HTML Behind Login Authentication to PDF

Comment déployer sur Azure

Lors du déploiement sur Azure Functions ou App Service, désactivez l'accélération GPU et assurez-vous que votre niveau d'hébergement fournit suffisamment de mémoire pour le rendu basé sur Chrome. Ajoutez ces paramètres au démarrage de l'application, avant tout appel de rendu.

Les sandboxes Azure fonctionnent sans tête sans accès GPU, et les tiers Free/Shared (F1, D1) manquent des ressources requises par Chrome. Ciblez au minimum un niveau B1 (Basique) ou supérieur.

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

Comment déployer sur AWS Lambda

AWS Lambda nécessite un déploiement basé sur Docker pour le rendu sur Chrome. Le système de fichiers Lambda par défaut est en lecture seule, donc tous les chemins temporaires et de déploiement doivent pointer vers /tmp.

Configurez ces paramètres en haut de votre handler de fonction, avant tout appel de rendu.

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

Comment déployer avec Docker

Pour les déploiements Docker, utilisez le package NuGet IronPdf.Linux pour réduire la taille de l'image et éviter les téléchargements de ressources d'exécution. Ce package inclut des binaires natifs Linux pré-empaquetés optimisés pour les environnements conteneurisés.

Définissez LinuxAndDockerDependenciesAutoConfig = false lorsque votre Dockerfile installe déjà les dépendances de bibliothèque partagée de Chrome via apt-get. L'auto-installation à l'exécution est redondante dans ce cas et peut entraîner des erreurs de permission ou des démarrages à froid plus longs.

Un Dockerfile multi-stage minimal pour une image basée sur Ubuntu/Debian :

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

Matrice de décision rapide : IronPDF par rapport à d'autres convertisseurs PDF .NET

COMPARAISONS RELIÉES :

• Comparer IronPDF et Syncfusion
• Comparer IronPDF et Aspose

Comparaison détaillée : IronPDF par rapport à d'autres convertisseurs PDF .NET

Comparaison de conversion HTML en PDF dans la vie réelle : rendu de la page d'accueil de Reddit

Pour évaluer la qualité du PDF de sortie, nous avons testé ces bibliothèques avec la page d'accueil de Reddit contenant du contenu web dynamique, des CSS modernes, et des éléments HTML JavaScript. Cette page sert de cas de test idéal pour la génération de PDF.

https://www.reddit.com/

Capture d'écran de la page d'accueil de Reddit montrant du contenu dynamique, un style moderne et des éléments interactifs utilisés pour les tests de conversion PDF.

IronPDF

IronPDF fournit des résultats parfaits, préservant tout le contenu web dynamique, le style des polices modernes et les éléments interactifs exactement comme affichés dans Chrome, le tout en seulement quelques lignes de code.

Syncfusion

Syncfusion a rendu le PDF avec la plupart des sections et des styles manquants, en particulier le contenu dynamique. Initialement bloqué par la sécurité de Reddit. Obtenir de meilleurs résultats nécessite un réglage approfondi de la ligne de commande, mais la sortie reste incomplète.

Aspose.PDF

Aspose.PDF a nécessité un téléchargement manuel de l'HTML d'abord (pas de support direct d'URL). Après conversion, la sortie manquait de mise en forme correcte et manquait pratiquement toutes les sections de contenu, ce qui la rendait inadaptée pour le web moderne avec du contenu dynamique.

wkhtmltopdf

wkhtmltopdf a terminé rapidement mais a produit une page simple et statique manquant de contenu critique comme les mises à jour en direct, les éléments dynamiques, et les sections interactives. Ceci démontre l'incompatibilité de wkhtmltopdf avec les sites modernes pilotés par JavaScript.

Conclusion sur la performance et la qualité de sortie PDF

Pour les développeurs .NET ayant besoin d'un convertisseur HTML en PDF fiable, IronPDF se démarque avec un code minimal, des API faciles à utiliser, et des améliorations fréquentes du produit.

Dans un test réel sur du contenu web, il a fourni les résultats les plus rapides et les plus précis tandis que Syncfusion était à la traîne, Aspose nécessitait des étapes supplémentaires, et wkhtmltopdf manquait de style moderne. IronPDF offre le meilleur équilibre entre vitesse, précision et simplicité pour les flux de travail de conversion HTML en PDF d'aujourd'hui.

Veuillez noter : Aspose, SyncFusion, et wkhtmltopdf sont des marques déposées de leurs propriétaires respectifs. Ce site n'est pas affilié ou approuvé par eux. Tous les noms, logos, et marques appartiennent à leurs propriétaires, et les comparaisons sont basées sur des informations publiquement disponibles au moment de l'écriture.

Résumé

Ce guide a couvert tout ce qu'il fallait pour convertir HTML en PDF dans .NET : de la conversion de chaîne de base aux fonctionnalités avancées comme le traitement asynchrone, les signatures numériques, et la génération par lot. Nous avons démontré trois méthodes de conversion, des configurations essentielles, des fonctionnalités avancées et des paramètres de sécurité, et comparé IronPDF avec d'autres bibliothèques à travers des tests réels de génération de documents dynamiques.

Tandis que les concurrents ont eu des difficultés avec les sites modernes ou ont nécessité des solutions complexes, IronPDF a fourni des résultats impeccables avec un code minimal et un moteur de rendu puissant.

Prêt à simplifier votre flux de travail PDF et à expérimenter une génération de PDF polyvalente en seulement quelques lignes de code ? Installez IronPDF via le Emballer Manager NuGet (ou sélectionnez Gérer NuGet Emballer dans Visual Studio) et convertissez votre premier HTML en PDF aujourd'hui.

Commencez votre essai gratuit de 30 jours pour des tests de production sans filigranes. Les licences flexibles commencent à $799 avec une tarification d'équipe transparente qui évolue en fonction de vos besoins.

Voir les licences IronPDF

Solutions rapides aux erreurs courantes

• Rendu lent au premier? Normal. Chrome s'initialise en 2–3 s, puis accélère.
• Problèmes de cloud? Utilisez au moins Azure B1 ou équivalent.
• Ressources manquantes? Définissez des chemins de base ou intégrez sous forme de base64.
• Éléments manquants? Ajoutez RenderDelay pour l'exécution de JavaScript.
• Mémoire dans le rendu ? Mettez à jour vers v2025.9.4 pour des correctifs dans HTML en PDF, tampons, et en-têtes/pieds de page.
• Problèmes de champ de formulaire (par exemple, longues zones de texte, cases à cocher)? Corrigé en v2025.7.17 ; assurez-vous que les cases ont des noms uniques.
• Coupures d'en-tête/pied de page personnalisés ou caractères spéciaux corrompus? Résolu en v2025.8.8 ; testez le retour à la ligne et les métadonnées.

Obtenez de l'aide des ingénieurs qui ont développé IronPDF, 24/7

• Guide complet de dépannage
• Stratégies d'optimisation des performances
• Demandes d'assistance technique
• Liste de contrôle de dépannage rapide

Prochaines étapes