Iron Suite for .NET

10 bibliotecas .NET. Um conjunto completo de documentos.

Explore o Iron Suite

IRONPDF

IRONWORD

IRONXL

IRONPPT

IRONOCR

IRONBARCODE

IRONQR

IRONPRINT

IRONZIP

IRONWEBSCRAPER

COMPARAÇÃO

NReco.PdfGenerator vs IronPDF: Guia de Comparação Técnica

Curtis Chau

Updated: 26 de abril de 2026

Quando desenvolvedores .NET precisam criar PDFs a partir de conteúdo HTML, duas soluções distintas se destacam: Dramaturgo for .NET e IronPDF. Embora ambos possam gerar documentos PDF, seus fundamentos arquitetônicos, designs de API e casos de uso pretendidos diferem fundamentalmente. Esta comparação técnica examina Dramaturgo e IronPDF nas dimensões que mais importam para desenvolvedores e arquitetos profissionais que avaliam soluções de geração de PDF para aplicações .NET em 2025 e além.

Entendendo o Dramaturgo for .NET

Playwright for .NET é o framework de automação de navegador e teste de ponta a ponta da Microsoft. Como parte da família de ferramentas de automação da Microsoft, Dramaturgo fornece capacidades de teste completas em navegadores Chromium, Firefox e WebKit. A biblioteca adota um design "teste-primeiro", significando que seu foco principal está nos cenários de teste baseados em navegador.

O framework suporta a geração de PDF como um recurso adicional através de sua funcionalidade de impressão de página. Essa capacidade usa o mecanismo de impressão para PDF do navegador — equivalente a pressionar Ctrl+P em um navegador. Embora funcional para saída básica de PDF, essa abordagem produz documentos prontos para impressão otimizados para papel em vez de renderização precisa para tela. Layouts podem se reorganizar, fundos podem ser omitidos por padrão, e a saída é paginada para fins de impressão.

Uma consideração importante: a configuração padrão da ferramenta requer o download de múltiplos binários de navegadores (Chromium, Firefox e WebKit). Esse download do navegador deve ser concluído antes que a primeira geração de PDF possa ocorrer, o que afeta cenários de implantação e pipelines de CI/CD.

Limitação de Acessibilidade: Não pode produzir documentos compatíveis com PDF/A (arquivamento) ou PDF/UA (acessibilidade). Para conformidade com a Seção 508, diretivas de acessibilidade da UE ou requisitos de arquivamento a longo prazo, bibliotecas dedicadas de PDF se tornam necessárias.

Entendendo o IronPDF

IronPDF adota uma abordagem focada em PDF para a geração de documentos. Ao contrário de frameworks centrados em teste,IronPDFoferece uma API completa centrada em documento construída especificamente para criação, manipulação e processamento de PDF. A biblioteca usa um motor de renderização Chromium embutido e otimizado sem necessidade de instalações de navegador externas.

A arquitetura do IronPDFsuporta operações síncronas e assíncronas, oferecendo flexibilidade para diferentes padrões de aplicação. A biblioteca inclui recursos avançados de documentos, como assinaturas digitais, conformidade com PDF/A, preenchimento de formulários, marca d'água e segurança de documentos — capacidades que vão muito além da conversão básica de HTML para PDF.

O Problema do Framework de Teste

Usar o Dramaturgo para geração de PDF cria uma incompatibilidade arquitetônica. O framework foi projetado para automação de navegador e teste, não para geração de documentos. Essa diferença fundamental se manifesta de várias maneiras:

Aspecto	Dramaturgo	IronPDF
Objetivo principal	Teste de navegador	Geração de PDF
Download do navegador	Múltiplos navegadores (Chromium, Firefox, WebKit)	Motor otimizado integrado
Complexidade da API	Ciclo de vida assíncrono do navegador/contexto/página	Frases curtas síncronas
Inicialização	`playwright install` + CreateAsync + LaunchAsync	`new ChromePdfRenderer()`
Suporte PDF/A	Não disponível	Apoiado
Acessibilidade PDF/UA	Não disponível	Apoiado
Assinaturas digitais	Não disponível	Apoiado
Edição de PDF	Não disponível	Mesclar, dividir, carimbar, editar

