COMPARAISON

WebView2 vs IronPDF : Guide de comparaison technique

Publié:

Lorsque les développeurs .NET doivent convertir du contenu HTML en PDF, le contrôle WebView2de Microsoft apparaît parfois comme une solution potentielle en raison de son moteur de rendu basé sur Chromium. Cependant, WebView2est fondamentalement un contrôle d'intégration de navigateur conçu pour les applications d'interface utilisateur, et non une bibliothèque de génération de PDF. Cette comparaison technique examine WebView2aux côtés d'IronPDF pour aider les architectes et les développeurs à comprendre les différences critiques entre l'intégration d'un contrôle de navigateur pour la sortie PDF et l'utilisation d'une bibliothèque PDF conçue à cet effet.

Comprendre WebView2

WebView2 (Microsoft Edge) est un contrôle de navigateur polyvalent qui intègre le moteur Edge/Chromium dans les applications Windows natives. Ce contrôle prend en charge l'expérience de navigation du navigateur Microsoft Edge au sein d'un écosystème restreint, offrant une conformité aux normes web modernes pour l'affichage de contenu HTML5, CSS3 et JavaScript.

La capacité de génération de PDF de WebView2existe grâce à sa méthode PrintToPdfAsync et à l'intégration du protocole DevTools. Cependant, cette fonctionnalité représente une réflexion après coup plutôt qu'une caractéristique essentielle :

  • Browser Control Architecture: Conçu pour l'intégration de contenu web dans des applications d'interface utilisateur, et non pour la génération de PDF côté serveur
  • <Plate-forme Windows uniquement: Aucune prise en charge de Linux, macOS, Docker ou des environnements en nuage
  • <Exigences relatives aux threads de l'interface utilisateur: Doit être exécuté sur un thread STA avec une pompe à messages - ne peut pas fonctionner avec des serveurs web ou des API
  • Edge Runtime Dependency: Nécessite Edge WebView2Runtime installé sur les machines cibles
  • No Headless Mode: Crée toujours les éléments de l'interface utilisateur, même lorsqu'ils sont cachés

Limitations deWebView2 pour la génération de PDF

La documentation du guide de migration identifie les problèmes critiques liés à l'utilisation de WebView2pour la génération de PDF :

Problématique Impact Sévérité
Fuites de mémoire WebView2a documenté des fuites de mémoire dans des processus de longue durée CRITIQUE
Réservé à Windows Aucune prise en charge de Linux, macOS, Docker ou des environnements en nuage CRITIQUE
Fil d'Ariane requis Doit être exécuté sur STA thread avec message pump CRITIQUE
Pas conçu pour les PDF PrintToPdfAsync est une réflexion après coup HAUT
Instable dans les services Crashs et blocages fréquents dans les services Windows HAUT
Flux asynchrone complexe Événements de navigation, rappels d'achèvement, conditions de course HAUT
Dépendance d'exécution Edge Nécessite Edge WebView2Runtime sur la machine cible MOYEN
Pas de mode sans tête Crée toujours les éléments de l'interface utilisateur, même lorsqu'ils sont cachés MOYEN

Comprendre IronPDF

IronPDF est une bibliothèque PDF conçue spécifiquement pour la génération de PDF à partir de HTML et de contenu web. Contrairement à l'approche d'intégration au navigateur de WebView2, IronPDF fournit un moteur de génération de PDF dédié avec une prise en charge multiplateforme et des capacités côté serveur.

Les principales caractéristiques sont les suivantes

  • Librairie PDF conçue à des fins spécifiques: Conçue dès le départ pour la génération de PDF, et non pour l'intégration d'interfaces utilisateur
  • <Prise en charge multiplateforme : Windows, Linux, macOS, Docker, iOS et Android
  • Opération Any Thread: Aucune exigence en matière de thread STA ou de pompe à messages
  • Server/Cloud Ready: Pris en charge pour ASP.NET Core, Azure, AWS, GCP et Docker
  • Aucune dépendance externe: Autonome, aucune installation en cours d'exécution n'est requise
  • Fonctionnalités PDF complètes: En-têtes/pieds de page, filigranes, fusion/séparation, signatures numériques, conformité PDF/A

Comparaison des fonctionnalités

Le tableau suivant met en évidence les différences fondamentales entre WebView2etIronPDF:

Fonction WebView2 IronPDF
Objectif Contrôle du navigateur (UI) Bibliothèque PDF (conçue pour le format PDF)
<Prêt pour la production NON OUI
Gestion de la mémoire Fuites dans des projets de longue haleine Stable, bien disposé
Support de la plateforme Windows uniquement Windows, Linux, macOS, Docker
Exigences en matière de fil conducteur STA + Message Pump N'importe quel fil
Serveur/Cloud Non pris en charge Prise en charge
Azure/AWS/GCP Problématique Fonctionne parfaitement
Docker Pas possible Images officielles disponibles
ASP.NET Core Ne peut pas travailler Une assistance de premier ordre
Services d'arrière-plan Instable Stable
Applications de console Piratages complexes Oui
WinForms/WPF Oui Oui
En-têtes/Pieds de page NON Oui (HTML)
Marqueurs d'eau NON Oui
Fusionner des PDF NON Oui
Diviser les PDF NON Oui
Signatures numériques NON Oui
Protection des mots de passe NON Oui
Conformité PDF/A NON Oui
Remplissage de formulaires NON Oui
Support professionnel Aucune pour l'utilisation en PDF Oui
Documentation Documents PDF limités Une traduction

Différences d'architecture des API

Les différences architecturales entre WebView2etIronPDFdeviennent immédiatement évidentes lorsqu'on examine la façon dont chaque approche gère la génération de PDF.

WebView2Complex Async Pattern

WebView2 nécessite un processus asynchrone en plusieurs étapes impliquant l'initialisation du navigateur, la navigation, la gestion des événements et les appels au protocole DevTools :

// NuGet: Install-Package Microsoft.Web.WebView2.WinForms
using System;
using System.IO;
using System.Threading.Tasks;
using Microsoft.Web.WebView2.WinForms;
using Microsoft.Web.WebView2.Core;

class Program
{
    static async Task Main()
    {
        var webView = new WebView2();
        await webView.EnsureCoreWebView2Async();

        webView.CoreWebView2.NavigateToString("<html><body><h1>Hello World</h1></body></html>");
        await Task.Delay(2000);

        await webView.CoreWebView2.CallDevToolsProtocolMethodAsync(
            "Page.printToPDF",
            "{}"
        );
    }
}
// NuGet: Install-Package Microsoft.Web.WebView2.WinForms
using System;
using System.IO;
using System.Threading.Tasks;
using Microsoft.Web.WebView2.WinForms;
using Microsoft.Web.WebView2.Core;

class Program
{
    static async Task Main()
    {
        var webView = new WebView2();
        await webView.EnsureCoreWebView2Async();

        webView.CoreWebView2.NavigateToString("<html><body><h1>Hello World</h1></body></html>");
        await Task.Delay(2000);

        await webView.CoreWebView2.CallDevToolsProtocolMethodAsync(
            "Page.printToPDF",
            "{}"
        );
    }
}
Imports System
Imports System.IO
Imports System.Threading.Tasks
Imports Microsoft.Web.WebView2.WinForms
Imports Microsoft.Web.WebView2.Core

Module Program
    Async Function Main() As Task
        Dim webView As New WebView2()
        Await webView.EnsureCoreWebView2Async()

        webView.CoreWebView2.NavigateToString("<html><body><h1>Hello World</h1></body></html>")
        Await Task.Delay(2000)

        Await webView.CoreWebView2.CallDevToolsProtocolMethodAsync(
            "Page.printToPDF",
            "{}"
        )
    End Function
End Module
$vbLabelText   $csharpLabel

Ce code démontre plusieurs complexités de WebView2: initialisation explicite via EnsureCoreWebView2Async(), navigation en utilisant NavigateToString(), délais arbitraires pour attendre le chargement du contenu, et appels au protocole DevTools de bas niveau. Le Task.Delay représente une estimation peu fiable du moment où le contenu est prêt - une condition de course qui ne demande qu'à se produire.

Approche simplifiée d'IronPDF

