Découvrez le meilleur logiciel de rédaction de PDF pour 2025

PuppeteerSharp

PuppeteerSharp est un portage .NET de Puppeteer Node.js de Google, sorti pour la première fois en 2017. Il pilote une instance Chromium sans tête via le protocole Chrome DevTools. C'est un orchestrateur de processus plutôt qu'une bibliothèque in-process : l'application télécharge une version de Chromium avec BrowserFetcher, lance le navigateur, définit le contenu de la page et capture le PDF.

using PuppeteerSharp;
using System.Threading.Tasks;

public class PuppeteerExample
{
    public async Task GeneratePdfAsync()
    {
        // Download a matching Chromium build if it is not already present (the 100-300 MB fetch)
        await new BrowserFetcher().DownloadAsync();

        // Start a headless browser process; await using disposes it to avoid orphaned processes
        await using var browser = await Puppeteer.LaunchAsync(new LaunchOptions { Headless = true });
        // Open a fresh tab to work in
        await using var page = await browser.NewPageAsync();

        // Load the HTML directly into the page instead of navigating to a URL
        await page.SetContentAsync("<h1>Invoice Report</h1><p>Rendered with PuppeteerSharp.</p>");
        // Drive Chrome's print pipeline to emit the PDF file
        await page.PdfAsync("puppeteer_output.pdf");
    }
}

using PuppeteerSharp;
using System.Threading.Tasks;

public class PuppeteerExample
{
    public async Task GeneratePdfAsync()
    {
        // Download a matching Chromium build if it is not already present (the 100-300 MB fetch)
        await new BrowserFetcher().DownloadAsync();

        // Start a headless browser process; await using disposes it to avoid orphaned processes
        await using var browser = await Puppeteer.LaunchAsync(new LaunchOptions { Headless = true });
        // Open a fresh tab to work in
        await using var page = await browser.NewPageAsync();

        // Load the HTML directly into the page instead of navigating to a URL
        await page.SetContentAsync("<h1>Invoice Report</h1><p>Rendered with PuppeteerSharp.</p>");
        // Drive Chrome's print pipeline to emit the PDF file
        await page.PdfAsync("puppeteer_output.pdf");
    }
}

Imports PuppeteerSharp
Imports System.Threading.Tasks

Public Class PuppeteerExample
    Public Async Function GeneratePdfAsync() As Task
        ' Download a matching Chromium build if it is not already present (the 100-300 MB fetch)
        Await New BrowserFetcher().DownloadAsync()

        ' Start a headless browser process; using disposes it to avoid orphaned processes
        Using browser = Await Puppeteer.LaunchAsync(New LaunchOptions With {.Headless = True})
            ' Open a fresh tab to work in
            Using page = Await browser.NewPageAsync()
                ' Load the HTML directly into the page instead of navigating to a URL
                Await page.SetContentAsync("<h1>Invoice Report</h1><p>Rendered with PuppeteerSharp.</p>")
                ' Drive Chrome's print pipeline to emit the PDF file
                Await page.PdfAsync("puppeteer_output.pdf")
            End Using
        End Using
    End Function
End Class

Pour capturer une URL en direct au lieu d'une chaîne, naviguez vers celle-ci avant l'appel :

// Navigate the tab to a live URL so the loaded page becomes the render source
await page.GoToAsync("https://example.com");
// Capture whatever is currently displayed as a PDF
await page.PdfAsync("from_url.pdf");

// Navigate the tab to a live URL so the loaded page becomes the render source
await page.GoToAsync("https://example.com");
// Capture whatever is currently displayed as a PDF
await page.PdfAsync("from_url.pdf");

Imports System.Threading.Tasks

' Navigate the tab to a live URL so the loaded page becomes the render source
Await page.GoToAsync("https://example.com")
' Capture whatever is currently displayed as a PDF
Await page.PdfAsync("from_url.pdf")

Forces :

• Le rendu correspond à Google Chrome, avec un support complet de Flexbox, Grid et des polices web.
• Exécute JavaScriptet peut attendre le réseau-idle avant la capture.
• Sous licence MIT, donc l'utilisation commerciale n'entraîne aucune obligation copyleft.