O framework requer que os desenvolvedores compreendam os contextos dos navegadores, o gerenciamento de páginas e os padrões adequados de descarte. Essa complexidade faz sentido para cenários de teste, mas adiciona sobrecarga desnecessária quando o objetivo é simplesmente gerar documentos PDF.

Comparação de desempenho

As diferenças de desempenho entre Dramaturgo e IronPDF decorrem de suas abordagens arquitetônicas. O framework mantém instâncias completas de navegadores com motores de execução de JavaScript projetados para interação completa com a web. O mecanismo de renderização do IronPDF foca especificamente na otimização da saída PDF.

Métrica	Dramaturgo	IronPDF
Partida a frio	Download + inicialização do navegador	Apenas inicialização do motor
Modelo de Processamento	Automação de navegador completa por renderização	Motor de renderização dedicado
Perfil de Memória	Alocação por contexto de navegador	Motor compartilhado com menor overhead

O motor de renderização dedicado do IronPDFé projetado para reutilização eficiente uma vez inicializado. Esta abordagem reflete o overhead de manter contextos completos de navegador e ambientes de execução de JavaScript, que são projetados para interação completa com a web ao invés de saída PDF otimizada.

Conversão de HTML para PDF

O cenário mais comum de geração de PDF envolve converter conteúdo HTML para o formato PDF. Os padrões de código para essa operação revelam diferenças significativas na API.

Implementação HTML-para-PDF do Playwright

Playwright requer padrões assíncronos com gerenciamento explícito do ciclo de vida do navegador:

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

class Program
{
    static async Task Main(string[] args)
    {
        var playwright = await Playwright.CreateAsync();
        var browser = await playwright.Chromium.LaunchAsync();
        var page = await browser.NewPageAsync();
        
        string html = "<h1>Hello World</h1><p>This is a test PDF.</p>";
        await page.SetContentAsync(html);
        await page.PdfAsync(new PagePdfOptions { Path = "output.pdf" });
        
        await browser.CloseAsync();
    }
}

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

class Program
{
    static async Task Main(string[] args)
    {
        var playwright = await Playwright.CreateAsync();
        var browser = await playwright.Chromium.LaunchAsync();
        var page = await browser.NewPageAsync();
        
        string html = "<h1>Hello World</h1><p>This is a test PDF.</p>";
        await page.SetContentAsync(html);
        await page.PdfAsync(new PagePdfOptions { Path = "output.pdf" });
        
        await browser.CloseAsync();
    }
}

' NuGet: Install-Package Microsoft.Playwright
Imports Microsoft.Playwright
Imports System.Threading.Tasks

Module Program
    Async Function Main(args As String()) As Task
        Dim playwright = Await Playwright.CreateAsync()
        Dim browser = Await playwright.Chromium.LaunchAsync()
        Dim page = Await browser.NewPageAsync()

        Dim html As String = "<h1>Hello World</h1><p>This is a test PDF.</p>"
        Await page.SetContentAsync(html)
        Await page.PdfAsync(New PagePdfOptions With {.Path = "output.pdf"})

        Await browser.CloseAsync()
    End Function
End Module

' NuGet: Install-Package Microsoft.Playwright
Imports Microsoft.Playwright
Imports System.Threading.Tasks

Module Program
    Async Function Main(args As String()) As Task
        Dim playwright = Await Playwright.CreateAsync()
        Dim browser = Await playwright.Chromium.LaunchAsync()
        Dim page = Await browser.NewPageAsync()

        Dim html As String = "<h1>Hello World</h1><p>This is a test PDF.</p>"
        Await page.SetContentAsync(html)
        Await page.PdfAsync(New PagePdfOptions With {.Path = "output.pdf"})

        Await browser.CloseAsync()
    End Function
