Como migrar do Playwright para o IronPDF em C#

Entendendo o Dramaturgo for .NET

Playwright for .NET (NuGet Microsoft.Playwright, licenciado pelo MIT) é o framework de automação de navegador da Microsoft, projetado principalmente para testes de ponta a ponta no Chromium, Firefox e WebKit. Seus fluxos de trabalho típicos são interativos: clicar em botões, preencher formulários, interceptar solicitações de rede, tirar capturas de tela e validar a compatibilidade entre navegadores.

A geração de PDF no Dramaturgo é um recurso secundário exposto via Page.PdfAsync() e é suportado apenas no Chromium — Firefox e WebKit não implementam saída de PDF. A saída usa o caminho de impressão para PDF do navegador (equivalente a Ctrl+P), o que tem implicações para layouts, fundos e paginação:

• Arquitetura focada em testes, não otimizada para produção de documentos sem cabeça
• Os binários do navegador (Chromium e, opcionalmente, Firefox e WebKit) devem ser instalados separadamente via playwright install
• API assíncrona projetada para fluxos de trabalho de automação de testes
• Sem conformidade integrada com PDF/A, PDF/UA, assinatura digital, marca d'água, mesclagem ou recursos de segurança

Considerações ao Usar Dramaturgo para PDFs

O Dramaturgo foi projetado para testes de ponta a ponta, não para geração de documentos. Algumas implicações práticas ao reutilizá-lo para PDFs:

1. Binários do navegador via playwright install. A configuração padrão do Dramaturgo faz o download de binários do navegador (Chromium, Firefox, WebKit), o que pode ser uma consideração para ambientes com restrições rigorosas de recursos ou implantação.

2. Modelo de navegador/contêiner/página assíncrono. Os desenvolvedores precisam estar confortáveis com contextos de navegador e gestão do ciclo de vida da página, incluindo disposição.

3. Arquitetura focada em testes, não otimizada para geração de documentos em alto volume.

4. Semântica de impressão-para-PDF equivalente a impressão Ctrl+P no navegador. Os layouts podem ser reorganizados, os planos de fundo podem ser omitidos por padrão e a saída é paginada para impressão.

5. Sem saída PDF/A ou PDF/UA. O Dramaturgo não produz documentos conformes com PDF/A (arquivamento) ou PDF/UA (acessibilidade). Para a Seção 508, diretivas de acessibilidade da UE ou requisitos de arquivamento a longo prazo, uma biblioteca de PDF dedicada é normalmente necessária.

6. Uso de recursos do navegador por renderização quando cada PDF inicia contextos de navegador e páginas.

Superfície de Configuração

Playwright expõe uma superfície de configuração orientada para automação de testes. As peças mais relevantes quando usadas apenas para geração de PDF:

Etapa de instalação do navegador:

# Separate installation step before first use
playwright install            # Downloads browser binaries (Chromium, Firefox, WebKit)
# Or for a single browser:
playwright install chromium   # Chromium-only (the only engine that supports PDF output)

# Separate installation step before first use
playwright install            # Downloads browser binaries (Chromium, Firefox, WebKit)
# Or for a single browser:
playwright install chromium   # Chromium-only (the only engine that supports PDF output)

Configuração de inicialização do navegador:

// Testing-focused launch options for PDF generation
using var playwright = await Playwright.CreateAsync();
var browser = await playwright.Chromium.LaunchAsync(new BrowserTypeLaunchOptions
{
    Headless = true,  // Required for server environments
    Args = new[] { "--disable-gpu", "--no-sandbox" } // Linux/Docker configs
});

// Testing-focused launch options for PDF generation
using var playwright = await Playwright.CreateAsync();
var browser = await playwright.Chromium.LaunchAsync(new BrowserTypeLaunchOptions
{
    Headless = true,  // Required for server environments
    Args = new[] { "--disable-gpu", "--no-sandbox" } // Linux/Docker configs
});

' Testing-focused launch options for PDF generation
Using playwright = Await Playwright.CreateAsync()
    Dim browser = Await playwright.Chromium.LaunchAsync(New BrowserTypeLaunchOptions With {
        .Headless = True,  ' Required for server environments
        .Args = New String() { "--disable-gpu", "--no-sandbox" } ' Linux/Docker configs
    })
End Using

Opções de configuração específicas para testes:

• Headless: Deve configurar o modo headless para produção (padrão é com interface para testes)
• SlowMo: Delays no tempo de teste (irrelevante para geração de PDF)
• Devtools: Configuração de ferramentas de teste (não necessário para documentos)
• ExecutablePath: Caminhos personalizados do navegador para ambientes de teste
• Proxy: Interceptação de rede para testes (carga desnecessária)
• DownloadsPath: Gerenciamento de artefatos de teste
• TracesDir: Rastros de execução de teste

Gerenciamento do contexto do navegador:

// Complex context lifecycle from testing paradigm
var context = await browser.NewContextAsync(new BrowserNewContextOptions
{
    ViewportSize = new ViewportSize { Width = 1920, Height = 1080 },
    UserAgent = "custom-user-agent",
    Locale = "en-US",
    TimezoneId = "America/New_York"
});
var page = await context.NewPageAsync();
// ... generate PDF ...
await context.CloseAsync();  // Manual cleanup required
await browser.CloseAsync();  // Manual cleanup required

// Complex context lifecycle from testing paradigm
var context = await browser.NewContextAsync(new BrowserNewContextOptions
{
    ViewportSize = new ViewportSize { Width = 1920, Height = 1080 },
    UserAgent = "custom-user-agent",
    Locale = "en-US",
    TimezoneId = "America/New_York"
});
var page = await context.NewPageAsync();
// ... generate PDF ...
await context.CloseAsync();  // Manual cleanup required
await browser.CloseAsync();  // Manual cleanup required

' Complex context lifecycle from testing paradigm
Dim context = Await browser.NewContextAsync(New BrowserNewContextOptions With {
    .ViewportSize = New ViewportSize With {.Width = 1920, .Height = 1080},
    .UserAgent = "custom-user-agent",
    .Locale = "en-US",
    .TimezoneId = "America/New_York"
})
Dim page = Await context.NewPageAsync()
' ... generate PDF ...
Await context.CloseAsync()  ' Manual cleanup required
Await browser.CloseAsync()  ' Manual cleanup required

Superfície de vários navegadores:

// Dramaturgo supports launching multiple engines
await playwright.Chromium.LaunchAsync();  // For Chromium-based testing (and PDF output)
await playwright.Firefox.LaunchAsync();   // For Firefox testing
await playwright.Webkit.LaunchAsync();    // For WebKit/Safari testing
// Note: Page.PdfAsync() is implemented on Chromium only.

// Dramaturgo supports launching multiple engines
await playwright.Chromium.LaunchAsync();  // For Chromium-based testing (and PDF output)
await playwright.Firefox.LaunchAsync();   // For Firefox testing
await playwright.Webkit.LaunchAsync();    // For WebKit/Safari testing
// Note: Page.PdfAsync() is implemented on Chromium only.

Option Strict On



' Dramaturgo supports launching multiple engines
Await playwright.Chromium.LaunchAsync()  ' For Chromium-based testing (and PDF output)
Await playwright.Firefox.LaunchAsync()   ' For Firefox testing
Await playwright.Webkit.LaunchAsync()    ' For WebKit/Safari testing
' Note: Page.PdfAsync() is implemented on Chromium only.

IronPDF: renderizador único embalado

// No separate browser-binary install or context management
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");

// No separate browser-binary install or context management
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");

Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")

IronPDF distribui seu motor de renderização dentro do pacote NuGet, assim não há etapa separada de playwright install e não há ciclo de vida de navegador/contexto/página para gerenciar.

Comparação de desempenho entre Dramaturgo e IronPDF

IronPDF é construído especificamente para geração de PDFs, com uma superfície de API focada em documentos. Ele usa um único motor de renderização baseado em Chromium embutido e suporta operações síncronas e assíncronas, o que dá aos desenvolvedores um modelo mental mais simples quando a saída de PDF — não a interação com o navegador — é o objetivo.

Conclusão

Playwright é uma forte escolha quando a carga de trabalho primária é automação de navegador ou testes entre navegadores, sendo a saída de PDF uma tarefa secundária ocasional.IronPDF é a melhor opção quando a geração de PDF é a carga de trabalho principal: não há etapa de instalação de binário de navegador separada, nem ciclo de vida de navegador/contexto/página para gerenciar, e recursos de documento como PDF/A, assinaturas digitais, segurança e mesclagem estão disponíveis imediatamente.

Pré-requisitos

1. Ambiente .NET : .NET Framework 4.6.2+ ou .NET Core 3.1+ / .NET 5/6/7/8/9+
2. Acesso ao NuGet : Capacidade de instalar pacotes NuGet.
3. Licença do IronPDF: Obtenha sua chave de licença em IronPDF

Alterações no pacote NuGet

