Í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 puppeteersharp a ironpdf
GUíAS DE MIGRACIóN

Cómo migrar de PuppeteerSharp a IronPDF en C#

Curtis Chau
Curtis Chau
Publicado:

La migración de PuppeteerSharpaIronPDFtransforma su flujo de trabajo de generación de PDF de una herramienta de automatización del navegador con dependencias de más de 300 MB a una biblioteca PDF creada específicamente con gestión automática de memoria. Esta guía proporciona una ruta de migración completa, paso a paso, que elimina las descargas de Chromium, resuelve los problemas de fugas de memoria y proporciona capacidades completas de manipulación de PDF.

Por qué migrar de PuppeteerSharpa IronPDF

Entendiendo PuppeteerSharp

PuppeteerSharp es una adaptación a .NET de Puppeteer de Google, que lleva las capacidades de automatización del navegador a C#. Genera archivos PDF utilizando la función integrada de impresión a PDF de Chrome, igual que si pulsaras Ctrl+P en un navegador. El resultado es un documento listo para imprimir y optimizado para el papel, que difiere de lo que se ve en pantalla.

PuppeteerSharp se diseñó para pruebas web y scraping, no para la generación de documentos. Aunque es capaz, el uso de PuppeteerSharppara la generación de PDF crea importantes retos de producción.

El problema de la automatización del navegador

PuppeteerSharp se diseñó para la automatización de navegadores, no para la generación de documentos. Esto plantea problemas fundamentales cuando se utiliza para PDF:

  1. se requieren 300MB+ de descargas de Chromium antes del primer uso. Una desventaja significativa de PuppeteerSharpes su gran tamaño de despliegue, debido principalmente al binario Chromium que incluye. Este tamaño considerable puede inflar las imágenes de Docker y causar problemas de arranque en frío en entornos sin servidor.

  2. Fugas de memoria bajo carga que requieren el reciclaje manual del navegador. Bajo carga pesada, PuppeteerSharpes conocido por experimentar fugas de memoria. La acumulación de memoria por parte de las instancias del navegador hace necesaria la intervención manual para la gestión y el reciclaje del proceso.

  3. Patrones async complejos con gestión del ciclo de vida del navegador.

  4. Print-to-PDF output (equivalente a Ctrl+P, no captura de pantalla). Los diseños pueden refluir, los fondos pueden omitirse por defecto y el resultado se pagina para la impresión en lugar de ajustarse a la ventana del navegador.

  5. No es compatible con PDF/A ni PDF/UA por requisitos de conformidad. PuppeteerSharpno puede producir documentos PDF/A (archivo) o PDF/UA (accesibilidad).

  6. Sin manipulación de PDF - sólo generación, sin fusión/división/edición. Aunque PuppeteerSharpes eficiente a la hora de generar archivos PDF, carece de capacidades para su manipulación posterior, como combinar, dividir, proteger o editar archivos PDF.

Comparación entre PuppeteerSharpy IronPDF