End Module

Este padrão requer:

Assinaturas de métodos assíncronos em toda a cadeia de chamadas
Criação e gerenciamento explícito de instâncias de navegador
Criação de contexto de página
Chamadas separadas para configuração de conteúdo e geração de PDF
Limpeza manual do navegador

Implementação de Conversão de HTML para PDF do IronPDF

IronPDF fornece uma API síncrona simplificada:

// NuGet: Install-Package IronPdf
using IronPdf;

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

// NuGet: Install-Package IronPdf
using IronPdf;

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

' NuGet: Install-Package IronPdf
Imports IronPdf

Module Program
    Sub Main(args As String())
        Dim renderer As New ChromePdfRenderer()

        Dim html As String = "<h1>Hello World</h1><p>This is a test PDF.</p>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")
    End Sub
End Module

' NuGet: Install-Package IronPdf
Imports IronPdf

Module Program
    Sub Main(args As String())
        Dim renderer As New ChromePdfRenderer()

        Dim html As String = "<h1>Hello World</h1><p>This is a test PDF.</p>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("output.pdf")
    End Sub
End Module

A abordagem do IronPDF elimina completamente o gerenciamento do ciclo de vida do navegador. A classe ChromePdfRenderer encapsula o motor de renderização, e RenderHtmlAsPdf lida com a conversão em uma única chamada de método. Para aplicativos que requerem padrões assíncronos, o IronPDFtambém fornece RenderHtmlAsPdfAsync.

Conversão de URL para PDF

Converter páginas web ao vivo para PDF requer buscar conteúdo remoto e lidar com o carregamento dinâmico de páginas.

Conversão URL do Playwright

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

class Program
{
    static async Task Main(string[] args)
    {
        var playwright = await Playwright.CreateAsync();
        var browser = await playwright.Chromium.LaunchAsync();
        var page = await browser.NewPageAsync();
        
        await page.GotoAsync("https://www.example.com");
        await page.PdfAsync(new PagePdfOptions 
        { 
            Path = "webpage.pdf",
            Format = "A4"
        });
        
        await browser.CloseAsync();
    }
}

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

class Program
{
    static async Task Main(string[] args)
    {
        var playwright = await Playwright.CreateAsync();
        var browser = await playwright.Chromium.LaunchAsync();
        var page = await browser.NewPageAsync();
        
        await page.GotoAsync("https://www.example.com");
        await page.PdfAsync(new PagePdfOptions 
        { 
            Path = "webpage.pdf",
            Format = "A4"
        });
        
        await browser.CloseAsync();
    }
}

' NuGet: Install-Package Microsoft.Playwright
Imports Microsoft.Playwright
Imports System.Threading.Tasks

Module Program
    Async Function Main(args As String()) As Task
        Dim playwright = Await Playwright.CreateAsync()
        Dim browser = Await playwright.Chromium.LaunchAsync()
        Dim page = Await browser.NewPageAsync()

        Await page.GotoAsync("https://www.example.com")
        Await page.PdfAsync(New PagePdfOptions With {
            .Path = "webpage.pdf",
            .Format = "A4"
        })

        Await browser.CloseAsync()
    End Function
End Module

' NuGet: Install-Package Microsoft.Playwright
Imports Microsoft.Playwright
Imports System.Threading.Tasks

Module Program
    Async Function Main(args As String()) As Task
        Dim playwright = Await Playwright.CreateAsync()
        Dim browser = Await playwright.Chromium.LaunchAsync()
        Dim page = Await browser.NewPageAsync()

        Await page.GotoAsync("https://www.example.com")
        Await page.PdfAsync(New PagePdfOptions With {
            .Path = "webpage.pdf",
            .Format = "A4"
        })

        Await browser.CloseAsync()
    End Function
End Module

