GUIDES DE MIGRATION

Comment migrer de WebView2 à IronPDF en C#

Mis à jour:1 février 2026

WebView2, le contrôle de navigateur Edge/Chromium intégrable de Microsoft, offre aux développeurs un moyen d'afficher du contenu web dans les applications Windows. Cependant, lorsque les équipes de développement tentent d'utiliser WebView2pour la génération de PDF, elles se heurtent à de sérieuses limitations architecturales qui le rendent inadapté aux environnements de production. WebView2est un contrôle d'intégration au navigateur conçu pour les applications d'interface utilisateur, et non une bibliothèque de génération de PDF.

Ce guide fournit un chemin de migration complet de WebView2à IronPDF, avec des instructions étape par étape, des comparaisons de code et des exemples pratiques pour les développeurs .NET professionnels qui ont besoin d'une génération fiable de PDF dans leurs applications.

Avertissement critique : WebView2n'est PAS adapté à la génération de PDF

Avant d'examiner la voie de la migration, les équipes de développement doivent comprendre pourquoi WebView2pose d'importants problèmes lorsqu'il est utilisé pour la création de PDF :

Problématique	Impact	Sévérité
Fuites de mémoire	WebView2présente des fuites de mémoire bien documentées dans les processus de longue durée. Votre serveur va tomber en panne.	CRITIQUE
Fenêtres uniquement	Aucune prise en charge de Linux, macOS, Docker ou des environnements en nuage	CRITIQUE
Filière UI requise	Doit être exécuté sur STA thread avec message pump. Ne peut pas fonctionner avec des serveurs web ou des API.	CRITIQUE
Non conçu pour les PDF	`PrintToPdfAsync` est une fonctionnalité ajoutée après coup, et non une fonctionnalité essentielle.	HAUT
Instable dans les services	Crashs et blocages fréquents dans les services Windows et les travailleurs en arrière-plan	HAUT
Flux asynchrone complexe	Événements de navigation, rappels d'achèvement, conditions de course	HAUT
Dépendance d'exécution Edge	Nécessite l'installation de 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
Performance	Démarrage lent, forte consommation de ressources	MOYEN
Pas de support professionnel	Microsoft ne prend pas en charge le cas d'utilisation de la génération de PDF	MOYEN

Scénarios d'échec dans le monde réel

Ces modèles de code provoquent des échecs de production :

// DANGER: This code WILL cause problems in production

// Problématique1: Memory leak - creates new WebView2for each PDF
public async Task<byte[]> GeneratePdf(string html) // Called 1000x/day = server crash
{
    using var webView = new WebView2(); // Memory not fully released!
    await webView.EnsureCoreWebView2Async();
    webView.CoreWebView2.NavigateToString(html);
    // ... memory accumulates until OOM
}

// Problématique2: UI thread requirement - crashes in ASP.NET
public IActionResult GenerateReport() // FAILS - no STA thread
{
    var webView = new WebView2(); // InvalidOperationException
}

// Problématique3: Windows Service instability
public class PdfService : BackgroundService // Random crashes
{
    protected override async Task ExecuteAsync(CancellationToken token)
    {
        // WebView2+ no message pump = hangs, crashes, undefined behavior
    }
}

// DANGER: This code WILL cause problems in production

// Problématique1: Memory leak - creates new WebView2for each PDF
public async Task<byte[]> GeneratePdf(string html) // Called 1000x/day = server crash
{
    using var webView = new WebView2(); // Memory not fully released!
    await webView.EnsureCoreWebView2Async();
    webView.CoreWebView2.NavigateToString(html);
    // ... memory accumulates until OOM
}

// Problématique2: UI thread requirement - crashes in ASP.NET
public IActionResult GenerateReport() // FAILS - no STA thread
{
    var webView = new WebView2(); // InvalidOperationException
}

// Problématique3: Windows Service instability
public class PdfService : BackgroundService // Random crashes
{
    protected override async Task ExecuteAsync(CancellationToken token)
    {
        // WebView2+ no message pump = hangs, crashes, undefined behavior
    }
}

' DANGER: This code WILL cause problems in production

' Problématique1: Memory leak - creates new WebView2 for each PDF
Public Async Function GeneratePdf(html As String) As Task(Of Byte()) ' Called 1000x/day = server crash
    Using webView As New WebView2() ' Memory not fully released!
        Await webView.EnsureCoreWebView2Async()
        webView.CoreWebView2.NavigateToString(html)
        ' ... memory accumulates until OOM
    End Using
