Iron Suite for .NET

10 bibliothèques .NET. Une suite de documents complète.

Découvrez Iron Suite

IRONPDF

IRONWORD

IRONXL

IRONPPT

IRONOCR

IRONBARCODE

IRONQR

IRONPRINT

IRONZIP

IRONWEBSCRAPER

COMPARAISON

RawPrint .NET vs IronPDF : Guide de comparaison technique

Curtis Chau

Updated: 21 avril 2026

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 WebView2et IronPDF:

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 WebView2et IronPDF deviennent immédiatement évidentes lorsqu'on examine la façon dont chaque approche gère la génération de PDF.

Modèle Asynchrone Complexe de WebView2

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

' NuGet: Install-Package Microsoft.Web.WebView2.WinForms
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

' NuGet: Install-Package Microsoft.Web.WebView2.WinForms
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

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 supposition peu fiable quant à la disponibilité du contenu—une condition de concurrence en attente de 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

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

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

' NuGet: Install-Package Microsoft.Web.WebView2.WinForms
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

' NuGet: Install-Package Microsoft.Web.WebView2.WinForms
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

Cette implémentation nécessite de créer un TaskCompletionSource pour suivre la navigation, s'abonner aux événements NavigationCompleted, analyser les réponses JSON du protocole DevTools, et gérer le décodage Base64. Le Task.Delay(1000) supplémentaire après l'achèvement de la navigation tente de s'assurer que JavaScript a fini d'exécuter—un autre hack 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

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

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

' NuGet: Install-Package Microsoft.Web.WebView2.WinForms
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 = 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 = Await webView.CoreWebView2.CallDevToolsProtocolMethodAsync(
            "Page.printToPDF",
            JsonSerializer.Serialize(options)
        )
        
        Dim base64 = JsonDocument.Parse(result).RootElement.GetProperty("data").GetString()
        File.WriteAllBytes("output.pdf", Convert.FromBase64String(base64))
    End Function
End Module

' NuGet: Install-Package Microsoft.Web.WebView2.WinForms
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 = 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 = Await webView.CoreWebView2.CallDevToolsProtocolMethodAsync(
            "Page.printToPDF",
            JsonSerializer.Serialize(options)
        )
        
        Dim base64 = JsonDocument.Parse(result).RootElement.GetProperty("data").GetString()
        File.WriteAllBytes("output.pdf", Convert.FromBase64String(base64))
    End Function
End Module

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

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports IronPdf.Rendering

Module Program
    Sub Main()
        Dim renderer As 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 Module

' NuGet: Install-Package IronPdf
Imports IronPdf
Imports IronPdf.Rendering

Module Program
    Sub Main()
        Dim renderer As 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 Module

IronPDF utilise des millimètres pour des mesures précises, fournit des enums PdfPaperSize pour des 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");
        }
    }
}

' NuGet: Install-Package Microsoft.Web.WebView2.WinForms
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

' NuGet: Install-Package Microsoft.Web.WebView2.WinForms
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

Notez le Task.Delay de 3 secondes—un temps d'attente arbitraire encore plus long essayant d'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");
    }
}

' NuGet: Install-Package IronPdf
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

' NuGet: Install-Package IronPdf
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

Référence de mappage d'API

Les équipes qui évaluent une transition de WebView2à IronPDF trouveront 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 à évaluer IronPDF comme 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 HTML vers PDF de base. 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,IronPDF offre des fonctionnalités de manipulation de documents que WebView2ne peut pas proposer :

Fusionner des PDF: Combiner plusieurs documents en un seul fichier
Division de documents: Extraire des plages de pages dans des PDF distincts
Signatures numériques: Appliquer des signatures cryptographiques pour l'authenticité des documents
Watermarking: Ajouter des filigranes de texte ou d'image
**Conformité IronPDF/A:**Générer des documents conformes aux normes d'archivage
Form Filling: Remplir par programme les champs d'un formulaire PDF
En-têtes et pieds de page: Numérotation des pages et marquage automatiques
Protection par mot de passe: Chiffrer les PDF avec les mots de passe de l'utilisateur et du propriétaire
Déploiement Docker: Images de conteneurs officielles pour le déploiement Linux

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

L'architecture Windows de WebView2limite son avenir dans un écosystème .NET de plus en plus multiplateforme.IronPDF maintient 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 et IronPDF repré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 WebView2et IronPDF est simple,IronPDF né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.

Veuillez noter: WebView2 est une marque déposée de son propriétaire respectif. Ce site n'est pas affilié à Microsoft, ni approuvé par elle, ni sponsorisé par elle. Tous les noms de produits, logos et marques sont la propriété de leurs propriétaires respectifs. Les comparaisons sont à titre informatif uniquement et reflètent les informations publiquement disponibles au moment de l'écriture.