A conversão de URL da ferramenta segue o mesmo padrão de ciclo de vida assíncrono do navegador, requerendo navegação via GotoAsync antes da geração do PDF.

Conversão de URL do 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");
    }
}

' NuGet: Install-Package IronPdf
Imports IronPdf

Module Program
    Sub Main(args As String())
        Dim renderer As New ChromePdfRenderer()

        Dim pdf = renderer.RenderUrlAsPdf("https://www.example.com")
        pdf.SaveAs("webpage.pdf")
    End Sub
End Module

' NuGet: Install-Package IronPdf
Imports IronPdf

Module Program
    Sub Main(args As String())
        Dim renderer As New ChromePdfRenderer()

        Dim pdf = renderer.RenderUrlAsPdf("https://www.example.com")
        pdf.SaveAs("webpage.pdf")
    End Sub
End Module

O método RenderUrlAsPdf do IronPDFlida com a navegação, carregamento de página e geração de PDF em uma única chamada. A biblioteca gerencia condições de espera internamente, embora os desenvolvedores possam configurar estratégias de espera explícitas quando necessário para páginas pesadas em JavaScript.

Configurações Personalizadas de PDF e Margens

A geração de PDF em produção geralmente requer controle sobre dimensões da página, margens e cabeçalhos/rodapés.

Configurações Personalizadas do Playwright

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

class Program
{
    static async Task Main(string[] args)
    {
        var playwright = await Playwright.CreateAsync();
        var browser = await playwright.Chromium.LaunchAsync();
        var page = await browser.NewPageAsync();
        
        string html = "<h1>Custom PDF</h1><p>With margins and headers.</p>";
        await page.SetContentAsync(html);
        
        await page.PdfAsync(new PagePdfOptions
        {
            Path = "custom.pdf",
            Format = "A4",
            Margin = new Margin { Top = "1cm", Bottom = "1cm", Left = "1cm", Right = "1cm" },
            DisplayHeaderFooter = true,
            HeaderTemplate = "<div style='font-size:10px; text-align:center;'>Header</div>",
            FooterTemplate = "<div style='font-size:10px; text-align:center;'>Page <span class='pageNumber'></span></div>"
        });
        
        await browser.CloseAsync();
    }
}

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

class Program
{
    static async Task Main(string[] args)
    {
        var playwright = await Playwright.CreateAsync();
        var browser = await playwright.Chromium.LaunchAsync();
        var page = await browser.NewPageAsync();
        
        string html = "<h1>Custom PDF</h1><p>With margins and headers.</p>";
        await page.SetContentAsync(html);
        
        await page.PdfAsync(new PagePdfOptions
        {
            Path = "custom.pdf",
            Format = "A4",
            Margin = new Margin { Top = "1cm", Bottom = "1cm", Left = "1cm", Right = "1cm" },
            DisplayHeaderFooter = true,
            HeaderTemplate = "<div style='font-size:10px; text-align:center;'>Header</div>",
            FooterTemplate = "<div style='font-size:10px; text-align:center;'>Page <span class='pageNumber'></span></div>"
        });
        
        await browser.CloseAsync();
    }
}

' NuGet: Install-Package Microsoft.Playwright
Imports Microsoft.Playwright
Imports System.Threading.Tasks

Module Program
    Async Function Main(args As String()) As Task
        Dim playwright = Await Playwright.CreateAsync()
        Dim browser = Await playwright.Chromium.LaunchAsync()
        Dim page = Await browser.NewPageAsync()
        
        Dim html As String = "<h1>Custom PDF</h1><p>With margins and headers.</p>"
        Await page.SetContentAsync(html)
        
        Await page.PdfAsync(New PagePdfOptions With {
            .Path = "custom.pdf",
            .Format = "A4",
            .Margin = New Margin With {.Top = "1cm", .Bottom = "1cm", .Left = "1cm", .Right = "1cm"},
            .DisplayHeaderFooter = True,
            .HeaderTemplate = "<div style='font-size:10px; text-align:center;'>Header</div>",
            .FooterTemplate = "<div style='font-size:10px; text-align:center;'>Page <span class='pageNumber'></span></div>"
        })
        
        Await browser.CloseAsync()
    End Function