End Function

' Problématique2: UI thread requirement - crashes in ASP.NET
Public Function GenerateReport() As IActionResult ' FAILS - no STA thread
    Dim webView As New WebView2() ' InvalidOperationException
    ' Additional implementation needed
    Return Nothing
End Function

' Problématique3: Windows Service instability
Public Class PdfService
    Inherits BackgroundService ' Random crashes

    Protected Overrides Async Function ExecuteAsync(token As CancellationToken) As Task
        ' WebView2+ no message pump = hangs, crashes, undefined behavior
    End Function
End Class

$vbLabelText $csharpLabel

IronPDF vs WebView2: Comparaison des fonctionnalités

La compréhension des différences architecturales aide les décideurs techniques à évaluer l'investissement dans la migration :

Aspect	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
Contextes pris en charge	WinForms/WPF uniquement	Tout contexte .NET : console, web, bureau
HTML à PDF	Basique	Complet
URL vers PDF	Basique	Complet
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
Support professionnel	Aucune pour PDF	Oui
Documentation	Limité	Complète

Démarrage rapide : Migration de WebView2vers IronPDF

La migration peut commencer immédiatement grâce à ces étapes fondamentales.

Étape 1 : Supprimer le paquet WebView2

dotnet remove package Microsoft.Web.WebView2

dotnet remove package Microsoft.Web.WebView2

SHELL

Ou supprimez-la de votre fichier de projet :


<PackageReference Include="Microsoft.Web.WebView2" Version="*" Remove />


<PackageReference Include="Microsoft.Web.WebView2" Version="*" Remove />

XML

Étape 2 : Installer IronPDF

dotnet add package IronPdf

dotnet add package IronPdf

SHELL

Étape 3 : Mise à jour des espaces de noms

Remplacer les espaces de noms WebView2par l'espace de nomsIronPDF:

// Before (WebView2)
using Microsoft.Web.WebView2.Core;
using Microsoft.Web.WebView2.WinForms;

// After (IronPDF)
using IronPdf;

// Before (WebView2)
using Microsoft.Web.WebView2.Core;
using Microsoft.Web.WebView2.WinForms;

// After (IronPDF)
using IronPdf;

Imports Microsoft.Web.WebView2.Core
Imports Microsoft.Web.WebView2.WinForms

' After (IronPDF)
Imports IronPdf

$vbLabelText $csharpLabel

Étape 4 : initialisation de la licence

Ajouter l'initialisation de la licence au démarrage de l'application :

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

$vbLabelText $csharpLabel

Exemples de migration de code

Conversion de HTML en PDF

L'opération la plus fondamentale révèle la différence de complexité entre ces approches PDF .NET.

Approche deWebView2:

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

Approche IronPDF:

// 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 version WebView2nécessite une initialisation asynchrone avec EnsureCoreWebView2Async(), une navigation via NavigateToString(), un Task.Delay(2000) peu fiable pour attendre le rendu et une interaction avec le protocole DevTools.IronPDFélimine entièrement cette cérémonie - créer un moteur de rendu, effectuer le rendu HTML, enregistrer.

Pour les scénarios avancés de conversion de HTML en PDF, voir le guide de conversion de HTML en PDF.

Conversion des URL en PDF

La conversion d'URL en PDF démontre le flux de navigation asynchrone complexe de WebView2.

Approche deWebView2:

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

Approche IronPDF:

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

WebView2 nécessite la création d'un TaskCompletionSource, l'abonnement aux événements NavigationCompleted, l'appel de CallDevToolsProtocolMethodAsync, l'analyse des réponses JSON et le décodage des données base64.IronPDFfournit une méthode dédiée RenderUrlAsPdf qui gère toute la complexité en interne.

Explorez la URL vers la documentation PDF pour l'authentification et les options d'en-tête personnalisées.

Paramètres PDF personnalisés à partir de fichiers HTML

La configuration de l'orientation des pages, des marges et de la taille du papier nécessite différentes approches.

Approche deWebView2:

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

Approche IronPDF:

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