Limitations :

• Un premier lancement télécharge une version de Chromium de 100 Mo à 300 Mo.
• Chaque instance de navigateur consomme une quantité de mémoire importante, donc les lots concurrents nécessitent une piscine de navigateurs.
• Aucun PDF/A ou PDF/UA intégré.

License: MIT. Optez pour cela lorsque vous souhaitez une sortie gratuite de fidélité Chrome et que l'équipe peut absorber la surcharge des opérations. Pour une comparaison directe sur ce compromis, voir la comparaisonPuppeteerSharpvs IronPDF.

Auteurfor .NET

Playwright est maintenu par Microsoft comme un framework d'automatisation multi-navigateurs pour Chromium, WebKit et Firefox. Les équipes le réutilisent pour HTML en PDF via Page.PdfAsync, bien que la génération de PDF ne fonctionne qu'avec Chromium. La configuration récupère des binaires de navigateur grâce à une étape d'installation unique.

using Microsoft.Playwright;
using System.Threading.Tasks;

public class PlaywrightExample
{
    public async Task GeneratePdfAsync()
    {
        // Create the Auteurdriver that manages the installed browser binaries
        using var playwright = await Playwright.CreateAsync();
        // PDF output is Chromium-only, so launch the Chromium build specifically
        await using var browser = await playwright.Chromium.LaunchAsync();
        // Open a new page (tab) to render into
        var page = await browser.NewPageAsync();

        // Set the HTML content in place rather than navigating to a URL
        await page.SetContentAsync("<html><body><h1>Sales Dashboard</h1></body></html>");
        // Emit the PDF with an explicit A4 page format
        await page.PdfAsync(new PagePdfOptions { Path = "playwright_output.pdf", Format = "A4" });
    }
}

using Microsoft.Playwright;
using System.Threading.Tasks;

public class PlaywrightExample
{
    public async Task GeneratePdfAsync()
    {
        // Create the Auteurdriver that manages the installed browser binaries
        using var playwright = await Playwright.CreateAsync();
        // PDF output is Chromium-only, so launch the Chromium build specifically
        await using var browser = await playwright.Chromium.LaunchAsync();
        // Open a new page (tab) to render into
        var page = await browser.NewPageAsync();

        // Set the HTML content in place rather than navigating to a URL
        await page.SetContentAsync("<html><body><h1>Sales Dashboard</h1></body></html>");
        // Emit the PDF with an explicit A4 page format
        await page.PdfAsync(new PagePdfOptions { Path = "playwright_output.pdf", Format = "A4" });
    }
}

Imports Microsoft.Playwright
Imports System.Threading.Tasks

Public Class PlaywrightExample
    Public Async Function GeneratePdfAsync() As Task
        ' Create the Auteurdriver that manages the installed browser binaries
        Using playwright = Await Playwright.CreateAsync()
            ' PDF output is Chromium-only, so launch the Chromium build specifically
            Await Using browser = Await playwright.Chromium.LaunchAsync()
                ' Open a new page (tab) to render into
                Dim page = Await browser.NewPageAsync()

                ' Set the HTML content in place rather than navigating to a URL
                Await page.SetContentAsync("<html><body><h1>Sales Dashboard</h1></body></html>")
                ' Emit the PDF with an explicit A4 page format
                Await page.PdfAsync(New PagePdfOptions With {.Path = "playwright_output.pdf", .Format = "A4"})
            End Using
        End Using
    End Function
End Class

Avant la première exécution, installez le navigateur avec pwsh bin/Debug/net10.0/playwright.ps1 install chromium (ou appelez le point d'entrée d'installation équivalent dans le code).

Pour une URL en direct, naviguez d'abord vers la page :

// Load a live URL so its rendered DOM becomes the PDF source
await page.GotoAsync("https://example.com");
// Export the loaded page as an A4 PDF
await page.PdfAsync(new PagePdfOptions { Path = "from_url.pdf", Format = "A4" });