Aspecto PuppeteerSharp IronPDF
Finalidad principal Automatización de navegadores Generación de PDF
Dependencia de Chromium descarga separada de más de 300 MB Motor integrado optimizado
Complejidad de la API Ciclo de vida asíncrono de navegador/página Sincronización de frases
Inicialización BrowserFetcher.DownloadAsync() + LaunchAsync <código>new ChromePdfRenderer()`
Gestión de memoria Se requiere reciclaje manual del navegador Automático
Memoria bajo carga más de 500 MB con filtraciones ~50 MB estables
Inicio en frío más de 45 segundos ~20 segundos
Soporte PDF/A No disponible Soporte completo
Accesibilidad PDF/UA No disponible Soporte completo
Edición de PDF No disponible Combinar, dividir, sellar, editar
Firmas digitales No disponible Soporte completo
Seguridad de hilos Limitado Completo
Soporte profesional Comunidad Comercial con SLA

Soporte de plataforma

Biblioteca .NET Framework 4.7.2 .NET Core 3.1 .NET 6-8 .NET 10
IronPDF Completo Completo Completo Completo
PuppeteerSharp Limitado Completo Completo Pendiente

La amplia compatibilidad deIronPDFcon todas las plataformas .NET garantiza que los desarrolladores puedan utilizarlo en varios entornos sin encontrar problemas de compatibilidad, lo que proporciona una opción flexible para las aplicaciones .NET modernas hasta 2025 y 2026.

Antes de empezar

Prerrequisitos

  1. Entorno .NET: .NET Framework 4.6.2+ o .NET Core 3.1+ / .NET 5/6/7/8/9+
  2. Acceso a NuGet: Capacidad para instalar paquetes NuGet
  3. Licencia de IronPDF: Obtenga su clave de licencia en ironpdf.com

Cambios en el paquete NuGet

# Remove PuppeteerSharp
dotnet remove package PuppeteerSharp

# Remove downloaded Chromium binaries (~300MB recovered)
# Delete the .local-chromium folder

# Add IronPDF
dotnet add package IronPdf
# Remove PuppeteerSharp
dotnet remove package PuppeteerSharp

# Remove downloaded Chromium binaries (~300MB recovered)
# Delete the .local-chromium folder

# Add IronPDF
dotnet add package IronPdf
SHELL

No se requiere BrowserFetcher.DownloadAsync() con IronPDF - el motor de renderizado se incluye automáticamente.

Configuración de licencias

// Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
// Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
$vbLabelText   $csharpLabel

Referencia completa de la API

Cambios en el espacio de nombres

// Before: PuppeteerSharp
using PuppeteerSharp;
using PuppeteerSharp.Media;
using System.Threading.Tasks;

// After: IronPDF
using IronPdf;
using IronPdf.Rendering;
// Before: PuppeteerSharp
using PuppeteerSharp;
using PuppeteerSharp.Media;
using System.Threading.Tasks;

// After: IronPDF
using IronPdf;
using IronPdf.Rendering;
$vbLabelText   $csharpLabel

Mapeos de API principales

API de PuppeteerSharp API de IronPDF Notas
new BrowserFetcher().DownloadAsync() No es necesario Sin descarga de navegador
<código>Puppeteer.LaunchAsync(options)` No es necesario Sin gestión de navegador
<código>browser.NewPageAsync() No es necesario Sin contexto de página
<código>page.GoToAsync(url) <código>renderer.RenderUrlAsPdf(url) Traducción directa
<código>page.SetContentAsync(html) renderer.RenderHtmlAsPdf(html) Traducción directa
<código>page.PdfAsync(ruta)` <código>pdf.SaveAs(ruta) Después de la traducción
esperar page.CloseAsync() No es necesario Limpieza automática
espera browser.CloseAsync() No es necesario Limpieza automática
<código>PdfOptions.Format` <código>RenderingOptions.PaperSize Tamaño del papel
<código>PdfOptions.Landscape <código>RenderingOptions.PaperOrientation Orientación
<código>PdfOptions.MarginOptions <código>RenderingOptions.MarginTop/Bottom/Left/Right Márgenes individuales
<código>PdfOptions.PrintBackground <código>RenderingOptions.PrintHtmlBackgrounds Impresión de fondo
<código>PdfOptions.HeaderTemplate <código>RenderingOptions.HtmlHeader Encabezados HTML
<código>PdfOptions.FooterTemplate <código>RenderingOptions.HtmlFooter Pies de página HTML
<código>page.WaitForSelectorAsync() <código>RenderingOptions.WaitFor.HtmlElementId Esperar elemento

Ejemplos de migración de código

Ejemplo 1: Conversión básica de HTML a PDF

Antes (PuppeteerSharp):

// NuGet: Install-Package PuppeteerSharp
using PuppeteerSharp;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        var browserFetcher = new BrowserFetcher();
        await browserFetcher.DownloadAsync();

        await using var browser = await Puppeteer.LaunchAsync(new LaunchOptions
        {
            Headless = true
        });

        await using var page = await browser.NewPageAsync();
        await page.SetContentAsync("<h1>Hello World</h1><p>This is a PDF document.</p>");
        await page.PdfAsync("output.pdf");
    }
}
// NuGet: Install-Package PuppeteerSharp
using PuppeteerSharp;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        var browserFetcher = new BrowserFetcher();
        await browserFetcher.DownloadAsync();

        await using var browser = await Puppeteer.LaunchAsync(new LaunchOptions
        {
            Headless = true
        });

        await using var page = await browser.NewPageAsync();
        await page.SetContentAsync("<h1>Hello World</h1><p>This is a PDF document.</p>");
        await page.PdfAsync("output.pdf");
    }
}
$vbLabelText   $csharpLabel