WebView2 nécessite un Task.Delay de 3 secondes (une supposition peu fiable), créant des paramètres d'impression via l'environnement et utilisant PrintToPdfAsync avec un flux.IronPDFfournit des propriétés directes RenderingOptions avec des noms clairs et utilise les millimètres pour des mesures plus précises.

Options PDF avancées avec DevTools Protocol

Les configurations complexes de WebView2nécessitent une interaction avec le protocole DevTools.

Approche deWebView2:

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

Approche IronPDF:

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

WebView2 nécessite la construction d'objets anonymes, leur sérialisation en JSON, l'appel de méthodes du protocole DevTools, l'analyse des réponses JSON et le décodage manuel du base64.IronPDFfournit des propriétés typées avec des noms clairs et des valeurs d'énumération comme PdfPaperSize.Letter.

Référence de mappage de l'APIWebView2 vers IronPDF

Cette cartographie accélère la migration en indiquant les équivalents directs des API :

API WebView2	Équivalent d'IronPDF
`new WebView2()`	`new ChromePdfRenderer()`
`EnsureCoreWebView2Async()`	N/A
`NavigateToString(html)` + `PrintToPdfAsync()`	`RenderHtmlAsPdf(html)`
`Navigate(url)` + `PrintToPdfAsync()`	`RenderUrlAsPdf(url)`
`PrintSettings.PageWidth`	`RenderingOptions.PaperSize`
`PrintSettings.PageHeight`	`RenderingOptions.PaperSize`
`PrintSettings.MarginTop`	`RenderingOptions.MarginTop`
`PrintSettings.Orientation`	`RenderingOptions.PaperOrientation`
`ExecuteScriptAsync()`	JavaScript en HTML
`AddScriptToExecuteOnDocumentCreatedAsync()`	HTML `<script>` balises
Événements de navigation	`WaitFor.JavaScript()`
`CallDevToolsProtocolMethodAsync("Page.printToPDF")`	`RenderHtmlAsPdf()`

Problèmes de migration courants et solutions

Édition 1 : Fuites de mémoire

Problème WebView2: La mémoire n'est pas entièrement libérée lors de l'élimination des instances WebView2. Les processus en cours d'exécution accumulent de la mémoire jusqu'à ce qu'ils se bloquent.

La solutionIronPDF: Une collecte des déchets correcte et sans fuites :

//IronPDF- clean memory management
using (var pdf = renderer.RenderHtmlAsPdf(html))
{
    pdf.SaveAs("output.pdf");
} // Properly disposed

//IronPDF- clean memory management
using (var pdf = renderer.RenderHtmlAsPdf(html))
{
    pdf.SaveAs("output.pdf");
} // Properly disposed

Imports IronPdf

Using pdf = renderer.RenderHtmlAsPdf(html)
    pdf.SaveAs("output.pdf")
End Using

$vbLabelText $csharpLabel

Édition 2 : Pas de fil d'Ariane dans les applications web

ProblèmeWebView2: Requiert un thread STA avec une pompe à messages. Les contrôleurs ASP.NET Core ne peuvent pas créer d'instances de WebView2.

La solution IronPDF: Fonctionne sur n'importe quel fil :

// ASP.NET Core - just works
public async Task<IActionResult> GetPdf()
{
    var pdf = await renderer.RenderHtmlAsPdfAsync(html);
    return File(pdf.BinaryData, "application/pdf");
}

// ASP.NET Core - just works
public async Task<IActionResult> GetPdf()
{
    var pdf = await renderer.RenderHtmlAsPdfAsync(html);
    return File(pdf.BinaryData, "application/pdf");
}

Imports System.Threading.Tasks
Imports Microsoft.AspNetCore.Mvc

Public Class YourController
    Inherits Controller

    Public Async Function GetPdf() As Task(Of IActionResult)
        Dim pdf = Await renderer.RenderHtmlAsPdfAsync(html)
        Return File(pdf.BinaryData, "application/pdf")
    End Function
End Class

$vbLabelText $csharpLabel

Problème WebView2 : Doit gérer les événements de navigation asynchrones, les rappels d'achèvement et les conditions de concurrence avec TaskCompletionSource.

SolutionIronPDF: Appel de méthode unique synchrone ou asynchrone :

// Simple and predictable
var pdf = renderer.RenderHtmlAsPdf(html);
// or
var pdf = await renderer.RenderHtmlAsPdfAsync(html);