// Load a live URL so its rendered DOM becomes the PDF source
await page.GotoAsync("https://example.com");
// Export the loaded page as an A4 PDF
await page.PdfAsync(new PagePdfOptions { Path = "from_url.pdf", Format = "A4" });

Imports System.Threading.Tasks

' Load a live URL so its rendered DOM becomes the PDF source
Await page.GotoAsync("https://example.com")
' Export the loaded page as an A4 PDF
Await page.PdfAsync(New PagePdfOptions With {.Path = "from_url.pdf", .Format = "A4"})

Où il excelle :

• Soutenu par Microsoft avec un cycle de sortie actif.
• Faible latence de premier rendu une fois le navigateur prêt.
• Rend avec précision les normes web modernes et le JavaScriptcôté client.

Le hic :

• Même empreinte binaire lourde et gestion du navigateur que PuppeteerSharp.
• La mémoire monte sans gestion soigneuse du contexte du navigateur.
• La sortie PDF est une caractéristique secondaire du pipeline d'impression de Chrome, donc elle manque de fonctionnalités de manipulation des documents.

License: MIT. Idéal quand un projet utilise déjà Auteurpour les tests et souhaite un rendu libre à côté.

wkhtmltopdf (via DinkToPdf)

Depuis plus d'une décennie, wkhtmltopdf était l'outil HTML en PDF par défaut. Sous .NET, il est généralement consommé via DinkToPdf, un wrapper C# autour de la bibliothèque native libwkhtmltox. L'API du wrapper est propre, mais le moteur sous-jacent est le problème.

using DinkToPdf;

public class DinkToPdfExample
{
    public void GeneratePdf()
    {
        // SynchronizedConverter serializes calls into the non-thread-safe native libwkhtmltox library
        var converter = new SynchronizedConverter(new PdfTools());

        // Describe the document: global page settings plus one or more HTML content objects
        var doc = new HtmlToPdfDocument
        {
            // Set the paper size and the output file path for the whole document
            GlobalSettings = { PaperSize = PaperKind.A4, Out = "legacy_output.pdf" },
            // Each object is a chunk of HTML to render into the PDF
            Objects = { new ObjectSettings { HtmlContent = "<h1>Legacy Report</h1>" } }
        };

        // Hand the descriptor to the native engine, which writes the file defined in Out
        converter.Convert(doc);
    }
}

using DinkToPdf;

public class DinkToPdfExample
{
    public void GeneratePdf()
    {
        // SynchronizedConverter serializes calls into the non-thread-safe native libwkhtmltox library
        var converter = new SynchronizedConverter(new PdfTools());

        // Describe the document: global page settings plus one or more HTML content objects
        var doc = new HtmlToPdfDocument
        {
            // Set the paper size and the output file path for the whole document
            GlobalSettings = { PaperSize = PaperKind.A4, Out = "legacy_output.pdf" },
            // Each object is a chunk of HTML to render into the PDF
            Objects = { new ObjectSettings { HtmlContent = "<h1>Legacy Report</h1>" } }
        };

        // Hand the descriptor to the native engine, which writes the file defined in Out
        converter.Convert(doc);
    }
}

Imports DinkToPdf

Public Class DinkToPdfExample
    Public Sub GeneratePdf()
        ' SynchronizedConverter serializes calls into the non-thread-safe native libwkhtmltox library
        Dim converter = New SynchronizedConverter(New PdfTools())

        ' Describe the document: global page settings plus one or more HTML content objects
        Dim doc = New HtmlToPdfDocument With {
            ' Set the paper size and the output file path for the whole document
            .GlobalSettings = New GlobalSettings With {.PaperSize = PaperKind.A4, .Out = "legacy_output.pdf"},
            ' Each object is a chunk of HTML to render into the PDF
            .Objects = {New ObjectSettings With {.HtmlContent = "<h1>Legacy Report</h1>"}}
        }

        ' Hand the descriptor to the native engine, which writes the file defined in Out
        converter.Convert(doc)
    End Sub
End Class

