Migrar do Microsoft Dramaturgo for .NET para o IronPDF move seu fluxo de trabalho de geração de PDF de uma estrutura de teste de automação de navegador para uma biblioteca de PDF construída para esse fim. Este guia fornece um caminho de migração passo a passo que remove o gerenciamento do ciclo de vida do navegador assíncrono e a etapa separada de download do playwright install binário do navegador.
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:
playwright installO 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:
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.
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.
Arquitetura focada em testes, não otimizada para geração de documentos em alto volume.
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.
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.
Uso de recursos do navegador por renderização quando cada PDF inicia contextos de navegador e páginas.
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)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 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 UsingOpçõ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 testeProxy: Interceptação de rede para testes (carga desnecessária)DownloadsPath: Gerenciamento de artefatos de testeTracesDir: Rastros de execução de testeGerenciamento 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
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 requiredSuperfí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.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");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.
| Métrica | Dramaturgo | IronPDF |
|---|---|---|
| Objetivo principal | Estrutura E2E de automação de navegador | Geração de documentos PDF |
| Filosofia de Design | Primeiro para testes; PDF é uma característica secundária | Biblioteca de PDF criada especificamente para esse fim |
| Pacote NuGet | Microsoft.Playwright (MIT) | IronPdf (comercial) |
| Passo do Binário do Navegador | Download separado de playwright install | Empacotado no pacote NuGet |
| Motores Suportando PDF | Somente Chromium (Firefox / WebKit não implementam Page.PdfAsync()) | Renderizador único baseado em Chromium empacotado |
| Primeira renderização (inicialização a frio) | 4,5 segundos | 2,8 segundos |
| Renderizações subsequentes | 3,8 a 4,1 segundos | 0,8-1,2 segundos |
| Memória por conversão | 280-420 MB | 80-120 MB |
| Estilo API | Ciclo de vida assíncrono do navegador/contexto/página | Síncrono ou assíncrono; renderer-based |
| Inicialização | CreateAsync() + LaunchAsync() + NewPageAsync() | 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 |
| Modelo de Suporte | Comunidade | Comercial com SLA |
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.
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.
# 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 IronPdfNão é necessário playwright install com o IronPDF - o motor de renderização é agrupado automaticamente.
// Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";' Add at application startup
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"// 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| 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.DisplayHeaderFooter | TextFooter |
PagePdfOptions.HeaderTemplate | RenderingOptions.HtmlHeader |
PagePdfOptions.FooterTemplate | RenderingOptions.HtmlFooter |
<span class='pageNumber'> | {page} |
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
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 ModuleApó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
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 ModuleEste 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.
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
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 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");
}
}' 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 ModuleO 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 .
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" }
});
}
}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 ModuleApó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");
}
}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 ClassO 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.
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
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 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.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 ModuleEste 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é.
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;
}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 ClassO dramaturgo utiliza unidades de cordas; O IronPDF usa milímetros numéricos:
| Dramaturgo | IronPDF (mm) |
|---|---|
"1in" | 25 |
"0.5in" | 12 |
"1cm" | 10 |
| Aula de Dramaturgia | Espaço reservado para IronPDF |
|---|---|
<span class='pageNumber'> | {page} |
<span class='totalPages'> | {total-pages} |
<span class='date'> | {date} |
<span class='title'> | {html-title} |
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
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("output.pdf")Após migrar para o IronPDF, você obtém recursos que o Dramaturgo não pode oferecer:
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")pdf.ApplyWatermark("<h1 style='color:red; opacity:0.3;'>DRAFT</h1>");IRON VB CONVERTER ERROR developers@ironsoftware.compdf.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)Microsoft.Playwright.playwright (e quaisquer binários de navegador Dramaturgo armazenados em cache sob o seu perfil de usuário)IronPdf: dotnet add package IronPdfChromePdfRendererpage.SetContentAsync() + page.PdfAsync() para RenderHtmlAsPdf()page.GotoAsync() + page.PdfAsync() para 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.