Después (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1><p>This is a PDF document.</p>");
        pdf.SaveAs("output.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1><p>This is a PDF document.</p>");
        pdf.SaveAs("output.pdf");
    }
}
$vbLabelText   $csharpLabel

Este ejemplo demuestra la diferencia arquitectónica fundamental. PuppeteerSharprequiere seis operaciones async: BrowserFetcher.DownloadAsync() (300MB+ Chromium download), Puppeteer.LaunchAsync(), browser.NewPageAsync(), page.SetContentAsync(), y page.PdfAsync(), además de su correcta eliminación con await using.

IronPDF elimina toda esta complejidad: cree un ChromePdfRenderer, llame a RenderHtmlAsPdf() y SaveAs(). Ni patrones asíncronos, ni ciclo de vida del navegador, ni descargas de Chromium. El enfoque deIronPDFofrece una sintaxis más limpia y una mejor integración con las aplicaciones .NET modernas. Consulte la documentación HTML a PDF para ver ejemplos completos.

Ejemplo 2: Conversión de URL a PDF

Antes (PuppeteerSharp):

// NuGet: Install-Package PuppeteerSharp
using PuppeteerSharp;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        var browserFetcher = new BrowserFetcher();
        await browserFetcher.DownloadAsync();

        await using var browser = await Puppeteer.LaunchAsync(new LaunchOptions
        {
            Headless = true
        });

        await using var page = await browser.NewPageAsync();
        await page.GoToAsync("https://www.example.com");
        await page.PdfAsync("webpage.pdf");
    }
}
// NuGet: Install-Package PuppeteerSharp
using PuppeteerSharp;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        var browserFetcher = new BrowserFetcher();
        await browserFetcher.DownloadAsync();

        await using var browser = await Puppeteer.LaunchAsync(new LaunchOptions
        {
            Headless = true
        });

        await using var page = await browser.NewPageAsync();
        await page.GoToAsync("https://www.example.com");
        await page.PdfAsync("webpage.pdf");
    }
}
$vbLabelText   $csharpLabel

Después (IronPDF):

// NuGet: Install-Package IronPdf
using IronPdf;

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

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderUrlAsPdf("https://www.example.com");
        pdf.SaveAs("webpage.pdf");
    }
}
$vbLabelText   $csharpLabel

PuppeteerSharp utiliza GoToAsync() para navegar a una URL seguida de PdfAsync().IronPDFproporciona un único método RenderUrlAsPdf() que gestiona la navegación y la generación de PDF en una sola llamada. Más información en nuestros tutoriales.

Ejemplo 3: Configuración de página personalizada con márgenes

Antes (PuppeteerSharp):

// NuGet: Install-Package PuppeteerSharp
using PuppeteerSharp;
using PuppeteerSharp.Media;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        var browserFetcher = new BrowserFetcher();
        await browserFetcher.DownloadAsync();

        await using var browser = await Puppeteer.LaunchAsync(new LaunchOptions
        {
            Headless = true
        });

        await using var page = await browser.NewPageAsync();
        await page.SetContentAsync("<h1>Custom PDF</h1><p>With landscape orientation and margins.</p>");

        await page.PdfAsync("custom.pdf", new PdfOptions
        {
            Format = PaperFormat.A4,
            Landscape = true,
            MarginOptions = new MarginOptions
            {
                Top = "20mm",
                Bottom = "20mm",
                Left = "20mm",
                Right = "20mm"
            }
        });
    }
}
// NuGet: Install-Package PuppeteerSharp
using PuppeteerSharp;
using PuppeteerSharp.Media;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        var browserFetcher = new BrowserFetcher();
        await browserFetcher.DownloadAsync();

        await using var browser = await Puppeteer.LaunchAsync(new LaunchOptions
        {
            Headless = true
        });

        await using var page = await browser.NewPageAsync();
        await page.SetContentAsync("<h1>Custom PDF</h1><p>With landscape orientation and margins.</p>");

        await page.PdfAsync("custom.pdf", new PdfOptions
        {
            Format = PaperFormat.A4,
            Landscape = true,
            MarginOptions = new MarginOptions
            {
                Top = "20mm",
                Bottom = "20mm",
                Left = "20mm",
                Right = "20mm"
            }
        });
    }
}
$vbLabelText   $csharpLabel