Ce code compile, mais le faire tourner sur une machine propre renvoie System.DllNotFoundException: Unable to load DLL 'libwkhtmltox' jusqu'à ce que les binaires natifs soient copiés dans le répertoire de sortie. Cette étape de dépendance native est le premier signe de la friction de déploiement que ce moteur apporte.

Avantage :

• Démarrage à froid rapide, sans navigateur moderne à initialiser.
• Faible mémoire, environ 50 Mo par rendu.

Inconvénients :

• Le moteur QtWebKit qu'il expédie (une version instantanée de WebKit environ 2012-2013, que Qt a lui-même dépréciée en 2015 et supprimée en 2016) ne peut pas rendre Flexbox, Grid ou le JavaScriptmoderne.
• Le dépôt wkhtmltopdf a été archivé le 2 janvier 2023 et la dernière version, 0.12.6, date de juin 2020.
• Il transporte CVE-2022-35583, une faille SSRF (Server-Side Request Forgery) notée CVSS 9.8 (critique) qui n'est pas corrigée car le projet n'est plus maintenu.

Licence : DinkToPdf lui-même est sous MIT, mais il lie les binaires wkhtmltopdf sous LGPLv3, donc l'obligation effective vient de wkhtmltopdf. Adapté aux flux de travail hérités en attente de migration, avec le risque de sécurité gardé à l'esprit. Consultez la comparaison wkhtmltopdf vs IronPDF pour une vue d'ensemble complète de la migration.

PdfSharp and HtmlRenderer

PdfSharp est une bibliothèque open-source largement utilisée, mais une idée fausse courante est qu'elle convertit HTML seule. Elle ne le fait pas. PdfSharp fournit une API de dessin au niveau bas, basée sur les coordonnées. Pour convertir HTML, vous l'associez avec le pont communautaire HtmlRenderer.PdfSharp, qui analyse HTML et émet des commandes de dessin PdfSharp.

using PdfSharp;
using TheArtOfDev.HtmlRenderer.PdfSharp;

public class PdfSharpExample
{
    public void GeneratePdf()
    {
        string html = "<h1>Simple Title</h1><p>Statically rendered text.</p>";

        // The HtmlRenderer bridge parses the HTML and emits PdfSharp drawing commands onto an A4 page
        var pdf = PdfGenerator.GeneratePdf(html, PageSize.A4);
        // Persist the resulting PdfSharp document to disk
        pdf.Save("simple_document.pdf");
    }
}

using PdfSharp;
using TheArtOfDev.HtmlRenderer.PdfSharp;

public class PdfSharpExample
{
    public void GeneratePdf()
    {
        string html = "<h1>Simple Title</h1><p>Statically rendered text.</p>";

        // The HtmlRenderer bridge parses the HTML and emits PdfSharp drawing commands onto an A4 page
        var pdf = PdfGenerator.GeneratePdf(html, PageSize.A4);
        // Persist the resulting PdfSharp document to disk
        pdf.Save("simple_document.pdf");
    }
}

Imports PdfSharp
Imports TheArtOfDev.HtmlRenderer.PdfSharp

Public Class PdfSharpExample
    Public Sub GeneratePdf()
        Dim html As String = "<h1>Simple Title</h1><p>Statically rendered text.</p>"

        ' The HtmlRenderer bridge parses the HTML and emits PdfSharp drawing commands onto an A4 page
        Dim pdf = PdfGenerator.GeneratePdf(html, PageSize.A4)
        ' Persist the resulting PdfSharp document to disk
        pdf.Save("simple_document.pdf")
    End Sub
End Class

Deux détails de configuration importent sous .NET 10. Le pont attend la page de code Windows-1252, absente par défaut sur .NET moderne, alors enregistrez-la une fois au démarrage avec Encoding.RegisterProvider(CodePagesEncodingProvider.Instance). Associer le pont avec un package PdfSharp 6.x plus récent casse également à l'exécution avec un MissingMethodException, donc laissez HtmlRenderer tirer sa propre version compatible de PdfSharp plutôt que d'attacher le dernier.

Ça fonctionne :