# Remove Playwright
dotnet remove package Microsoft.Playwright

# Remove the downloaded browser binaries
# Delete the .playwright folder in your project (and any cached binaries
# under your user profile, e.g. %USERPROFILE%\.cache\ms-playwright on Windows)

# Add IronPDF
dotnet add package IronPdf

# Remove Playwright
dotnet remove package Microsoft.Playwright

# Remove the downloaded browser binaries
# Delete the .playwright folder in your project (and any cached binaries
# under your user profile, e.g. %USERPROFILE%\.cache\ms-playwright on Windows)

# Add IronPDF
dotnet add package IronPdf

Não é necessário playwright install com o IronPDF - o motor de renderização é agrupado automaticamente.

Configuração de licença

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

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

' Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

Alterações de namespace

// Before: Playwright
using Microsoft.Playwright;
using System.Threading.Tasks;

// After: IronPDF
using IronPdf;
using IronPdf.Rendering;

// Before: Playwright
using Microsoft.Playwright;
using System.Threading.Tasks;

// After: IronPDF
using IronPdf;
using IronPdf.Rendering;

' Before: Playwright
Imports Microsoft.Playwright
Imports System.Threading.Tasks

' After: IronPDF
Imports IronPdf
Imports IronPdf.Rendering

Mapeamentos da API principal

Exemplo 1: Conversão de string HTML para PDF

Antes (Dramaturgo):

// 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();
    }
}

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

Após (IronPDF):

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

Imports IronPdf

Class Program
    Shared Sub Main(ByVal args As String())
        Dim renderer = 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 Class

Este exemplo demonstra a diferença arquitetônica fundamental. O Dramaturgo requer cinco operações assíncronas: Playwright.CreateAsync(), Chromium.LaunchAsync(), NewPageAsync(), SetContentAsync() e PdfAsync(), além da limpeza explícita do navegador com CloseAsync().

IronPDF elimina toda essa complexidade: crie um ChromePdfRenderer, chame RenderHtmlAsPdf() e SaveAs(). Sem padrões assíncronos, sem ciclo de vida do navegador, sem código de limpeza. 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.

Exemplo 2: Conversão de URL para PDF

Antes (Dramaturgo):

// 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();
    }
}

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

Apó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");
    }
}

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 Class

O Dramaturgo usa GotoAsync() para navegar até uma URL seguido por PdfAsync().IronPDF fornece um único método RenderUrlAsPdf() que lida com navegação e geração de PDF em uma única chamada. Observe que o Dramaturgo requer especificar o Format em PagePdfOptions, enquanto o IronPDF usa RenderingOptions.PaperSize para configuração de tamanho de papel. Saiba mais em nossos tutoriais .

Exemplo 3: Tamanho de página personalizado com margens

Antes (Dramaturgo):

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

Após (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

O Dramaturgo usa valores de margem baseados em string ("1in", "0.5in") enquanto o IronPDF usa valores numéricos em milímetros. A conversão é: 1 polegada = 25,4mm, então "1in" torna-se 25 e "0.5in" torna-se aproximadamente 12. O Format = "Letter" do Dramaturgo mapeia para o PaperSize = PdfPaperSize.Letter do IronPDF.

Exemplo 4: Cabeçalhos, rodapés e configurações personalizadas

Antes (Dramaturgo):

// 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();
    }
}

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

Após (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");
    }
}

Imports IronPdf
Imports IronPdf.Rendering

Class Program
    Shared 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 Class

Este exemplo mostra a diferença na sintaxe dos espaços reservados para cabeçalho e rodapé. O Dramaturgo usa placeholders baseados em classes HTML (<span class='pageNumber'></span>), enquanto o IronPDF usa placeholders com chaves ({page}). Observe que o Dramaturgo requer DisplayHeaderFooter = true para habilitar cabeçalhos/rodapés, enquanto o IronPDF os habilita automaticamente quando você define o conteúdo do cabeçalho/rodapé.

Conversão de assíncrono para síncrono

O Dramaturgo requer async/await em todo o processo; O IronPDF suporta operações síncronas:

// Playwright: Async required
public async Task<byte[]> GeneratePdfAsync(string html)
{
    using var playwright = await Playwright.CreateAsync();
    await using var browser = await playwright.Chromium.LaunchAsync();
    var page = await browser.NewPageAsync();
    await page.SetContentAsync(html);
    return await page.PdfAsync();
}

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