Después (IronPDF):

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

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;
        renderer.RenderingOptions.MarginTop = 20;
        renderer.RenderingOptions.MarginBottom = 20;
        renderer.RenderingOptions.MarginLeft = 20;
        renderer.RenderingOptions.MarginRight = 20;

        var pdf = renderer.RenderHtmlAsPdf("<h1>Custom PDF</h1><p>With landscape orientation and margins.</p>");
        pdf.SaveAs("custom.pdf");
    }
}
// NuGet: Install-Package IronPdf
using IronPdf;
using IronPdf.Rendering;

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Landscape;
        renderer.RenderingOptions.MarginTop = 20;
        renderer.RenderingOptions.MarginBottom = 20;
        renderer.RenderingOptions.MarginLeft = 20;
        renderer.RenderingOptions.MarginRight = 20;

        var pdf = renderer.RenderHtmlAsPdf("<h1>Custom PDF</h1><p>With landscape orientation and margins.</p>");
        pdf.SaveAs("custom.pdf");
    }
}
$vbLabelText   $csharpLabel

Este ejemplo muestra la correspondencia entre las opciones PDF de las dos bibliotecas. PuppeteerSharputiliza PdfOptions con Format, Landscape y MarginOptions que contienen valores de cadena ("20mm").IronPDFutiliza propiedades RenderingOptions con enums directos de tamaño de papel, enums de orientación y valores numéricos de margen en milímetros.

Asignaciones clave:

  • Formato = PaperFormat.A4 → TamañoPapel = PdfPaperSize.A4
  • Landscape = true → PaperOrientation = PdfPaperOrientation.Landscape
  • MarginOptions.Top = "20mm" → MarginTop = 20 (milímetros numéricos)

El problema de las fugas de memoria

PuppeteerSharp es notorio por la acumulación de memoria bajo carga sostenida:

// ❌ PuppeteerSharp- Memory grows with each operation
// Requires explicit browser recycling every N operations
for (int i = 0; i < 1000; i++)
{
    var page = await browser.NewPageAsync();
    await page.SetContentAsync($"<h1>Document {i}</h1>");
    await page.PdfAsync($"doc_{i}.pdf");
    await page.CloseAsync(); // Memory still accumulates!
}
// Must periodically: await browser.CloseAsync(); and re-launch

// ✅IronPDF- Stable memory, reuse renderer
var renderer = new ChromePdfRenderer();
for (int i = 0; i < 1000; i++)
{
    var pdf = renderer.RenderHtmlAsPdf($"<h1>Document {i}</h1>");
    pdf.SaveAs($"doc_{i}.pdf");
    // Memory managed automatically
}
// ❌ PuppeteerSharp- Memory grows with each operation
// Requires explicit browser recycling every N operations
for (int i = 0; i < 1000; i++)
{
    var page = await browser.NewPageAsync();
    await page.SetContentAsync($"<h1>Document {i}</h1>");
    await page.PdfAsync($"doc_{i}.pdf");
    await page.CloseAsync(); // Memory still accumulates!
}
// Must periodically: await browser.CloseAsync(); and re-launch

// ✅IronPDF- Stable memory, reuse renderer
var renderer = new ChromePdfRenderer();
for (int i = 0; i < 1000; i++)
{
    var pdf = renderer.RenderHtmlAsPdf($"<h1>Document {i}</h1>");
    pdf.SaveAs($"doc_{i}.pdf");
    // Memory managed automatically
}
$vbLabelText   $csharpLabel

IronPDF elimina la necesidad de la infraestructura de agrupación de navegadores que requiere PuppeteerSharp:

// Before (PuppeteerSharp - delete entire class)
public class PuppeteerBrowserPool
{
    private readonly ConcurrentBag<IBrowser> _browsers;
    private readonly SemaphoreSlim _semaphore;
    private int _operationCount;
    // ... recycling logic ...
}

