Migrar de PuppeteerSharp para IronPDF move seu fluxo de trabalho de geração de PDF de uma ferramenta de automação de navegador com uma dependência de Chromium de 300 MB ou mais para uma biblioteca de PDF projetada especialmente que oferece gerenciamento automático de memória. Este guia fornece um caminho de migração passo a passo que elimina o download do runtime Chromium, aborda o crescimento de memória reportado sob carga, e adiciona capacidades abrangentes de manipulação de PDF.
PuppeteerSharp é uma versão .NET do Puppeteer do Google, que traz recursos de automação de navegador para C#. Ele gera PDFs usando a funcionalidade integrada de impressão para PDF do Chrome — o mesmo que pressionar Ctrl+P em um navegador. Isso produz um resultado pronto para impressão, otimizado para papel, que difere do que você vê na tela.
O PuppeteerSharp foi projetado para testes e extração de dados da web, não para geração de documentos. Embora seja uma ferramenta capaz, o uso do PuppeteerSharp para geração de PDFs apresenta desafios significativos de produção.
O PuppeteerSharp foi projetado para automação de navegadores, não para geração de documentos. Isso cria problemas fundamentais ao usá-lo com PDFs:
É necessário fazer o download do Chromium (mais de 300 MB) antes do primeiro uso. Uma desvantagem significativa do PuppeteerSharp é o seu tamanho de implantação considerável, principalmente devido ao binário do Chromium que ele inclui. Esse tamanho considerável pode inflar as imagens do Docker e causar problemas de inicialização a frio em ambientes sem servidor.
Crescimento de memória relatado sob carga requerendo reciclagem manual do navegador. Sob carga sustentada, usuários do PuppeteerSharp relataram acúmulo de memória em instâncias de navegador, tipicamente abordado por reciclagem manual do processo.
Padrões assíncronos complexos com gerenciamento do ciclo de vida do navegador.
Impressão em PDF (equivalente a Ctrl+P, não captura de tela). Os layouts podem ser redimensionados, os planos de fundo podem ser omitidos por padrão e a saída é paginada para impressão em vez de corresponder à área visível do navegador.
Não há suporte para PDF/A ou PDF/UA para atender aos requisitos de conformidade. O PuppeteerSharp não consegue gerar documentos compatíveis com PDF/A (arquivísticos) ou PDF/UA (acessíveis).
Sem manipulação de PDF - apenas geração, sem mesclagem/divisão/edição. Embora o PuppeteerSharp seja eficiente na geração de PDFs, ele carece de recursos para manipulação adicional, como mesclagem, divisão, proteção ou edição de PDFs.
| Aspecto | PuppeteerSharp | IronPDF |
|---|---|---|
| Objetivo principal | Automação do navegador | Geração de PDF |
| Dependência do Chromium | Download separado de mais de 300 MB | Motor otimizado integrado |
| Complexidade da API | Ciclo de vida assíncrono do navegador/página | Frases curtas síncronas |
| Inicialização | BrowserFetcher.DownloadAsync() + LaunchAsync | new ChromePdfRenderer() |
| Gerenciamento de memória | Reciclagem manual do navegador | Automático |
| Memória sob carga | Crescimento relatado em cargas pesadas | Estável em execuções sustentadas |
| Suporte PDF/A | Não disponível | Apoiado |
| Acessibilidade PDF/UA | Não disponível | Apoiado |
| Edição de PDF | Não disponível | Mesclar, dividir, carimbar, editar |
| Assinaturas digitais | Não disponível | Apoiado |
| Segurança da rosca | Limitado (conforme orientação upstream) | Completo |
| Licenciamento | MIT (código aberto) | Licença comercial |
| Biblioteca | .NET Framework 4.7.2 | .NET Core 3.1 | .NET 6-8 | .NET 10 |
|---|---|---|---|---|
| IronPDF | Completo | Completo | Completo | Completo |
| PuppeteerSharp | via netstandard2.0 | Completo | Completo | Completo |
O suporte do IronPDF em alvos modernos do .NET significa que ele se encaixa na maioria das aplicações existentes sem atrito de compatibilidade.
# Remove PuppeteerSharp
dotnet remove package PuppeteerSharp
# Remove downloaded Chromium binaries (~300MB recovered)
# Delete the .local-chromium folder
# Add IronPDF
dotnet add package IronPdfNenhum BrowserFetcher.DownloadAsync() necessário com IronPDF - o mecanismo de renderização é incluído automaticamente.
// Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";' Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"// Before: PuppeteerSharp
using PuppeteerSharp;
using PuppeteerSharp.Media;
using System.Threading.Tasks;
// After: IronPDF
using IronPdf;
using IronPdf.Rendering;' Before: PuppeteerSharp
Imports PuppeteerSharp
Imports PuppeteerSharp.Media
Imports System.Threading.Tasks
' After: IronPDF
Imports IronPdf
Imports IronPdf.Rendering| API PuppeteerSharp | API IronPDF | Notas |
|---|---|---|
new BrowserFetcher().DownloadAsync() | Não é necessário | Sem download no navegador |
Puppeteer.LaunchAsync(options) | Não é necessário | Sem gerenciamento de navegador |
browser.NewPageAsync() | Não é necessário | Sem contexto de página |
page.GoToAsync(url) | renderer.RenderUrlAsPdf(url) | Renderização direta |
page.SetContentAsync(html) | renderer.RenderHtmlAsPdf(html) | Renderização direta |
page.PdfAsync(path) | pdf.SaveAs(path) | Após a renderização |
await page.CloseAsync() | Não é necessário | Limpeza automática |
await browser.CloseAsync() | Não é necessário | Limpeza automática |
PdfOptions.Format | RenderingOptions.PaperSize | Tamanho do papel |
PdfOptions.Landscape | RenderingOptions.PaperOrientation | Orientação |
PdfOptions.MarginOptions | RenderingOptions.MarginTop/Bottom/Left/Right | margens individuais |
PdfOptions.PrintBackground | RenderingOptions.PrintHtmlBackgrounds | Impressão de fundo |
PdfOptions.HeaderTemplate | RenderingOptions.HtmlHeader | Cabeçalhos HTML |
PdfOptions.FooterTemplate | RenderingOptions.HtmlFooter | Rodapés HTML |
page.WaitForSelectorAsync() | RenderingOptions.WaitFor.HtmlElementId | Aguarde o elemento |
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
Imports PuppeteerSharp
Imports System.Threading.Tasks
Module Program
Async Function Main(args As String()) As Task
Dim browserFetcher = New BrowserFetcher()
Await browserFetcher.DownloadAsync()
Await Using browser = Await Puppeteer.LaunchAsync(New LaunchOptions With {
.Headless = True
})
Await Using page = Await browser.NewPageAsync()
Await page.SetContentAsync("<h1>Hello World</h1><p>This is a PDF document.</p>")
Await page.PdfAsync("output.pdf")
End Using
End Using
End Function
End ModuleApó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");
}
}Imports IronPdf
Class Program
Shared Sub Main(args As String())
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Hello World</h1><p>This is a PDF document.</p>")
pdf.SaveAs("output.pdf")
End Sub
End ClassEste exemplo demonstra a diferença arquitetônica fundamental. PuppeteerSharp requer seis operações assíncronas: BrowserFetcher.DownloadAsync() (download do Chromium de 300MB+), Puppeteer.LaunchAsync(), browser.NewPageAsync(), page.SetContentAsync(), e page.PdfAsync(), além de uma disposição adequada com await using.
IronPDF elimina toda essa complexidade: crie um ChromePdfRenderer, chame RenderHtmlAsPdf(), e SaveAs(). Sem padrões assíncronos, sem ciclo de vida do navegador, sem downloads do Chromium. A abordagem do IronPDF oferece uma sintaxe mais limpa e melhor integração com aplicativos .NET modernos. Consulte a documentação de conversão de HTML para PDF para obter exemplos completos.
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
Imports PuppeteerSharp
Imports System.Threading.Tasks
Module Program
Async Function Main(args As String()) As Task
Dim browserFetcher = New BrowserFetcher()
Await browserFetcher.DownloadAsync()
Await Using browser = Await Puppeteer.LaunchAsync(New LaunchOptions With {
.Headless = True
})
Await Using page = Await browser.NewPageAsync()
Await page.GoToAsync("https://www.example.com")
Await page.PdfAsync("webpage.pdf")
End Using
End Using
End Function
End ModuleApó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");
}
}Imports IronPdf
Class Program
Shared Sub Main(ByVal args As String())
Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderUrlAsPdf("https://www.example.com")
pdf.SaveAs("webpage.pdf")
End Sub
End ClassPuppeteerSharp usa GoToAsync() para navegar até um URL seguido de PdfAsync().IronPDF fornece um único método RenderUrlAsPdf() que lida com a navegação e a geração de PDF em uma única chamada. Saiba mais em nossos tutoriais .
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
Imports PuppeteerSharp
Imports PuppeteerSharp.Media
Imports System.Threading.Tasks
Module Program
Async Function Main(args As String()) As Task
Dim browserFetcher = New BrowserFetcher()
Await browserFetcher.DownloadAsync()
Await Using browser = Await Puppeteer.LaunchAsync(New LaunchOptions With {
.Headless = True
})
Await Using 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 With {
.Format = PaperFormat.A4,
.Landscape = True,
.MarginOptions = New MarginOptions With {
.Top = "20mm",
.Bottom = "20mm",
.Left = "20mm",
.Right = "20mm"
}
})
End Using
End Using
End Function
End ModuleApó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
Imports IronPdf
Imports IronPdf.Rendering
Class Program
Shared Sub Main(ByVal args As String())
Dim 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
Dim pdf = renderer.RenderHtmlAsPdf("<h1>Custom PDF</h1><p>With landscape orientation and margins.</p>")
pdf.SaveAs("custom.pdf")
End Sub
End ClassEste exemplo mostra como as opções de PDF são mapeadas entre as duas bibliotecas. PuppeteerSharp usa PdfOptions com Format, Landscape, e MarginOptions contendo valores de string ("20mm").IronPDF usa propriedades RenderingOptions com enums de tamanho de papel direto, enums de orientação, e valores numéricos de margem em milímetros.
Mapeamentos de teclas:
Format = PaperFormat.A4 → PaperSize = PdfPaperSize.A4Landscape = true → PaperOrientation = PdfPaperOrientation.LandscapeMarginOptions.Top = "20mm" → MarginTop = 20 (milímetros numéricos)Usuários relataram acúmulo de memória com PuppeteerSharp sob carga sustentada, tipicamente mitigado por reciclagem manual do navegador:
// PuppeteerSharp - memory growth typically requires periodic recycling
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();
}
// Recommended: await browser.CloseAsync(); and re-launch every N operations
//IronPDF- reuse a single renderer across operations
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
}O IronPDF elimina a necessidade da infraestrutura de agrupamento de navegadores exigida pelo 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 _browsers As ConcurrentBag(Of IBrowser)
Private ReadOnly _semaphore As SemaphoreSlim
Private _operationCount As Integer
' ... recycling logic ...
End Class
' After (IronPDF - simple reuse)
Public Class PdfService
Private ReadOnly _renderer As New ChromePdfRenderer()
Public Function Generate(html As String) As Byte()
Return _renderer.RenderHtmlAsPdf(html).BinaryData
End Function
End ClassO PuppeteerSharp requer async/await em todas as suas etapas; O IronPDF suporta operações 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;
}Imports System.Threading.Tasks
Imports PuppeteerSharp
' PuppeteerSharp: Async required
Public Async Function GeneratePdfAsync(html As String) As Task(Of Byte())
Await (New BrowserFetcher()).DownloadAsync()
Await Using browser = Await Puppeteer.LaunchAsync(...)
Await Using page = Await browser.NewPageAsync()
Await page.SetContentAsync(html)
Return Await page.PdfDataAsync()
End Using
End Using
End Function
' IronPDF: Sync default
Public Function GeneratePdf(html As String) As Byte()
Dim renderer = New ChromePdfRenderer()
Return renderer.RenderHtmlAsPdf(html).BinaryData
End Function
' Or async when needed
Public Async Function GeneratePdfAsync(html As String) As Task(Of Byte())
Dim renderer = New ChromePdfRenderer()
Dim pdf = Await renderer.RenderHtmlAsPdfAsync(html)
Return pdf.BinaryData
End FunctionPuppeteerSharp usa unidades de corda; O IronPDF usa 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;| Puppeteer Classe Afiada | Espaço reservado para IronPDF |
|---|---|
<span class='pageNumber'> | {page} |
<span class='totalPages'> | {total-pages} |
<span class='date'> | {date} |
<span class='title'> | {html-title} |
Após migrar para o IronPDF, você obtém recursos que o PuppeteerSharp não pode fornecer:
var pdf1 = renderer.RenderHtmlAsPdf(html1);
var pdf2 = renderer.RenderHtmlAsPdf(html2);
var merged = PdfDocument.Merge(pdf1, pdf2);
merged.SaveAs("merged.pdf");Dim pdf1 = renderer.RenderHtmlAsPdf(html1)
Dim pdf2 = renderer.RenderHtmlAsPdf(html2)
Dim merged = PdfDocument.Merge(pdf1, pdf2)
merged.SaveAs("merged.pdf")var watermark = new TextStamper
{
Text = "CONFIDENTIAL",
FontSize = 48,
Opacity = 30,
Rotation = -45
};
pdf.ApplyStamp(watermark);Dim watermark As New TextStamper With {
.Text = "CONFIDENTIAL",
.FontSize = 48,
.Opacity = 30,
.Rotation = -45
}
pdf.ApplyStamp(watermark)pdf.SecuritySettings.OwnerPassword = "admin";
pdf.SecuritySettings.UserPassword = "readonly";
pdf.SecuritySettings.AllowUserCopyPasteContent = false;pdf.SecuritySettings.OwnerPassword = "admin"
pdf.SecuritySettings.UserPassword = "readonly"
pdf.SecuritySettings.AllowUserCopyPasteContent = Falsevar signature = new PdfSignature("certificate.pfx", "password");
pdf.Sign(signature);Dim signature = New PdfSignature("certificate.pfx", "password")
pdf.Sign(signature)pdf.SaveAsPdfA("archive.pdf", PdfAVersions.PdfA3b);pdf.SaveAsPdfA("archive.pdf", PdfAVersions.PdfA3b)| Métrica | PuppeteerSharp | IronPDF | Melhoria |
|---|---|---|---|
| Primeiro PDF (Inicialização a frio) | 45s+ | ~20s | 55% mais rápido |
| PDFs subsequentes | Variável | Consistente | Previsível |
| Uso de memória | Mais de 500 MB (e continua crescendo) | ~50 MB (estável) | 90% menos memória |
| Espaço em disco (Chromium) | 300 MB ou mais | 0 | Eliminar downloads |
| Download do navegador | Obrigatório | Não é necessário | Configuração zero |
| Segurança da rosca | Limitado | Completo | Concorrência confiável |
| Tempo de geração do PDF | 45s | anos 20 | 55% mais rápido |
PuppeteerSharp.local-chromium para recuperar ~300MB de espaço em discoIronPdf: dotnet add package IronPdfBrowserFetcher.DownloadAsync()Puppeteer.LaunchAsync() e gerenciamento de navegadorpage.SetContentAsync() + page.PdfAsync() por RenderHtmlAsPdf()page.GoToAsync() + page.PdfAsync() por RenderUrlAsPdf()
Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.
IronPDF faz parte do IRON SUITE.
10 produtos de API .NET para seus documentos de escritório
Quando você precisa que seu PDF tenha a aparência de HTML, rapidamente.