// Simple and predictable
var pdf = renderer.RenderHtmlAsPdf(html);
// or
var pdf = await renderer.RenderHtmlAsPdfAsync(html);

$vbLabelText $csharpLabel

Edition 4 : Unités de mesure

WebView2 utilise les pouces pour les dimensions (8.5 x 11 pour Letter). IronPDF utilise des millimètres pour des mesures plus précises.

Approche de conversion:

// WebView2: PageWidth = 8.27 (inches for A4)
// IronPDF: Use enum
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;

// Or custom size in mm
renderer.RenderingOptions.SetCustomPaperSizeInMillimeters(210, 297);

// WebView2: PageWidth = 8.27 (inches for A4)
// IronPDF: Use enum
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;

// Or custom size in mm
renderer.RenderingOptions.SetCustomPaperSizeInMillimeters(210, 297);

' WebView2: PageWidth = 8.27 (inches for A4)
' IronPDF: Use enum
renderer.RenderingOptions.PaperSize = PdfPaperSize.A4

' Or custom size in mm
renderer.RenderingOptions.SetCustomPaperSizeInMillimeters(210, 297)

$vbLabelText $csharpLabel

Liste de contrôle pour la migration versWebView2

Tâches préalables à la migration

Documentez tout le code de génération de PDF WebView2dans votre base de code. Identifier où WebView2pose des problèmes (fuites de mémoire, plantages, problèmes de déploiement). Consultez la documentation IronPDF pour vous familiariser avec les capacités.

Tâches de mise à jour du code

Supprimer le paquet NuGet Microsoft.Web.WebView2
Installer le paquet NuGet IronPDF
Supprimer les dépendances WinForms/WPF si elles ne sont utilisées que pour la génération de PDF
Remplacez le code WebView2par ChromePdfRenderer
Supprimer les exigences relatives aux fils STA
Supprimez les gestionnaires d'événements de navigation et les modèles TaskCompletionSource
Supprimer Task.Delay hacks
Ajouter l'initialisation de la licenceIronPDFau démarrage

Test de post-migration

Après la migration, vérifiez ces aspects :

Test dans l'environnement cible (ASP.NET, Docker, Linux le cas échéant)
Vérifier que la qualité de la sortie PDF correspond aux attentes
Tester le bon rendu des pages contenant beaucoup de JavaScript
Vérifier que les en-têtes et les pieds de page fonctionnent avec les capacités HTML d'IronPDF
Test de charge pour la stabilité de la mémoire lors d'opérations prolongées
Tester des scénarios de longue durée sans accumulation de mémoire

Mises à jour du déploiement

Mettre à jour les images Docker le cas échéant (supprimer Edge WebView2Runtime)
Supprimer la dépendance Edge WebView2Runtime des exigences du serveur
Mise à jour de la documentation sur les exigences du serveur
Vérifier que le déploiement multiplateforme fonctionne sur les plateformes cibles

Avantages clés de la migration vers IronPDF

Le passage de WebView2àIronPDFprésente plusieurs avantages décisifs :

Compatibilité multiplateforme : contrairement à WebView2, limité à Windows,IronPDFfonctionne sous Windows, Linux, macOS et Docker. Cette flexibilité permet un déploiement sur Azure, AWS, GCP et tout autre environnement cloud sans contrainte de plateforme.

Aucune dépendance à l'interface utilisateur :IronPDFne nécessite ni threads STA, ni boucles de messages, ni contextes WinForms/WPF. Elle fonctionne dans les applications en console, les API web, les services Windows et les travailleurs en arrière-plan.

Stabilité de la mémoire : Un système de récupération des déchets efficace élimine les fuites de mémoire qui affectent WebView2dans les processus de longue durée. Les serveurs de production doivent rester stables.

API simple : des appels de méthode uniques remplacent les événements de navigation complexes, les rappels d'achèvement, les interactions avec le protocole DevTools et le décodage base64.

Fonctionnalités PDF étendues : en-têtes, pieds de page, filigranes, fusion/séparation, signatures numériques, protection par mot de passe et conformité PDF/A — des fonctionnalités que WebView2ne peut pas fournir.

Développement actif : Avec l'adoption croissante de .NET 10 et C# 14 jusqu'en 2026, les mises à jour régulières d'IronPDF garantissent la compatibilité avec les versions actuelles et futures de .NET .

Curtis Chau

Discutez maintenant avec l'équipe d'ingénierie

Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Articles connexes