IronPDF élimine cette complexité grâce à une approche simple et à méthode unique :

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello World</h1></body></html>");
        pdf.SaveAs("output.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello World</h1></body></html>");
        pdf.SaveAs("output.pdf");
    }
}
Imports IronPdf

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf("<html><body><h1>Hello World</h1></body></html>")
        pdf.SaveAs("output.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

La classe ChromePdfRenderer gère en interne toute la complexité du rendu. Pas de cérémonie d'initialisation, pas d'événements de navigation, pas d'estimation de temps. Pour obtenir des conseils complets sur la conversion HTML, consultez le tutoriel HTML au PDF.

Conversion d'URL en PDF

La conversion de pages web en documents PDF démontre l'écart de complexité entre WebView2et IronPDF.

Mise en œuvre deWebView2

WebView2 nécessite une gestion des événements de navigation, des rappels d'achèvement et une extraction manuelle des PDF :

// NuGet: Install-Package Microsoft.Web.WebView2.WinForms
using System;
using System.IO;
using System.Threading.Tasks;
using Microsoft.Web.WebView2.WinForms;
using Microsoft.Web.WebView2.Core;

class Program
{
    static async Task Main()
    {
        var webView = new WebView2();
        await webView.EnsureCoreWebView2Async();

        var tcs = new TaskCompletionSource<bool>();
        webView.CoreWebView2.NavigationCompleted += (s, e) => tcs.SetResult(true);

        webView.CoreWebView2.Navigate("https://example.com");
        await tcs.Task;
        await Task.Delay(1000);

        var result = await webView.CoreWebView2.CallDevToolsProtocolMethodAsync(
            "Page.printToPDF",
            "{\"printBackground\": true}"
        );

        var base64 = System.Text.Json.JsonDocument.Parse(result).RootElement.GetProperty("data").GetString();
        File.WriteAllBytes("output.pdf", Convert.FromBase64String(base64));
    }
}
// NuGet: Install-Package Microsoft.Web.WebView2.WinForms
using System;
using System.IO;
using System.Threading.Tasks;
using Microsoft.Web.WebView2.WinForms;
using Microsoft.Web.WebView2.Core;

class Program
{
    static async Task Main()
    {
        var webView = new WebView2();
        await webView.EnsureCoreWebView2Async();

        var tcs = new TaskCompletionSource<bool>();
        webView.CoreWebView2.NavigationCompleted += (s, e) => tcs.SetResult(true);

        webView.CoreWebView2.Navigate("https://example.com");
        await tcs.Task;
        await Task.Delay(1000);

        var result = await webView.CoreWebView2.CallDevToolsProtocolMethodAsync(
            "Page.printToPDF",
            "{\"printBackground\": true}"
        );

        var base64 = System.Text.Json.JsonDocument.Parse(result).RootElement.GetProperty("data").GetString();
        File.WriteAllBytes("output.pdf", Convert.FromBase64String(base64));
    }
}
Imports System
Imports System.IO
Imports System.Threading.Tasks
Imports Microsoft.Web.WebView2.WinForms
Imports Microsoft.Web.WebView2.Core

Module Program
    Async Function Main() As Task
        Dim webView As New WebView2()
        Await webView.EnsureCoreWebView2Async()

        Dim tcs As New TaskCompletionSource(Of Boolean)()
        AddHandler webView.CoreWebView2.NavigationCompleted, Sub(s, e) tcs.SetResult(True)

        webView.CoreWebView2.Navigate("https://example.com")
        Await tcs.Task
        Await Task.Delay(1000)

        Dim result As String = Await webView.CoreWebView2.CallDevToolsProtocolMethodAsync(
            "Page.printToPDF",
            "{""printBackground"": true}"
        )

        Dim base64 As String = System.Text.Json.JsonDocument.Parse(result).RootElement.GetProperty("data").GetString()
        File.WriteAllBytes("output.pdf", Convert.FromBase64String(base64))
    End Function
End Module
$vbLabelText   $csharpLabel

Cette mise en œuvre nécessite la création d'une TaskCompletionSource pour suivre la navigation, l'abonnement aux événements NavigationCompleted, l'analyse des réponses JSON du protocole DevTools et la gestion du décodage Base64. Le Task.Delay(1000) supplémentaire après la fin de la navigation tente de s'assurer que JavaScript a fini de s'exécuter - une autre astuce de synchronisation peu fiable.

Mise en œuvre IronPDF

IronPDF permet un rendu direct des URL en un seul appel de méthode :

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://example.com");
        pdf.SaveAs("output.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://example.com");
        pdf.SaveAs("output.pdf");
    }
}
Imports IronPdf

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderUrlAsPdf("https://example.com")
        pdf.SaveAs("output.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

La méthode RenderUrlAsPdf gère la navigation, l'exécution du JavaScript et le chargement du contenu en interne. Pas d'abonnements à des événements, pas d'estimations de temps, pas d'analyse Base64.

Paramètres et options PDF personnalisés

La configuration des dimensions, des marges et de l'orientation des pages révèle des différences significatives dans l'utilisation des API.

WebView2DevTools Configuration du protocole

WebView2 nécessite la sérialisation JSON et les paramètres du protocole DevTools :

// NuGet: Install-Package Microsoft.Web.WebView2.WinForms
using System;
using System.IO;
using System.Threading.Tasks;
using System.Text.Json;
using Microsoft.Web.WebView2.WinForms;
using Microsoft.Web.WebView2.Core;

class Program
{
    static async Task Main()
    {
        var webView = new WebView2();
        await webView.EnsureCoreWebView2Async();

        var htmlPath = Path.GetFullPath("document.html");
        var tcs = new TaskCompletionSource<bool>();
        webView.CoreWebView2.NavigationCompleted += (s, e) => tcs.SetResult(true);

        webView.CoreWebView2.Navigate($"file:///{htmlPath}");
        await tcs.Task;
        await Task.Delay(1000);

        var options = new
        {
            landscape = false,
            printBackground = true,
            paperWidth = 8.5,
            paperHeight = 11,
            marginTop = 0.4,
            marginBottom = 0.4,
            marginLeft = 0.4,
            marginRight = 0.4
        };

        var result = await webView.CoreWebView2.CallDevToolsProtocolMethodAsync(
            "Page.printToPDF",
            JsonSerializer.Serialize(options)
        );

        var base64 = JsonDocument.Parse(result).RootElement.GetProperty("data").GetString();
        File.WriteAllBytes("output.pdf", Convert.FromBase64String(base64));
    }
}
// NuGet: Install-Package Microsoft.Web.WebView2.WinForms
using System;
using System.IO;
using System.Threading.Tasks;
using System.Text.Json;
using Microsoft.Web.WebView2.WinForms;
using Microsoft.Web.WebView2.Core;

class Program
{
    static async Task Main()
    {
        var webView = new WebView2();
        await webView.EnsureCoreWebView2Async();

        var htmlPath = Path.GetFullPath("document.html");
        var tcs = new TaskCompletionSource<bool>();
        webView.CoreWebView2.NavigationCompleted += (s, e) => tcs.SetResult(true);

        webView.CoreWebView2.Navigate($"file:///{htmlPath}");
        await tcs.Task;
        await Task.Delay(1000);

        var options = new
        {
            landscape = false,
            printBackground = true,
            paperWidth = 8.5,
            paperHeight = 11,
            marginTop = 0.4,
            marginBottom = 0.4,
            marginLeft = 0.4,
            marginRight = 0.4
        };

        var result = await webView.CoreWebView2.CallDevToolsProtocolMethodAsync(
            "Page.printToPDF",
            JsonSerializer.Serialize(options)
        );

        var base64 = JsonDocument.Parse(result).RootElement.GetProperty("data").GetString();
        File.WriteAllBytes("output.pdf", Convert.FromBase64String(base64));
    }
}
Imports System
Imports System.IO
Imports System.Threading.Tasks
Imports System.Text.Json
Imports Microsoft.Web.WebView2.WinForms
Imports Microsoft.Web.WebView2.Core

Module Program
    Async Function Main() As Task
        Dim webView As New WebView2()
        Await webView.EnsureCoreWebView2Async()

        Dim htmlPath As String = Path.GetFullPath("document.html")
        Dim tcs As New TaskCompletionSource(Of Boolean)()
        AddHandler webView.CoreWebView2.NavigationCompleted, Sub(s, e) tcs.SetResult(True)

        webView.CoreWebView2.Navigate($"file:///{htmlPath}")
        Await tcs.Task
        Await Task.Delay(1000)

        Dim options = New With {
            .landscape = False,
            .printBackground = True,
            .paperWidth = 8.5,
            .paperHeight = 11,
            .marginTop = 0.4,
            .marginBottom = 0.4,
            .marginLeft = 0.4,
            .marginRight = 0.4
        }

        Dim result As String = Await webView.CoreWebView2.CallDevToolsProtocolMethodAsync(
            "Page.printToPDF",
            JsonSerializer.Serialize(options)
        )

        Dim base64 As String = JsonDocument.Parse(result).RootElement.GetProperty("data").GetString()
        File.WriteAllBytes("output.pdf", Convert.FromBase64String(base64))
    End Function
End Module
$vbLabelText   $csharpLabel

WebView2 utilise des pouces pour les dimensions, nécessite des objets anonymes et la sérialisation JSON, et maintient le flux asynchrone complexe avec des gestionnaires d'événements et des délais de temporisation.

Configuration des options de rendu IronPDF

IronPDF fournit une configuration fortement typée par le biais de la propriété RenderingOptions :

// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter;
        renderer.RenderingOptions.MarginTop = 40;
        renderer.RenderingOptions.MarginBottom = 40;
        renderer.RenderingOptions.MarginLeft = 40;
        renderer.RenderingOptions.MarginRight = 40;
        renderer.RenderingOptions.PrintHtmlBackgrounds = true;

        var pdf = renderer.RenderHtmlFileAsPdf("document.html");
        pdf.SaveAs("output.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter;
        renderer.RenderingOptions.MarginTop = 40;
        renderer.RenderingOptions.MarginBottom = 40;
        renderer.RenderingOptions.MarginLeft = 40;
        renderer.RenderingOptions.MarginRight = 40;
        renderer.RenderingOptions.PrintHtmlBackgrounds = true;

        var pdf = renderer.RenderHtmlFileAsPdf("document.html");
        pdf.SaveAs("output.pdf");
    }
}
Imports IronPdf
Imports IronPdf.Rendering