• Licence MIT véritablement permissive sans limites de revenu.
• Léger, sans binaires natifs ni téléchargeurs de navigateur.
• Pur C#, donc le déploiement sur plusieurs systèmes d'exploitation est simple.

Ce qui casse :

• Le pont HTML est limité à peu près à HTML 4.01 et CSS Niveau 2, et il a vu un ensemble unique de versions fin 2025 après neuf ans de dormance.
• Aucune exécution JavaScriptdu tout.
• Les règles d'impression comme page-break-inside: avoid ne sont pas supportées, donc les lignes de table se divisent sur plusieurs pages.

License: PdfSharp MIT, HtmlRenderer BSD-3-Clause. Le bon choix pour des documents statiques simples sans mise en page complexe. Pour une analyse fonction-par-fonction, voir la comparaison PdfSharp vs IronPDF.

QuestPDF

QuestPDF prend une direction différente : il supprime HTML et définit les mises en page en C# via une API fluide. Pour les données qui proviennent d'objets plutôt que de balisage, cela supprime l'étape de génération HTML uniquement pour le réanalyser.

using QuestPDF.Fluent;
using QuestPDF.Helpers;
using QuestPDF.Infrastructure;

public class QuestPdfExample
{
    public void GeneratePdf()
    {
        // The revenue-gated license tier must be declared before any document is built
        QuestPDF.Settings.License = LicenseType.Community;

        // Compose the layout in C# through the fluent API; no HTML anywhere
        var document = Document.Create(container =>
        {
            container.Page(page =>
            {
                // Define the physical page size and margins
                page.Size(PageSizes.A4);
                page.Margin(2, Unit.Centimetre);
                // Place content into named page regions (header and body)
                page.Header().Text("Programmatic Invoice").FontSize(24);
                page.Content().Text("This document is generated without HTML.");
            });
        });

        // Run the layout engine and write the composed document to a file
        document.GeneratePdf("fluent_layout.pdf");
    }
}

using QuestPDF.Fluent;
using QuestPDF.Helpers;
using QuestPDF.Infrastructure;

public class QuestPdfExample
{
    public void GeneratePdf()
    {
        // The revenue-gated license tier must be declared before any document is built
        QuestPDF.Settings.License = LicenseType.Community;

        // Compose the layout in C# through the fluent API; no HTML anywhere
        var document = Document.Create(container =>
        {
            container.Page(page =>
            {
                // Define the physical page size and margins
                page.Size(PageSizes.A4);
                page.Margin(2, Unit.Centimetre);
                // Place content into named page regions (header and body)
                page.Header().Text("Programmatic Invoice").FontSize(24);
                page.Content().Text("This document is generated without HTML.");
            });
        });

        // Run the layout engine and write the composed document to a file
        document.GeneratePdf("fluent_layout.pdf");
    }
}

Imports QuestPDF.Fluent
Imports QuestPDF.Helpers
Imports QuestPDF.Infrastructure

Public Class QuestPdfExample
    Public Sub GeneratePdf()
        ' The revenue-gated license tier must be declared before any document is built
        QuestPDF.Settings.License = LicenseType.Community

        ' Compose the layout in VB.NET through the fluent API; no HTML anywhere
        Dim document = Document.Create(Sub(container)
                                           container.Page(Sub(page)
                                                              ' Define the physical page size and margins
                                                              page.Size(PageSizes.A4)
                                                              page.Margin(2, Unit.Centimetre)
                                                              ' Place content into named page regions (header and body)
                                                              page.Header().Text("Programmatic Invoice").FontSize(24)
                                                              page.Content().Text("This document is generated without HTML.")
                                                          End Sub)
                                       End Sub)

        ' Run the layout engine and write the composed document to a file
        document.GeneratePdf("fluent_layout.pdf")
    End Sub
End Class

Points forts :

• Très rapide, car il évite l'analyse du DOM et la mise en page du navigateur.
• Mémoire prévisible, linéaire, qui convient aux travaux par lots à haut débit.
• Une application compagnon offre un aperçu en direct et une recharge à chaud pendant la conception.

Points faibles :