Mis à jour1 février 2026

Comment migrer de ZetPDF à IronPDF en C#

Maîtrisez la migration de ZetPDF vers IronPDF grâce à ce guide C# complet. Passez d'une bibliothèque basée sur les coordonnées à une solution HTML-PDF moderne. Inclut des exemples de code pour la conversion HTML, la fusion de PDF et la suppression des dépendances PDFSharp.

Mis à jour1 février 2026

Comment migrer de Scryber.Core vers IronPDF en C#

Maîtrisez la migration de Scryber.Core vers IronPDF grâce à ce guide complet en C#. Passez d'une analyse XML/HTML personnalisée à un moteur de rendu moderne Chromium. Inclut des exemples de code pour la conversion HTML, le rendu d'URL et le remplacement des liaisons propriétaires.

Mis à jour1 février 2026

Comment migrer de XFINIUM.PDF vers IronPDF en C#

Maîtrisez la migration de XFINIUM.PDF vers IronPDF grâce à ce guide C# complet. Passez d'un positionnement manuel basé sur les coordonnées à un rendu HTML/CSS déclaratif. Inclut des exemples de code pour le remplacement des primitives graphiques et la mise en page automatique.

Comment migrer de Winnovative vers IronPDF en C#

Comment migrer de VectSharp à Iron...

Mise en avant du client :

Projecteur sur les Développeurs:

Webinaires:

Essai gratuit de 30 jours

Comment migrer de WebView2 à IronPDF en C#

Avertissement critique : WebView2n'est PAS adapté à la génération de PDF

Scénarios d'échec dans le monde réel

IronPDF vs WebView2: Comparaison des fonctionnalités

Démarrage rapide : Migration de WebView2vers IronPDF

Étape 1 : Supprimer le paquet WebView2

Étape 2 : Installer IronPDF

Étape 3 : Mise à jour des espaces de noms

Étape 4 : initialisation de la licence

Exemples de migration de code

Conversion de HTML en PDF

Conversion des URL en PDF

Paramètres PDF personnalisés à partir de fichiers HTML

Options PDF avancées avec DevTools Protocol

Référence de mappage de l'APIWebView2 vers IronPDF

Problèmes de migration courants et solutions

Édition 1 : Fuites de mémoire

Édition 2 : Pas de fil d'Ariane dans les applications web

Édition 3 : Complexité des événements de navigation

Edition 4 : Unités de mesure

Liste de contrôle pour la migration versWebView2

Tâches préalables à la migration

Tâches de mise à jour du code

Test de post-migration

Mises à jour du déploiement

Avantages clés de la migration vers IronPDF

Équipe de soutien Iron

Essai gratuit de 30 jours

Comment migrer de WebView2 à IronPDF en C#

Avertissement critique : WebView2n'est PAS adapté à la génération de PDF

Scénarios d'échec dans le monde réel

IronPDF vs WebView2: Comparaison des fonctionnalités

Démarrage rapide : Migration de WebView2vers IronPDF

Étape 1 : Supprimer le paquet WebView2

Étape 2 : Installer IronPDF

Étape 3 : Mise à jour des espaces de noms

Étape 4 : initialisation de la licence

Exemples de migration de code

Conversion de HTML en PDF

Conversion des URL en PDF

Paramètres PDF personnalisés à partir de fichiers HTML

Options PDF avancées avec DevTools Protocol

Référence de mappage de l'APIWebView2 vers IronPDF

Problèmes de migration courants et solutions

Édition 1 : Fuites de mémoire

Édition 2 : Pas de fil d'Ariane dans les applications web

Édition 3 : Complexité des événements de navigation

Edition 4 : Unités de mesure

Liste de contrôle pour la migration versWebView2

Tâches préalables à la migration

Tâches de mise à jour du code

Test de post-migration

Mises à jour du déploiement

Avantages clés de la migration vers IronPDF

Articles connexes

Comment migrer de ZetPDF à IronPDF en C#

Comment migrer de Scryber.Core vers IronPDF en C#

Comment migrer de XFINIUM.PDF vers IronPDF en C#

Want to deploy IronSuite to a live project for FREE?

What’s included?

Thank You

Want to deploy IronSuite to a live project for FREE?

What’s included?

De confiance par des millions d'ingénieurs dans le monde entier

Équipe de soutien Iron