Ícono de mensaje
Saltar al pie de página
  1. IronPDF
  2. Blog de IronPDF
  3. Guías de migración
  4. migración de webview2 a ironpdf
GUíAS DE MIGRACIóN

Cómo migrar de WebView2 a IronPDF en C#

Curtis Chau
Curtis Chau
Publicado:

WebView2, el control de navegador Edge/Chromium integrable de Microsoft, ofrece a los desarrolladores una forma de mostrar contenido web dentro de las aplicaciones de Windows. Sin embargo, cuando los equipos de desarrollo intentan utilizar WebView2para la generación de PDF, se encuentran con serias limitaciones arquitectónicas que lo hacen inadecuado para entornos de producción. WebView2es un control de incrustación en navegador diseñado para aplicaciones de interfaz de usuario, no una biblioteca de generación de PDF.

Esta guía proporciona una ruta de migración completa de WebView2a IronPDF, con instrucciones paso a paso, comparaciones de código y ejemplos prácticos para desarrolladores .NET profesionales que necesitan una generación de PDF fiable en sus aplicaciones.

Advertencia crítica: WebView2NO es adecuado para la generación de PDF

Antes de examinar la ruta de migración, los equipos de desarrollo deben entender por qué WebView2crea problemas significativos cuando se utiliza para la creación de PDF:

Problema Impacto Gravedad
Fugas de memoria WebView2tiene fugas de memoria bien documentadas en procesos de larga duración. Su servidor se bloqueará. CRÍTICA
Sólo para Windows Cero compatibilidad con Linux, macOS, Docker o entornos en la nube CRÍTICA
Se requiere hilo de interfaz de usuario Debe ejecutarse en un hilo STA con bomba de mensajes. No puede funcionar en servidores web o API. CRÍTICA
No diseñado para PDF PrintToPdfAsync es una ocurrencia tardía, no una función principal ALTA
Instable en Servicios Bloqueos y cuelgues comunes en los servicios de Windows y los trabajadores en segundo plano ALTA
Flujo asíncrono complejo Eventos de navegación, devoluciones de llamada de finalización, condiciones de carrera ALTA
Dependencia de tiempo de ejecución de Edge Requiere que Edge WebView2Runtime esté instalado en el equipo de destino MEDIO
Sin modo Headless Crea siempre elementos de interfaz de usuario aunque estén ocultos MEDIO
Rendimiento Arranque lento, gran consumo de recursos MEDIO
Sin Soporte Profesional Microsoft no admite el caso de uso de generación de PDF MEDIO

Escenarios de fallos en el mundo real

Estos patrones de código provocan fallos de producción:

// DANGER: This code WILL cause problems in production

// Problema1: 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
}

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

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

// Problema1: 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
}

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

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

IronPDFfrente a WebView2: comparación de características

Comprender las diferencias arquitectónicas ayuda a los responsables técnicos a evaluar la inversión en migración:

Aspecto WebView2 IronPDF
Objetivo Control del navegador (UI) Biblioteca PDF (diseñada para PDF)
Listo para producción NO SÍ
Gestión de memoria Filtraciones en Estable y con la disposición adecuada
Soporte de Plataforma Sólo para Windows Windows, Linux, macOS, Docker
Requisitos de la traducción STA + Bomba de mensajes Cualquier tema
Servidor/Nube No soportado Soporte completo
Azure/AWS/GCP Problemática Funciona a la perfección
Docker No es posible Imágenes oficiales disponibles
ASP.NET Core No puede trabajar Asistencia de primera clase
Servicios de fondo Inestable Estable
Contextos admitidos Sólo WinForms/WPF Cualquier contexto .NET: consola, web, escritorio
HTML a PDF Básico Completo
URL a PDF Básico Completo
Cabeceras/Pies de página NO Sí (HTML)
Marcas de agua NO Sí
Fusionar PDF NO Sí
Dividir PDF NO Sí
Firmas digitales NO Sí
Protección de contraseñas NO Sí
Cumplimiento de PDF/A NO Sí
Soporte profesional Ninguno para PDF Sí
Documentación Limitado Amplia

Inicio rápido: Migración de WebView2a IronPDF

La migración puede comenzar inmediatamente con estos pasos básicos.

Paso 1: Eliminar el paquete WebView2

dotnet remove package Microsoft.Web.WebView2
dotnet remove package Microsoft.Web.WebView2
SHELL

O eliminar de su archivo de proyecto:


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

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

Paso 2: Instalar IronPDF

dotnet add package IronPdf
dotnet add package IronPdf
SHELL

Paso 3: Actualizar los espacios de nombres

Sustituya los espacios de nombres WebView2por el espacio de nombres IronPdf:

// 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;
$vbLabelText   $csharpLabel

Paso 4: Inicializar licencia

Añadir inicialización de licencia al inicio de la aplicación:

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
$vbLabelText   $csharpLabel

Ejemplos de migración de código

Convertir HTML a PDF

La operación más fundamental revela la diferencia de complejidad entre estos enfoques de .NET PDF.

Enfoque de WebView2:

// 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",
            "{}"
        );
    }
}
$vbLabelText   $csharpLabel

Enfoque 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");
    }
}
$vbLabelText   $csharpLabel

La versión WebView2requiere inicialización asíncrona con EnsureCoreWebView2Async(), navegación mediante NavigateToString(), un Task.Delay(2000) poco fiable para esperar a la renderización, e interacción con el protocolo DevTools.IronPDFelimina por completo esta ceremonia: crear un renderizador, renderizar HTML, guardar.

Para situaciones avanzadas de conversión de HTML a PDF, consulte la Guía de conversión de HTML a PDF.

Convertir URL en PDF

La conversión de URL a PDF demuestra el complejo flujo de navegación asíncrono de WebView2.

Enfoque de WebView2:

// 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));
    }
}
$vbLabelText   $csharpLabel

Enfoque 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");
    }
}
$vbLabelText   $csharpLabel

WebView2 requiere crear un TaskCompletionSource, suscribirse a eventos NavigationCompleted, llamar a CallDevToolsProtocolMethodAsync, analizar respuestas JSON y descodificar datos base64.IronPDFproporciona un método RenderUrlAsPdf dedicado que maneja toda la complejidad internamente.

Explore la URL a la documentación PDF para conocer las opciones de autenticación y encabezado personalizado.

Configuración personalizada de PDF a partir de archivos HTML

La configuración de la orientación de la página, los márgenes y el tamaño del papel requiere distintos enfoques.

Enfoque de WebView2:

// 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");
        }
    }
}
$vbLabelText   $csharpLabel

Enfoque 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");
    }
}
$vbLabelText   $csharpLabel

WebView2 requiere un Task.Delay de 3 segundos (una suposición poco fiable), la creación de configuraciones de impresión a través del entorno y el uso de PrintToPdfAsync con un flujo.IronPDFproporciona propiedades RenderingOptions directas con nombres claros y utiliza milímetros para medidas más precisas.

Opciones avanzadas de PDF con el protocolo DevTools

Las configuraciones complejas de WebView2requieren la interacción con el protocolo DevTools.

Enfoque de WebView2:

// 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));
    }
}
$vbLabelText   $csharpLabel

Enfoque 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");
    }
}
$vbLabelText   $csharpLabel

WebView2 requiere construir objetos anónimos, serializar a JSON, llamar a los métodos del protocolo DevTools, analizar las respuestas JSON y descodificar manualmente base64.IronPDFproporciona propiedades tipificadas con nombres claros y valores enum como PdfPaperSize.Letter.

Referencia de la API de WebView2a IronPDF

Este mapeo acelera la migración al mostrar los equivalentes directos de las API:

API de WebView2 Equivalente de IronPDF Notas
<código>new WebView2()` <código>new ChromePdfRenderer() No se necesita control de interfaz de usuario
<código>EnsureCoreWebView2Async() N/A No requiere inicialización
NavigateToString(html) + PrintToPdfAsync() <código>RenderHtmlAsPdf(html)` Llamada a un solo método
Navigate(url) + PrintToPdfAsync() <código>RenderUrlAsPdf(url)` Llamada a un solo método
<código>PrintSettings.PageWidth <código>RenderingOptions.PaperSize Utilizar el enum PdfPaperSize
<código>PrintSettings.PageHeight <código>RenderingOptions.PaperSize Utilizar el enum PdfPaperSize
<código>PrintSettings.MarginTop <código>RenderingOptions.MarginTop En mm, no en pulgadas
<código>PrintSettings.Orientation <código>RenderingOptions.PaperOrientation Retrato/Paisaje
<código>ExecuteScriptAsync() JavaScript en HTML O utilice las opciones WaitFor
AddScriptToExecuteOnDocumentCreatedAsync() Etiquetas HTML <script> Compatibilidad total con JS
Eventos de navegación WaitFor.JavaScript() Mecanismo de espera limpio
CallDevToolsProtocolMethodAsync("Page.printToPDF") <código>RenderHtmlAsPdf()` Traducción directa

Problemas comunes de migración y soluciones

Tema 1: Fugas de memoria

Problema de WebView2: La memoria no se libera completamente cuando se eliminan las instancias de WebView2. Los procesos de larga duración acumulan memoria hasta que se bloquean.

Solución IronPDF: Recogida de basura adecuada sin fugas:

//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
$vbLabelText   $csharpLabel

Tema 2: Sin hilo de interfaz de usuario en aplicaciones web

Problema de WebView2: Requiere hilo STA con bomba de mensajes. Los controladores ASP.NET Core no pueden crear instancias WebView2.

Solución IronPDF: Funciona en cualquier hilo:

// 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");
}
$vbLabelText   $csharpLabel

Tema 3: Complejidad de los eventos de navegación

Problema de WebView2: Debe manejar eventos de navegación asíncrona, devoluciones de llamada de finalización y condiciones de carrera con TaskCompletionSource.

Solución IronPDF: Llamada a método único síncrono o asíncrono:

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

Número 4: Unidades de medida

WebView2 utiliza pulgadas para las dimensiones (8,5 x 11 para Carta). IronPDF utiliza milímetros para medidas más precisas.

Enfoque de conversión:

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

Lista de comprobación de la migración a WebView2

Tareas previas a la migración

Documente todo el código de generación de PDF de WebView2en su base de código. Identificar dónde WebView2está causando problemas (fugas de memoria, bloqueos, problemas de despliegue). Revise la documentación de IronPDF para familiarizarse con las funciones.

Tareas de actualización de código

  1. Eliminar el paquete NuGet Microsoft.Web.WebView2
  2. Instalación del paquete IronPdf NuGet
  3. Eliminar las dependencias de WinForms/WPF si sólo se utiliza para la generación de PDF
  4. Sustituya el código de WebView2por ChromePdfRenderer
  5. Eliminar los requisitos de hilo STA
  6. Eliminar los controladores de eventos de navegación y los patrones TaskCompletionSource
  7. Eliminar los hacks de Task.Delay
  8. Añadir la inicialización de la licenciaIronPDFal inicio

Pruebas posteriores a la migración

Tras la migración, verifique estos aspectos:

  • Pruebas en el entorno de destino (ASP.NET, Docker, Linux, si procede)
  • Verificación de que la calidad del PDF se ajusta a las expectativas
  • Compruebe que las páginas con mucho JavaScript se visualizan correctamente
  • Compruebe que los encabezados y pies de página funcionan con las funciones HTML de IronPDF
  • Prueba de carga para comprobar la estabilidad de la memoria en operaciones prolongadas
  • Probar escenarios de larga duración sin acumulación de memoria

Actualizaciones de despliegue

  • Actualizar las imágenes Docker si procede (eliminar Edge WebView2Runtime)
  • Eliminar la dependencia de Edge WebView2Runtime de los requisitos del servidor
  • Actualización de la documentación sobre requisitos del servidor
  • Verificar que la implementación multiplataforma funciona en las plataformas de destino

Beneficios clave de migrar a IronPDF

El paso de WebView2aIronPDFofrece varias ventajas fundamentales:

Compatibilidad multiplataforma: a diferencia de la limitación exclusiva de WebView2para Windows,IronPDFfunciona en Windows, Linux, macOS y Docker. Esta flexibilidad permite el despliegue en Azure, AWS, GCP y cualquier entorno en la nube sin limitaciones de plataforma.

Sin dependencias de UI:IronPDFno requiere subprocesos STA, bombas de mensajes o contextos WinForms/WPF. Funciona en aplicaciones de consola, API web, servicios de Windows y trabajadores en segundo plano.

Estabilidad de la memoria: la recolección de basura adecuada elimina las fugas de memoria que afectan a WebView2en procesos de ejecución prolongada. Los servidores de producción permanecen estables.

API simple: las llamadas a un solo método reemplazan eventos de navegación complejos, devoluciones de llamadas de finalización, interacciones del protocolo DevTools y decodificación base64.

Funciones ampliadas de PDF: encabezados, pies de página, marcas de agua, fusión/división, firmas digitales, protección con contraseña y compatibilidad con PDF/A: funciones que WebView2no puede proporcionar.

Desarrollo activo: a medida que aumenta la adopción de .NET 10 y C# 14 hasta 2026, las actualizaciones periódicas deIronPDFgarantizan la compatibilidad con las versiones actuales y futuras de .NET.

Curtis Chau
Curtis Chau
  Chatea con el equipo de ingeniería ahora
Escritor Técnico

Curtis Chau tiene una licenciatura en Ciencias de la Computación (Carleton University) y se especializa en el desarrollo front-end con experiencia en Node.js, TypeScript, JavaScript y React. Apasionado por crear interfaces de usuario intuitivas y estéticamente agradables, disfruta trabajando con frameworks modernos y creando manuales bien ...

Leer más

Artículos Relacionados

Prueba de 30 días → Producto completo. Sin límites. Sin tarjeta. Prueba gratis