• C'est un moteur de mise en page, pas un moteur de rendu HTML, il ne peut donc pas convertir une URL ou un modèle HTML existant.
• Les documents HTML ou Razor existants auraient besoin d'une réécriture complète dans l'API fluide.
• La licence est passée d'un modèle MIT à un modèle à seuil de revenu.

Licence : Licence communautaire (gratuite pour les entreprises dont le revenu annuel est inférieur à 1 000 000 USD) ou un niveau Professionnel et Enterprise payant. Adapté aux documents à mise en page fixe définis par code, pilotés par des données structurées. Voir la comparaison QuestPDF vs IronPDF pour l'arbitrage entre HTML et mise en page fluide.

iText (pdfHTML)

iText 7 et 8 sont reconnus pour la manipulation programmatique des PDF, et le module complémentaire pdfHTML convertit HTML. Contrairement aux outils Chromium, pdfHTML utilise un parseur personnalisé qui mappe les balises HTML aux objets iText au lieu d'exécuter un navigateur.

using iText.Html2pdf;
using System.IO;

public class iTextExample
{
    public void GeneratePdf()
    {
        string html = "<h1>Report</h1><p>Converted with pdfHTML.</p>";

        // Open the destination stream; using ensures the file handle is released after writing
        using var dest = File.Create("output.pdf");
        // pdfHTML maps the HTML tags to iText objects and writes them to the stream (no browser involved)
        HtmlConverter.ConvertToPdf(html, dest);
    }
}

using iText.Html2pdf;
using System.IO;

public class iTextExample
{
    public void GeneratePdf()
    {
        string html = "<h1>Report</h1><p>Converted with pdfHTML.</p>";

        // Open the destination stream; using ensures the file handle is released after writing
        using var dest = File.Create("output.pdf");
        // pdfHTML maps the HTML tags to iText objects and writes them to the stream (no browser involved)
        HtmlConverter.ConvertToPdf(html, dest);
    }
}

Imports iText.Html2pdf
Imports System.IO

Public Class iTextExample
    Public Sub GeneratePdf()
        Dim html As String = "<h1>Report</h1><p>Converted with pdfHTML.</p>"

        ' Open the destination stream; using ensures the file handle is released after writing
        Using dest As FileStream = File.Create("output.pdf")
            ' pdfHTML maps the HTML tags to iText objects and writes them to the stream (no browser involved)
            HtmlConverter.ConvertToPdf(html, dest)
        End Using
    End Sub
End Class

Sur un nouveau projet, cela renvoie une erreur jusqu'à ce que vous ajoutiez le package itext7.bouncy-castle-adapter, qu'iText requiert pour son chemin de cryptographie. Cette dépendance supplémentaire est facile à manquer et produit une erreur opaque sans elle.

Avantages :

• Manipulation profonde des PDF, signature et rédaction dans l'écosystème iText.
• Produit PDF/A et PDF/UA à partir de HTML sémantique, qui convient au travail de conformité.
• Temps de démarrage rapide, car il ne lance pas de navigateur.

Inconvénients :

• Pas d'exécution de script, donc le contenu dynamique ne se rend pas.
• Les fonctionnalités CSS3 comme Grid ne sont pas prises en charge et échouent silencieusement.
• La licence AGPLv3 nécessite une licence commerciale pour les applications à source fermée, et les fichiers volumineux sont mis en tampon en entier plutôt que diffusés.

License: AGPLv3 or Commercial. Choisissez-le pour la manipulation intensive de PDF et les flux de travail de conformité avec HTML statique et contrôlé. Pour les détails sur la licence et la manipulation, voir la comparaison iText 7 vs IronPDF.

IronPDF

IronPDF intègre un moteur Chromium dans son package NuGet et l'expose via une API C#, de sorte que rien d'externe n'a besoin d'être lancé ou mis en pool. Il se situe entre les outils de navigateur gratuits et les bibliothèques programmatiques, échangeant un coût de licence pour la fidélité de rendu sans gérer le navigateur.

using IronPdf;
using System.Threading.Tasks;