End Module

' NuGet: Install-Package Microsoft.Playwright
Imports Microsoft.Playwright
Imports System.Threading.Tasks

Module Program
    Async Function Main(args As String()) As Task
        Dim playwright = Await Playwright.CreateAsync()
        Dim browser = Await playwright.Chromium.LaunchAsync()
        Dim page = Await browser.NewPageAsync()
        
        Dim html As String = "<h1>Custom PDF</h1><p>With margins and headers.</p>"
        Await page.SetContentAsync(html)
        
        Await page.PdfAsync(New PagePdfOptions With {
            .Path = "custom.pdf",
            .Format = "A4",
            .Margin = New Margin With {.Top = "1cm", .Bottom = "1cm", .Left = "1cm", .Right = "1cm"},
            .DisplayHeaderFooter = True,
            .HeaderTemplate = "<div style='font-size:10px; text-align:center;'>Header</div>",
            .FooterTemplate = "<div style='font-size:10px; text-align:center;'>Page <span class='pageNumber'></span></div>"
        })
        
        Await browser.CloseAsync()
    End Function
End Module

O framework usa valores de margem baseados em string (suportando unidades como "cm", "in", "px") e modelos HTML para cabeçalhos e rodapés. Os números de página usam espaços reservados baseados em classes CSS como <span class='pageNumber'></span>.

Configurações Personalizadas do IronPDF

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

class Program
{
    static void Main(string[] args)
    {
        var renderer = new ChromePdfRenderer();
        
        renderer.RenderingOptions.MarginTop = 10;
        renderer.RenderingOptions.MarginBottom = 10;
        renderer.RenderingOptions.MarginLeft = 10;
        renderer.RenderingOptions.MarginRight = 10;
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
        renderer.RenderingOptions.TextHeader.CenterText = "Header";
        renderer.RenderingOptions.TextFooter.CenterText = "Page {page}";
        
        string html = "<h1>Custom PDF</h1><p>With margins and headers.</p>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        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.MarginTop = 10;
        renderer.RenderingOptions.MarginBottom = 10;
        renderer.RenderingOptions.MarginLeft = 10;
        renderer.RenderingOptions.MarginRight = 10;
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
        renderer.RenderingOptions.TextHeader.CenterText = "Header";
        renderer.RenderingOptions.TextFooter.CenterText = "Page {page}";
        
        string html = "<h1>Custom PDF</h1><p>With margins and headers.</p>";
        var pdf = renderer.RenderHtmlAsPdf(html);
        pdf.SaveAs("custom.pdf");
    }
}

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

Module Program
    Sub Main(args As String())
        Dim renderer = New ChromePdfRenderer()
        
        renderer.RenderingOptions.MarginTop = 10
        renderer.RenderingOptions.MarginBottom = 10
        renderer.RenderingOptions.MarginLeft = 10
        renderer.RenderingOptions.MarginRight = 10
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
        renderer.RenderingOptions.TextHeader.CenterText = "Header"
        renderer.RenderingOptions.TextFooter.CenterText = "Page {page}"
        
        Dim html As String = "<h1>Custom PDF</h1><p>With margins and headers.</p>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("custom.pdf")
    End Sub
End Module

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

Module Program
    Sub Main(args As String())
        Dim renderer = New ChromePdfRenderer()
        
        renderer.RenderingOptions.MarginTop = 10
        renderer.RenderingOptions.MarginBottom = 10
        renderer.RenderingOptions.MarginLeft = 10
        renderer.RenderingOptions.MarginRight = 10
        renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
        renderer.RenderingOptions.TextHeader.CenterText = "Header"
        renderer.RenderingOptions.TextFooter.CenterText = "Page {page}"
        
        Dim html As String = "<h1>Custom PDF</h1><p>With margins and headers.</p>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        pdf.SaveAs("custom.pdf")
    End Sub