// After (IronPDF - simple reuse)
public class PdfService
{
    private readonly ChromePdfRenderer _renderer = new();

    public byte[] Generate(string html)
    {
        return _renderer.RenderHtmlAsPdf(html).BinaryData;
    }
}
// Before (PuppeteerSharp - delete entire class)
public class PuppeteerBrowserPool
{
    private readonly ConcurrentBag<IBrowser> _browsers;
    private readonly SemaphoreSlim _semaphore;
    private int _operationCount;
    // ... recycling logic ...
}

// After (IronPDF - simple reuse)
public class PdfService
{
    private readonly ChromePdfRenderer _renderer = new();

    public byte[] Generate(string html)
    {
        return _renderer.RenderHtmlAsPdf(html).BinaryData;
    }
}
$vbLabelText   $csharpLabel

Notas de migración críticas

Conversión de Async a Sync

PuppeteerSharp requiere async/await en todo momento;IronPDFadmite operaciones síncronas:

// PuppeteerSharp: Async required
public async Task<byte[]> GeneratePdfAsync(string html)
{
    await new BrowserFetcher().DownloadAsync();
    await using var browser = await Puppeteer.LaunchAsync(...);
    await using var page = await browser.NewPageAsync();
    await page.SetContentAsync(html);
    return await page.PdfDataAsync();
}

// IronPDF: Sync default
public byte[] GeneratePdf(string html)
{
    var renderer = new ChromePdfRenderer();
    return renderer.RenderHtmlAsPdf(html).BinaryData;
}

// Or async when needed
public async Task<byte[]> GeneratePdfAsync(string html)
{
    var renderer = new ChromePdfRenderer();
    var pdf = await renderer.RenderHtmlAsPdfAsync(html);
    return pdf.BinaryData;
}
// PuppeteerSharp: Async required
public async Task<byte[]> GeneratePdfAsync(string html)
{
    await new BrowserFetcher().DownloadAsync();
    await using var browser = await Puppeteer.LaunchAsync(...);
    await using var page = await browser.NewPageAsync();
    await page.SetContentAsync(html);
    return await page.PdfDataAsync();
}

// IronPDF: Sync default
public byte[] GeneratePdf(string html)
{
    var renderer = new ChromePdfRenderer();
    return renderer.RenderHtmlAsPdf(html).BinaryData;
}

// Or async when needed
public async Task<byte[]> GeneratePdfAsync(string html)
{
    var renderer = new ChromePdfRenderer();
    var pdf = await renderer.RenderHtmlAsPdfAsync(html);
    return pdf.BinaryData;
}
$vbLabelText   $csharpLabel

Conversión de unidades de margen

PuppeteerSharp utiliza unidades de cadena;IronPDFutiliza milímetros numéricos:

// PuppeteerSharp- string units
MarginOptions = new MarginOptions
{
    Top = "1in",      // 25.4mm
    Bottom = "0.75in", // 19mm
    Left = "1cm",     // 10mm
    Right = "20px"    // ~7.5mm at 96dpi
}

//IronPDF- numeric millimeters
renderer.RenderingOptions.MarginTop = 25;    // mm
renderer.RenderingOptions.MarginBottom = 19;
renderer.RenderingOptions.MarginLeft = 10;
renderer.RenderingOptions.MarginRight = 8;
// PuppeteerSharp- string units
MarginOptions = new MarginOptions
{
    Top = "1in",      // 25.4mm
    Bottom = "0.75in", // 19mm
    Left = "1cm",     // 10mm
    Right = "20px"    // ~7.5mm at 96dpi
}

//IronPDF- numeric millimeters
renderer.RenderingOptions.MarginTop = 25;    // mm
renderer.RenderingOptions.MarginBottom = 19;
renderer.RenderingOptions.MarginLeft = 10;
renderer.RenderingOptions.MarginRight = 8;
$vbLabelText   $csharpLabel

Conversión de marcadores de posición de encabezado/pie

Clase PuppeteerSharp Marcador de posición IronPDF
<código>|{page}`
<código>|{total de páginas}`
<código>|{fecha}`
<código>|{html-title}`

Nuevas capacidades tras la migración

Después de migrar a IronPDF, obtendrá capacidades que PuppeteerSharpno puede proporcionar:

Fusión de PDF

var pdf1 = renderer.RenderHtmlAsPdf(html1);
var pdf2 = renderer.RenderHtmlAsPdf(html2);
var merged = PdfDocument.Merge(pdf1, pdf2);
merged.SaveAs("merged.pdf");
var pdf1 = renderer.RenderHtmlAsPdf(html1);
var pdf2 = renderer.RenderHtmlAsPdf(html2);
var merged = PdfDocument.Merge(pdf1, pdf2);
merged.SaveAs("merged.pdf");
$vbLabelText   $csharpLabel

Marcas de agua

var watermark = new TextStamper
{
    Text = "CONFIDENTIAL",
    FontSize = 48,
    Opacity = 30,
    Rotation = -45
};
pdf.ApplyStamp(watermark);
var watermark = new TextStamper
{
    Text = "CONFIDENTIAL",
    FontSize = 48,
    Opacity = 30,
    Rotation = -45
};
pdf.ApplyStamp(watermark);
$vbLabelText   $csharpLabel

Protección con contraseña

pdf.SecuritySettings.OwnerPassword = "admin";
pdf.SecuritySettings.UserPassword = "readonly";
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
pdf.SecuritySettings.OwnerPassword = "admin";
pdf.SecuritySettings.UserPassword = "readonly";
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
$vbLabelText   $csharpLabel

Firmas digitales

var signature = new PdfSignature("certificate.pfx", "password");
pdf.Sign(signature);
var signature = new PdfSignature("certificate.pfx", "password");
pdf.Sign(signature);
$vbLabelText   $csharpLabel

Cumplimiento de PDF/A

pdf.SaveAsPdfA("archive.pdf", PdfAVersions.PdfA3b);
pdf.SaveAsPdfA("archive.pdf", PdfAVersions.PdfA3b);
$vbLabelText   $csharpLabel

Resumen comparativo de prestaciones

Métrica PuppeteerSharp IronPDF Mejora
Primer PDF (Cold Start) 45s+ ~20s 55%+ más rápido
PDF posteriores Variable Consistente Predecible
Uso de memoria 500MB+ (crece) ~50 MB (estable) 90% menos de memoria
Espacio en disco (Chromium) mÁS DE 300 MB 0 Eliminar descargas
Navegador Descargar Requerido No es necesario Cero configuración
Seguridad de los hilos Limitado Completo Concurrencia fiable
Tiempo de generación de PDF 45s 20s 55% más rápido

Lista de comprobación de la migración

Pre-Migración

  • Identificar todos los usos de PuppeteerSharpen el código base
  • Valores de márgenes del documento (convertir cadenas a milímetros)
  • Nota sobre la sintaxis de marcador de posición de encabezado/pie de página para la conversión
  • Eliminar la infraestructura de agrupación/reciclaje del navegador
  • Obtenga la clave de licencia deIronPDFen ironpdf.com

Cambios en el paquete

  • Eliminar el paquete NuGet PuppeteerSharp
  • Eliminar la carpeta .local-chromium para recuperar ~300 MB de espacio en disco
  • Instalar el paquete NuGet IronPdf : dotnet add package IronPdf

Cambios de código

  • Actualizar las importaciones de espacios de nombres
  • Eliminar llamadas BrowserFetcher.DownloadAsync()
  • Eliminar Puppeteer.LaunchAsync() y la administración del navegador
  • Reemplace page.SetContentAsync() + page.PdfAsync() con RenderHtmlAsPdf()
  • Reemplace page.GoToAsync() + page.PdfAsync() con RenderUrlAsPdf()
  • Convertir cadenas de margen a valores milimétricos
  • Convertir la sintaxis de marcador de posición de encabezado/pie de página
  • Eliminar todo el código de eliminación de páginas/navegadores
  • Eliminar la infraestructura de agrupación de navegadores
  • Agregar inicialización de licencia al iniciar la aplicación

Posmigración

  • Comparación visual de la salida PDF
  • Prueba de carga para la estabilidad de la memoria (debe permanecer estable sin reciclar)
  • Verificar la representación del encabezado/pie de página con números de página
  • Agregue nuevas capacidades (seguridad, marcas de agua, fusión) según sea necesario
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