public class IronPdfExample
{
    public async Task GeneratePdfAsync()
    {
        // Create the in-process Chromium renderer (no external browser to launch)
        var renderer = new ChromePdfRenderer();
        // Turn on the JavaScriptengine so client-side chart scripts execute before capture
        renderer.RenderingOptions.EnableJavaScript = true;
        // Wait 500 ms after load to let JavaScript-built content settle before rendering
        renderer.RenderingOptions.WaitFor.RenderDelay(500);

        // Render the HTML string asynchronously into an in-memory PDF
        var pdf = await renderer.RenderHtmlAsPdfAsync("<h1>Quarterly Report</h1><div class='chart'></div>");
        // Save the finished PDF to disk
        pdf.SaveAs("report.pdf");
    }
}

using IronPdf;
using System.Threading.Tasks;

public class IronPdfExample
{
    public async Task GeneratePdfAsync()
    {
        // Create the in-process Chromium renderer (no external browser to launch)
        var renderer = new ChromePdfRenderer();
        // Turn on the JavaScriptengine so client-side chart scripts execute before capture
        renderer.RenderingOptions.EnableJavaScript = true;
        // Wait 500 ms after load to let JavaScript-built content settle before rendering
        renderer.RenderingOptions.WaitFor.RenderDelay(500);

        // Render the HTML string asynchronously into an in-memory PDF
        var pdf = await renderer.RenderHtmlAsPdfAsync("<h1>Quarterly Report</h1><div class='chart'></div>");
        // Save the finished PDF to disk
        pdf.SaveAs("report.pdf");
    }
}

Imports IronPdf
Imports System.Threading.Tasks

Public Class IronPdfExample
    Public Async Function GeneratePdfAsync() As Task
        ' Create the in-process Chromium renderer (no external browser to launch)
        Dim renderer As New ChromePdfRenderer()
        ' Turn on the JavaScript engine so client-side chart scripts execute before capture
        renderer.RenderingOptions.EnableJavaScript = True
        ' Wait 500 ms after load to let JavaScript-built content settle before rendering
        renderer.RenderingOptions.WaitFor.RenderDelay(500)

        ' Render the HTML string asynchronously into an in-memory PDF
        Dim pdf = Await renderer.RenderHtmlAsPdfAsync("<h1>Quarterly Report</h1><div class='chart'></div>")
        ' Save the finished PDF to disk
        pdf.SaveAs("report.pdf")
    End Function
End Class

Le même moteur convertit une URL en PDF avec un seul appel :

// RenderUrlAsPdf fetches and renders the live page in one call, no navigation step needed
var fromUrl = new ChromePdfRenderer().RenderUrlAsPdf("https://example.com");
// Write the captured page to disk
fromUrl.SaveAs("from_url.pdf");

// RenderUrlAsPdf fetches and renders the live page in one call, no navigation step needed
var fromUrl = new ChromePdfRenderer().RenderUrlAsPdf("https://example.com");
// Write the captured page to disk
fromUrl.SaveAs("from_url.pdf");

' RenderUrlAsPdf fetches and renders the live page in one call, no navigation step needed
Dim fromUrl = (New ChromePdfRenderer()).RenderUrlAsPdf("https://example.com")
' Write the captured page to disk
fromUrl.SaveAs("from_url.pdf")

Il rend également les vues Razor et MVC en PDF et convertit directement les fichiers HTML. La présentation complète des fonctionnalités se trouve dans le tutoriel HTML en PDF.

Avantages :

• Rendu de qualité navigateur qui gère Grid, Flexbox, et les scripts côté client.
• Déploiement sans exécutables externes ou mise en pool de navigateur.
• Génère des PDF/A et applique des signatures numériques, ce qui le sépare des frameworks de test.

Inconvénients :

• Une licence commerciale est requise, sans niveau de production gratuit.
• Après un déploiement neuf, le premier rendu comporte un coût d'initialisation unique, puis les rendus suivants se stabilisent dans un chemin rapide à chaud.

License: Commercial, perpetual. Utilisez-le là où le CSS actuel en volume importe et où les priorités sont de réduire la charge des opérations tout en maintenant une haute fidélité.