End Module

IronPDF usa valores de margem numéricos em milímetros, proporcionando clareza de unidade explícita. A biblioteca suporta tanto cabeçalhos/rodapés de texto simples quanto cabeçalhos e rodapés HTML completos com campos de mesclagem como {page} e {total-pages}.

Tamanhos de Página Personalizados

Ambas as bibliotecas suportam dimensões de página padrão e personalizadas.

Tamanho Personalizado do Playwright

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

class Program
{
    static async Task Main()
    {
        using var playwright = await Playwright.CreateAsync();
        await using var browser = await playwright.Chromium.LaunchAsync();
        var page = await browser.NewPageAsync();
        await page.SetContentAsync("<h1>Custom PDF</h1><p>Letter size with margins</p>");
        await page.PdfAsync(new PagePdfOptions 
        { 
            Path = "custom.pdf",
            Format = "Letter",
            Margin = new Margin { Top = "1in", Bottom = "1in", Left = "0.5in", Right = "0.5in" }
        });
    }
}

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

class Program
{
    static async Task Main()
    {
        using var playwright = await Playwright.CreateAsync();
        await using var browser = await playwright.Chromium.LaunchAsync();
        var page = await browser.NewPageAsync();
        await page.SetContentAsync("<h1>Custom PDF</h1><p>Letter size with margins</p>");
        await page.PdfAsync(new PagePdfOptions 
        { 
            Path = "custom.pdf",
            Format = "Letter",
            Margin = new Margin { Top = "1in", Bottom = "1in", Left = "0.5in", Right = "0.5in" }
        });
    }
}

Imports Microsoft.Playwright
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Using playwright = Await Playwright.CreateAsync()
            Await Using browser = Await playwright.Chromium.LaunchAsync()
                Dim page = Await browser.NewPageAsync()
                Await page.SetContentAsync("<h1>Custom PDF</h1><p>Letter size with margins</p>")
                Await page.PdfAsync(New PagePdfOptions With {
                    .Path = "custom.pdf",
                    .Format = "Letter",
                    .Margin = New Margin With {
                        .Top = "1in",
                        .Bottom = "1in",
                        .Left = "0.5in",
                        .Right = "0.5in"
                    }
                })
            End Using
        End Using
    End Function
End Module

Imports Microsoft.Playwright
Imports System.Threading.Tasks

Module Program
    Async Function Main() As Task
        Using playwright = Await Playwright.CreateAsync()
            Await Using browser = Await playwright.Chromium.LaunchAsync()
                Dim page = Await browser.NewPageAsync()
                Await page.SetContentAsync("<h1>Custom PDF</h1><p>Letter size with margins</p>")
                Await page.PdfAsync(New PagePdfOptions With {
                    .Path = "custom.pdf",
                    .Format = "Letter",
                    .Margin = New Margin With {
                        .Top = "1in",
                        .Bottom = "1in",
                        .Left = "0.5in",
                        .Right = "0.5in"
                    }
                })
            End Using
        End Using
    End Function
End Module

Tamanho Personalizado do 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 = 25;
        renderer.RenderingOptions.MarginBottom = 25;
        renderer.RenderingOptions.MarginLeft = 12;
        renderer.RenderingOptions.MarginRight = 12;
        var pdf = renderer.RenderHtmlAsPdf("<h1>Custom PDF</h1><p>Letter size with margins</p>");
        pdf.SaveAs("custom.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 = 25;
        renderer.RenderingOptions.MarginBottom = 25;
        renderer.RenderingOptions.MarginLeft = 12;
        renderer.RenderingOptions.MarginRight = 12;
        var pdf = renderer.RenderHtmlAsPdf("<h1>Custom PDF</h1><p>Letter size with margins</p>");
        pdf.SaveAs("custom.pdf");
    }
}