// Playwright: Async required
public async Task<byte[]> GeneratePdfAsync(string html)
{
    using var playwright = await Playwright.CreateAsync();
    await using var browser = await playwright.Chromium.LaunchAsync();
    var page = await browser.NewPageAsync();
    await page.SetContentAsync(html);
    return await page.PdfAsync();
}

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

Imports System.Threading.Tasks
Imports Microsoft.Playwright

Public Class PdfGenerator
    ' Playwright: Async required
    Public Async Function GeneratePdfAsync(html As String) As Task(Of Byte())
        Using playwright = Await Playwright.CreateAsync()
            Await Using browser = Await playwright.Chromium.LaunchAsync()
                Dim page = Await browser.NewPageAsync()
                Await page.SetContentAsync(html)
                Return Await page.PdfAsync()
            End Using
        End Using
    End Function

    ' IronPDF: Sync is simpler
    Public Function GeneratePdf(html As String) As Byte()
        Dim renderer = New ChromePdfRenderer()
        Return renderer.RenderHtmlAsPdf(html).BinaryData
    End Function
End Class

Conversão de Unidades de Margem

O dramaturgo utiliza unidades de cordas; O IronPDF usa milímetros numéricos:

Conversão de espaços reservados para cabeçalho/rodapé

Eliminação do ciclo de vida do navegador

Remova todo o código de gerenciamento do navegador:

// Playwright: Explicit cleanup required
await page.CloseAsync();
await browser.CloseAsync();
playwright.Dispose();

// IronPDF: No disposal needed - just use the renderer
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");

// Playwright: Explicit cleanup required
await page.CloseAsync();
await browser.CloseAsync();
playwright.Dispose();

// IronPDF: No disposal needed - just use the renderer
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("output.pdf");

' Playwright: Explicit cleanup required
Await page.CloseAsync()
Await browser.CloseAsync()
playwright.Dispose()

' IronPDF: No disposal needed - just use the renderer
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")

Fusão de PDFs

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");

Dim pdf1 = renderer.RenderHtmlAsPdf(html1)
Dim pdf2 = renderer.RenderHtmlAsPdf(html2)
Dim merged = PdfDocument.Merge(pdf1, pdf2)
merged.SaveAs("merged.pdf")

Marcas d'água

pdf.ApplyWatermark("<h1 style='color:red; opacity:0.3;'>DRAFT</h1>");

pdf.ApplyWatermark("<h1 style='color:red; opacity:0.3;'>DRAFT</h1>");

IRON VB CONVERTER ERROR developers@ironsoftware.com

Proteção por senha

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

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

pdf.SecuritySettings.OwnerPassword = "admin"
pdf.SecuritySettings.UserPassword = "readonly"
pdf.SecuritySettings.AllowUserCopyPasteContent = False

Assinaturas digitais

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

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

Dim signature = New PdfSignature("certificate.pfx", "password")
pdf.Sign(signature)

Conformidade com PDF/A

pdf.SaveAsPdfA("archive.pdf", PdfAVersions.PdfA3b);

pdf.SaveAsPdfA("archive.pdf", PdfAVersions.PdfA3b);

pdf.SaveAsPdfA("archive.pdf", PdfAVersions.PdfA3b)

Pré-migração

• Identificar todos os códigos de geração de PDF do Playwright
• Valores das margens do documento (converter polegadas/cm para milímetros)
• Observe a sintaxe dos espaços reservados para cabeçalho/rodapé para conversão.
• Obtenha a chave de licença do IronPDF em IronPDF

Alterações no pacote

• Remova o pacote NuGet Microsoft.Playwright
• Exclua a pasta .playwright (e quaisquer binários de navegador Dramaturgo armazenados em cache sob o seu perfil de usuário)
• Instale o pacote NuGet IronPdf: dotnet add package IronPdf

Alterações no código

• Atualizar importações de namespace
• Substitua o ciclo de vida assíncrono do navegador por ChromePdfRenderer
• Converta page.SetContentAsync() + page.PdfAsync() para RenderHtmlAsPdf()
• Converta page.GotoAsync() + page.PdfAsync() para RenderUrlAsPdf()
• Converter strings de margem em valores em milímetros
• Converter sintaxe de espaço reservado de cabeçalho/rodapé
• Remover todos os códigos de descarte de navegador/página
• Adicionar inicialização de licença na inicialização do aplicativo

Pós-migração

• Comparação visual da saída em PDF
• Verificar a renderização do cabeçalho/rodapé com os números de página
• Testar a precisão das margens e do dimensionamento da página
• Adicionar novas funcionalidades (segurança, marcas d'água, mesclagem) conforme necessário.