Class Program
    Shared Sub Main()
        Dim renderer = New ChromePdfRenderer()
        renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter
        renderer.RenderingOptions.MarginTop = 40
        renderer.RenderingOptions.MarginBottom = 40
        renderer.RenderingOptions.MarginLeft = 40
        renderer.RenderingOptions.MarginRight = 40
        renderer.RenderingOptions.PrintHtmlBackgrounds = True

        Dim pdf = renderer.RenderHtmlFileAsPdf("document.html")
        pdf.SaveAs("output.pdf")
    End Sub
End Class
$vbLabelText   $csharpLabel

IronPDF utilise les millimètres pour les mesures précises, fournit des enums PdfPaperSize pour les tailles de papier standard, et offre des méthodes dédiées comme RenderHtmlFileAsPdf() pour le contenu basé sur des fichiers.

Fichier HTML vers PDF avec orientation personnalisée

La conversion de fichiers HTML avec orientation paysage démontre l'approche PrintSettings par rapport à RenderingOptions.

WebView2PrintSettings Approach (Approche des paramètres d'impression)

WebView2 offre une méthode alternative PrintToPdfAsync avec CoreWebView2PrintSettings :

// NuGet: Install-Package Microsoft.Web.WebView2.WinForms
using System;
using System.IO;
using System.Threading.Tasks;
using Microsoft.Web.WebView2.Core;
using Microsoft.Web.WebView2.WinForms;

class Program
{
    static async Task Main()
    {
        var webView = new WebView2();
        await webView.EnsureCoreWebView2Async();

        string htmlFile = Path.Combine(Directory.GetCurrentDirectory(), "input.html");
        webView.CoreWebView2.Navigate(htmlFile);

        await Task.Delay(3000);

        var printSettings = webView.CoreWebView2.Environment.CreatePrintSettings();
        printSettings.Orientation = CoreWebView2PrintOrientation.Landscape;
        printSettings.MarginTop = 0.5;
        printSettings.MarginBottom = 0.5;

        using (var stream = await webView.CoreWebView2.PrintToPdfAsync("custom.pdf", printSettings))
        {
            Console.WriteLine("Custom PDF created");
        }
    }
}
// NuGet: Install-Package Microsoft.Web.WebView2.WinForms
using System;
using System.IO;
using System.Threading.Tasks;
using Microsoft.Web.WebView2.Core;
using Microsoft.Web.WebView2.WinForms;

class Program
{
    static async Task Main()
    {
        var webView = new WebView2();
        await webView.EnsureCoreWebView2Async();

        string htmlFile = Path.Combine(Directory.GetCurrentDirectory(), "input.html");
        webView.CoreWebView2.Navigate(htmlFile);

        await Task.Delay(3000);

        var printSettings = webView.CoreWebView2.Environment.CreatePrintSettings();
        printSettings.Orientation = CoreWebView2PrintOrientation.Landscape;
        printSettings.MarginTop = 0.5;
        printSettings.MarginBottom = 0.5;

        using (var stream = await webView.CoreWebView2.PrintToPdfAsync("custom.pdf", printSettings))
        {
            Console.WriteLine("Custom PDF created");
        }
    }
}
Imports System
Imports System.IO
Imports System.Threading.Tasks
Imports Microsoft.Web.WebView2.Core
Imports Microsoft.Web.WebView2.WinForms

Module Program
    Async Function Main() As Task
        Dim webView As New WebView2()
        Await webView.EnsureCoreWebView2Async()

        Dim htmlFile As String = Path.Combine(Directory.GetCurrentDirectory(), "input.html")
        webView.CoreWebView2.Navigate(htmlFile)

        Await Task.Delay(3000)

        Dim printSettings = webView.CoreWebView2.Environment.CreatePrintSettings()
        printSettings.Orientation = CoreWebView2PrintOrientation.Landscape
        printSettings.MarginTop = 0.5
        printSettings.MarginBottom = 0.5

        Using stream = Await webView.CoreWebView2.PrintToPdfAsync("custom.pdf", printSettings)
            Console.WriteLine("Custom PDF created")
        End Using
    End Function
End Module
$vbLabelText   $csharpLabel

Notez le Task.Delay de 3 secondes - une attente arbitraire encore plus longue pour s'assurer que le contenu se charge avant l'impression.

Configuration simplifiée d'IronPDF

IronPDF s'acquitte de la même tâche avec des paramètres explicites et sans deviner le timing :

// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;
using System;
using System.IO;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;
        renderer.RenderingOptions.MarginTop = 50;
        renderer.RenderingOptions.MarginBottom = 50;

        string htmlFile = Path.Combine(Directory.GetCurrentDirectory(), "input.html");
        var pdf = renderer.RenderHtmlFileAsPdf(htmlFile);
        pdf.SaveAs("custom.pdf");

        Console.WriteLine("Custom PDF created");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;
using System;
using System.IO;

class Program
{
    static void Main()
    {
        var renderer = new ChromePdfRenderer();

        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;
        renderer.RenderingOptions.MarginTop = 50;
        renderer.RenderingOptions.MarginBottom = 50;

        string htmlFile = Path.Combine(Directory.GetCurrentDirectory(), "input.html");
        var pdf = renderer.RenderHtmlFileAsPdf(htmlFile);
        pdf.SaveAs("custom.pdf");

        Console.WriteLine("Custom PDF created");
    }
}
Imports IronPdf
Imports IronPdf.Rendering
Imports System
Imports System.IO

Module Program
    Sub Main()
        Dim renderer As New ChromePdfRenderer()

        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape
        renderer.RenderingOptions.MarginTop = 50
        renderer.RenderingOptions.MarginBottom = 50

        Dim htmlFile As String = Path.Combine(Directory.GetCurrentDirectory(), "input.html")
        Dim pdf = renderer.RenderHtmlFileAsPdf(htmlFile)
        pdf.SaveAs("custom.pdf")

        Console.WriteLine("Custom PDF created")
    End Sub
End Module
$vbLabelText   $csharpLabel

Référence de mappage d'API

Les équipes qui évaluent une transition de WebView2àIronPDFtrouveront cette cartographie utile pour comprendre les équivalences de concepts :

API WebView2 Équivalent d'IronPDF
new WebView2() new ChromePdfRenderer()
EnsureCoreWebView2Async() N/A
NavigateToString(html) + PrintToPdfAsync() RenderHtmlAsPdf(html)
Navigate(url) + PrintToPdfAsync() RenderUrlAsPdf(url)
Navigate(file) + PrintToPdfAsync() RenderHtmlFileAsPdf(file)
PrintSettings.PageWidth RenderingOptions.PaperSize
PrintSettings.PageHeight RenderingOptions.PaperSize
PrintSettings.MarginTop RenderingOptions.MarginTop
PrintSettings.Orientation RenderingOptions.PaperOrientation
Événements de navigation WaitFor.JavaScript()
printBackground : true PrintHtmlBackgrounds = true

Quand les équipes envisagent de passer de WebView2à IronPDF

Plusieurs scénarios incitent couramment les équipes de développement à évaluerIronPDFcomme alternative à WebView2:

Exigences multiplateformes

La limitation de WebView2à Windows uniquement le rend inadapté aux applications ciblant les serveurs Linux, les conteneurs Docker ou les environnements en nuage. Les équipes déployant sur Azure, AWS, GCP ou une infrastructure conteneurisée ne peuvent pas utiliser WebView2pour la génération de PDF.

Génération de PDF côté serveur

L'exigence du thread d'interface utilisateur de WebView2avec STA et pompe à messages le rend fondamentalement incompatible avec ASP.NET Core, les services d'arrière-plan ou les points d'extrémité d'API. Les applications nécessitant la génération de PDF en réponse à des requêtes web ne peuvent pas utiliser WebView2.

Préoccupations relatives à la stabilité de la mémoire

Les fuites de mémoire documentées de WebView2dans les processus de longue durée provoquent des pannes de serveur dans les environnements de production. Les applications qui génèrent des PDF en continu tout au long de la journée accumulent de la mémoire jusqu'à ce qu'une panne de mémoire se produise.

Exigences en matière de fonctionnalités du PDF

Le PrintToPdfAsync de WebView2ne fournit qu'une conversion de base de HTML en PDF. Les équipes qui ont besoin d'en-têtes/pieds de page, de filigranes, de fusion/division de PDF, de signatures numériques, de protection par mot de passe ou de conformité PDF/A doivent chercher ailleurs.

Développement simplifié

Le flux asynchrone complexe requis par WebView2- initialisation, événements de navigation, rappels d'achèvement, délais de temporisation, sérialisation JSON, décodage Base64 - introduit un surcoût de développement et de maintenance important par rapport à l'approche à méthode unique d'IronPDF.

Capacités supplémentaires d'IronPDF

Au-delà de la génération basique de PDF,IronPDFoffre des fonctionnalités de manipulation de documents que WebView2ne peut pas proposer :

Compatibilité .NET et préparation à l'avenir

L'architecture Windows de WebView2limite son avenir dans un écosystème .NET de plus en plus multiplateforme.IronPDFmaintient un développement actif avec des mises à jour régulières, garantissant la compatibilité avec .NET 8, .NET 9 et les futures versions, notamment .NET 10 prévue en 2026. La prise en charge de l'asynchronisme et de l'attente dans l'ensemble de l'API de la bibliothèque s'aligne sur les pratiques de développement C# modernes, y compris les fonctionnalités prévues dans C# 14.

Conclusion

WebView2 etIronPDFreprésentent des approches fondamentalement différentes de la génération de PDF dans .NET. WebView2est un contrôle intégré au navigateur qui prend en charge l'impression de fichiers PDF - une fonctionnalité secondaire qui présente des limites importantes pour une utilisation en production. La restriction à la plateforme Windows, l'exigence d'un thread UI, les problèmes de fuites de mémoire et le manque de fonctionnalités spécifiques au PDF le rendent inadapté aux charges de travail sérieuses liées à la génération de PDF.

IronPDF est une bibliothèque PDF conçue spécifiquement pour la conversion de HTML en PDF avec un support multiplateforme, des capacités côté serveur et des fonctionnalités complètes de manipulation de PDF. Son API rationalisée élimine les schémas asynchrones complexes, la gestion des événements et les bidouillages de synchronisation dont WebView2a besoin.

Pour les équipes qui utilisent actuellement WebView2pour la génération de PDF, les problèmes de stabilité documentés, les limitations de la plateforme et les lacunes des fonctionnalités rendent essentielle l'évaluation d'alternatives conçues à cet effet. Le mappage des API entre WebView2etIronPDFest simple,IronPDFnécessitant systématiquement moins de code et éliminant les contraintes architecturales imposées par WebView2.

Pour des conseils de mise en œuvre supplémentaires, explorez la documentation IronPDF et les tutoriels couvrant des cas d'utilisation spécifiques et des fonctionnalités avancées.