Imports IronPdf
Imports IronPdf.Rendering

Class Program
    Shared Sub Main()
        Dim renderer As New ChromePdfRenderer()
        renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter
        renderer.RenderingOptions.MarginTop = 25
        renderer.RenderingOptions.MarginBottom = 25
        renderer.RenderingOptions.MarginLeft = 12
        renderer.RenderingOptions.MarginRight = 12
        Dim pdf = renderer.RenderHtmlAsPdf("<h1>Custom PDF</h1><p>Letter size with margins</p>")
        pdf.SaveAs("custom.pdf")
    End Sub
End Class

Imports IronPdf
Imports IronPdf.Rendering

Class Program
    Shared Sub Main()
        Dim renderer As New ChromePdfRenderer()
        renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter
        renderer.RenderingOptions.MarginTop = 25
        renderer.RenderingOptions.MarginBottom = 25
        renderer.RenderingOptions.MarginLeft = 12
        renderer.RenderingOptions.MarginRight = 12
        Dim pdf = renderer.RenderHtmlAsPdf("<h1>Custom PDF</h1><p>Letter size with margins</p>")
        pdf.SaveAs("custom.pdf")
    End Sub
End Class

A enumeração PdfPaperSize do IronPDF fornece tamanhos padrão, enquanto dimensões personalizadas podem ser especificadas em milímetros através das opções de renderização.

Referência de Mapeamento de API

Equipes considerando a migração do Dramaturgo para o IronPDF podem consultar este mapeamento de operações equivalentes:

API do Dramaturgo	API IronPDF
`Playwright.CreateAsync()`	`new ChromePdfRenderer()`
`playwright.Chromium.LaunchAsync()`	Não é necessário
`browser.NewPageAsync()`	Não é necessário
`page.GotoAsync(url)`	`renderer.RenderUrlAsPdf(url)`
`page.SetContentAsync(html)` + `page.PdfAsync()`	`renderer.RenderHtmlAsPdf(html)`
`page.CloseAsync()`	Não é necessário
`browser.CloseAsync()`	Não é necessário
`PagePdfOptions.Format`	`RenderingOptions.PaperSize`
`PagePdfOptions.Margin`	`RenderingOptions.MarginTop/Bottom/Left/Right`
`PagePdfOptions.HeaderTemplate`	`RenderingOptions.HtmlHeader`
`PagePdfOptions.FooterTemplate`	`RenderingOptions.HtmlFooter`
N / D	`pdf.Merge()`
N / D	`pdf.SecuritySettings`
N / D	`pdf.Sign()`

Comparação de recursos

Além da conversão básica, as bibliotecas diferem substancialmente em capacidades de manipulação de documentos:

Recurso	Dramaturgo	IronPDF
HTML para PDF	Sim (impressão para PDF)	Sim (renderização Chromium)
URL para PDF	Sim	Sim
Suporte a CSS3	Sim	Sim
Execução de JavaScript	Sim	Sim
Arquivamento PDF/A	Não	Sim
Acessibilidade PDF/UA	Não	Sim
Assinaturas digitais	Não	Sim
Proteção por senha	Não	Sim
Mesclar PDFs	Não	Sim
Dividir PDFs	Não	Sim
Marcas d'água	Não	Sim
Preenchimento de formulários	Não	Sim
Extração de texto	Não	Sim
API Síncrona	Não	Sim
API Assíncrona	Sim	Sim

O conjunto de recursos do IronPDFse estende para segurança de documentos, manipulação e áreas de conformidade que o Dramaturgo simplesmente não aborda.

Quando as Equipes Consideram a Migração do Playwright

Vários fatores levam as equipes de desenvolvimento a avaliar alternativas ao Dramaturgo para geração de PDF:

Requisitos de download do navegador criam fricção no deployment. Vários binários de navegador devem ser baixados antes do primeiro uso, afetando os tamanhos dos contêineres, os tempos de pipeline de CI/CD e ambientes com conectividade limitada.

O overhead de framework de teste mostra-se desnecessário quando a geração de PDF é a única exigência. Equipes que mantêm o código de ciclo de vida do navegador, padrões assíncronos e lógica de descarte para geração de documentos adicionam complexidade sem benefício correspondente.

Recursos de documentos ausentes tornam-se bloqueadores quando os requisitos incluem assinaturas digitais, conformidade com PDF/A, proteção por senha ou manipulação de documentos. A abordagem de impressão para PDF do Dramaturgo não pode atender a essas necessidades.

Considerações de desempenho são importantes para geração de PDFs em grande volume. O motor de renderização dedicado do IronPDF evita o overhead de contextos completos de navegador, o que pode se traduzir em economia de recursos em escala.

Requisitos de conformidade para acessibilidade (Seção 508, PDF/UA) ou arquivamento (PDF/A) não podem ser atendidos com as capacidades atuais do Playwright.

Pontos Fortes e Concessões

Forças do Playwright

Automação de navegador abrangente para cenários de teste
Suporte entre navegadores (Chromium, Firefox, WebKit)
Mantido pela Microsoft com desenvolvimento ativo
Gratuito e de código aberto

Limitações do Dramaturgo para Geração de PDF

Arquitetura orientada a testes não otimizada para documentos
Grande download de vários navegadores necessário
Sem suporte a conformidade com PDF/A ou PDF/UA
Sem características de assinaturas digitais, segurança ou manipulação
Overhead de contexto de navegador por renderização
Padrões assíncronos complexos para operações simples

Pontos fortes do IronPDF

Desenvolvido especificamente para geração e manipulação de PDFs
Nenhum download de navegador externo necessário
Recursos de documentos abrangentes (assinaturas, segurança, formulários)
Suporte à conformidade com PDF/A e PDF/UA
Padrões de API síncronos e assíncronos
Pegada de memória menor e renderização mais rápida
Suporte profissional com documentação

Considerações sobre o IronPDF

Modelo de licenciamento comercial
Focado especificamente em operações de PDF (não em testes de navegador)

Conclusão

O Dramaturgo for .NET se destaca como um framework de automação e teste de navegador, com geração de PDF como uma capacidade secundária. Para equipes que já utilizam o Dramaturgo para testes e que ocasionalmente precisam de saída simples de PDF, a biblioteca fornece funcionalidade adequada.

Para aplicativos onde a geração de PDF representa um requisito central—especialmente aqueles que precisam de manipulação de documentos, recursos de segurança, conformidade de acessibilidade ou processamento em alta escala—o IronPDF oferece uma solução desenvolvida especificamente. O foco arquitetônico nas operações de PDF se traduz em APIs mais simples, melhor desempenho e recursos abrangentes de documentos que frameworks de teste não podem fornecer.

Ao avaliar a migração do Dramaturgo para o IronPDF, as equipes devem considerar seus requisitos específicos em torno de conformidade (PDF/A, PDF/UA), segurança (assinaturas digitais, criptografia), manipulação de documentos (mesclar, dividir, marca d'água) e desempenho em escala. Para fluxos de trabalho centrados em PDF visando .NET 10 e C# 14 em 2026, a arquitetura dedicada do IronPDF fornece uma base mais apropriada do que reutilizar um framework de testes.

Para orientações de implementação, explore o tutorial IronPDFHTML-to-PDF e documentação cobrindo os padrões de geração de PDF para aplicativos .NET.

Observe: Playwright é uma marca registrada de seu respectivo proprietário. Este site não é afiliado, endossado ou patrocinado pela Microsoft. Todos os nomes de produtos, logotipos e marcas são propriedade de seus respectivos proprietários. As comparações são apenas para fins informativos e refletem informações disponíveis publicamente no momento da redação.