1. IronPDF
  2. Tutoriais
  3. Geração de PDFs com .NET Core
Como gerar arquivos PDF no .NET Core

Converter HTML para PDF em .NET Core usando C# com IronPDF

Jacob Mellor, Diretor de Tecnologia da Team Iron
Jacob Mellor
Atualizado:
This article was translated from English: Does it need improvement?
Translated
View the article in English

Gerar PDFs de alta fidelidade diretamente a partir de HTML é um requisito rotineiro em aplicações .NET modernas — relatórios, faturas e ingressos precisam de uma saída com qualidade impecável que corresponda à interface web. O IronPDF simplifica esse fluxo de trabalho ao expor uma única API C# para renderizar HTML, visualizações Razor e sites completos em documentos PDF compatíveis com os padrões. Ao final deste guia, o desenvolvedor será capaz de converter URLs, HTML bruto ou visualizações MVC em um projeto ASP.NET Core e implantar o mesmo código em ambientes Windows, Linux, Docker ou sem servidor.

PontasPara problemas de layout, o IronPDF fornece um depurador independente de Chrome que ajuda a diagnosticar peculiaridades de CSS, JavaScript e media-query antes que o PDF seja renderizado. Consulte o guia dedicado de conversão de HTML para PDF com perfeição de pixels para obter técnicas detalhadas.

Início rápido: Criar um PDF a partir de HTML no .NET Core

Converta HTML para PDF sem esforço em .NET Core usando a biblioteca IronPDF . Este guia fornece um exemplo simples para você começar rapidamente, renderizando conteúdo HTML em um PDF de alta qualidade com o mínimo de código. Ideal para desenvolvedores que desejam integrar a criação de PDFs em seus aplicativos com facilidade.

  1. Instale IronPDF com o Gerenciador de Pacotes NuGet

    PM > Install-Package IronPdf

  2. Copie e execute este trecho de código.

    var pdf = new IronPdf.ChromePdfRenderer().RenderHtmlAsPdf("<h1>Hello World</h1>");

  3. Implante para testar em seu ambiente de produção.

    Comece a usar IronPDF em seu projeto hoje com uma avaliação gratuita

    arrow pointer

Fluxo de trabalho mínimo (5 etapas)

  1. Instale o pacote NuGet IronPDF
  2. ConverterURLde site com RenderUrlAsPdf
  3. Renderizar HTML bruto através de RenderHtmlAsPdf
  4. Exportar uma visualização MVC para PDF
  5. Ajuste o tamanho do papel, as margens, os cabeçalhos e os rodapés.

Lista de verificação de início rápido

  1. Instalar – Install-Package IronPdf
  2. Renderizar uma URL – ChromePdfRenderer.RenderUrlAsPdf()
  3. Renderizar HTML bruto – ChromePdfRenderer.RenderHtmlAsPdf()
  4. Exportar uma view Razor – ChromePdfRenderer.RenderHtmlAsPdfAsync()
  5. Ajuste fino da saída – alavancar ChromePdfRenderer.RenderingOptions

O que este tutorial aborda

  • Conversão de URL, string HTML e visão Razor
  • Configuração de papel, margem e tipo de mídia
  • Implantação multiplataforma (Windows, Linux, Docker)
  • Pós-processamento: mesclar, adicionar marca d'água, proteger com senha e assinar digitalmente PDFs
  • Exemplo completo: aplicativo MVC de reserva de ingressos

Como faço para instalar a biblioteca PDF no .NET Core?

A instalação da biblioteca é feita com apenas uma linha de comando em qualquer projeto .NET 8 e permanece compatível com versões futuras do .NET 9 (prévia) e com o lançamento do .NET 10. Utilize o Console do Gerenciador de Pacotes do NuGet e o gerenciador de pacotes resolverá automaticamente todas as dependências para Windows, Linux, Docker e ambientes sem servidor.

PM> Install-Package IronPdf             # .NET 8 LTS and higher
PM> Install-Package IronPdf             # .NET 8 LTS and higher
SHELL

Observe Precisa da linha de comando? O mesmo comando funciona com dotnet add package IronPdf dentro da pasta do seu projeto.

Após a instalação, confirme se tudo está conectado convertendo qualquerURLpública:

// Program.cs — .NET 8 LTS
using IronPdf;

var renderer = new ChromePdfRenderer();

// Render a live website to PDF
using PdfDocument pdf = renderer.RenderUrlAsPdf("https://example.com");

// Persist to disk
pdf.SaveAs("website-snapshot.pdf");
// Program.cs — .NET 8 LTS
using IronPdf;

var renderer = new ChromePdfRenderer();

// Render a live website to PDF
using PdfDocument pdf = renderer.RenderUrlAsPdf("https://example.com");

// Persist to disk
pdf.SaveAs("website-snapshot.pdf");
' Program.cs — .NET 8 LTS
Imports IronPdf

Private renderer = New ChromePdfRenderer()

' Render a live website to PDF
Private PdfDocument As using

' Persist to disk
pdf.SaveAs("website-snapshot.pdf")
$vbLabelText   $csharpLabel

Como funciona

  • ChromePdfRenderer inicia uma instância do Chromium em sandbox nos bastidores — nenhuma instalação separada do Chrome é necessária.
  • RenderUrlAsPdf captura o DOM totalmente renderizado, incluindo conteúdo baseado em JavaScript, consultas de mídia CSS e fontes.
  • O resultado PdfDocument expõe métodos auxiliares para mesclar, proteger com senha ou assinar digitalmente a saída — funcionalidades abordadas posteriormente neste tutorial.

Para obter mais detalhes sobre as nuances de implantação (Azure App Service, AWS Lambda, Linux local), consulte o guia de instalação específico e as páginas de configuração avançada do NuGet . Dicas internas de CI/CD para clusters Docker e K8s são abordadas nas melhores práticas de implantação do Docker .

Como um serviço .NET Core pode converter umURLde um site ativo em PDF?

Basta uma única chamada para RenderUrlAsPdf: passe qualquerURLpublicamente acessível e o IronPDF retornará um PDF totalmente renderizado e em conformidade com os padrões. O código abaixo é direcionado ao .NET 8 LTS e compila sem alterações no .NET 9 Preview, bem como na futura versão do .NET 10, prevista para 2025.

Exemplo passo a passo

// Program.cs — .NET 8 LTS-compatible
using IronPdf;

// 1. Activate a license (or trial key)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

// 2. Create a reusable renderer instance
var renderer = new ChromePdfRenderer
{
    RenderingOptions =
    {
        // Force A4 portrait output and apply @media print styles
        PaperSize    = PdfPaperSize.A4,
        CssMediaType = PdfCssMediaType.Print
    }
};

// 3. Convert Microsoft Docs home page to PDF
using PdfDocument pdf = renderer.RenderUrlAsPdf("https://learn.microsoft.com/");

// 4. Save the PDF or stream it from a Web API
pdf.SaveAs("docs-offline-copy.pdf");
// Program.cs — .NET 8 LTS-compatible
using IronPdf;

// 1. Activate a license (or trial key)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";

// 2. Create a reusable renderer instance
var renderer = new ChromePdfRenderer
{
    RenderingOptions =
    {
        // Force A4 portrait output and apply @media print styles
        PaperSize    = PdfPaperSize.A4,
        CssMediaType = PdfCssMediaType.Print
    }
};

// 3. Convert Microsoft Docs home page to PDF
using PdfDocument pdf = renderer.RenderUrlAsPdf("https://learn.microsoft.com/");

// 4. Save the PDF or stream it from a Web API
pdf.SaveAs("docs-offline-copy.pdf");
' Program.cs — .NET 8 LTS-compatible
Imports IronPdf

' 1. Activate a license (or trial key)
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"

' 2. Create a reusable renderer instance
Dim renderer = New ChromePdfRenderer With {
	.RenderingOptions = {
		PaperSize = PdfPaperSize.A4,
		CssMediaType = PdfCssMediaType.Print
	}
}

' 3. Convert Microsoft Docs home page to PDF
Using pdf As PdfDocument = renderer.RenderUrlAsPdf("https://learn.microsoft.com/")
	
	' 4. Save the PDF or stream it from a Web API
	pdf.SaveAs("docs-offline-copy.pdf")
End Using
$vbLabelText   $csharpLabel

Por que funciona

  • ChromePdfRenderer inicia uma instância do Chromium em sandbox — sem dependência do Chrome do sistema, mantendo as imagens do Docker compactas.
  • RenderUrlAsPdf aguarda a conclusão do DOM e do JavaScript antes de gerar o snapshot, para que os aplicativos de página única sejam renderizados corretamente.
  • Definir CssMediaType como Imprimir instrui o mecanismo a usar regras específicas de impressão, correspondendo à saída Imprimir → Salvar como PDF de um navegador. O código resultante PdfDocument pode ser criptografado, assinado digitalmente, mesclado ou rasterizado — funcionalidades abordadas em seções posteriores.

Pontas Depuração perfeita em pixels: habilite renderer.LoggingOptions.DebugMode = true e siga o guia de depuração do Chrome sem interface gráfica para inspecionar as DevTools em tempo real durante a renderização.

Recursos relacionados

Como faço para converter HTML bruto em PDF no .NET Core?

Passar uma string HTML — ou a marcação renderizada de uma view Razor — para ChromePdfRenderer.RenderHtmlAsPdf produz instantaneamente um PDF compatível com os padrões. O método inicia o mecanismo Chromium integrado do IronPDF, portanto, não é necessária a instalação de um navegador externo nem a dependência do WebView. O mesmo código mostrado abaixo compila no .NET 8 LTS atualmente e permanece compatível com o .NET 9 e com o lançamento previsto do .NET 10 em novembro de 2025.

Exemplo — gerar um PDF a partir de um fragmento HTML

// Program.cs — compatible with .NET 8 and newer
using IronPdf;

// Sample HTML fragment (could also be read from a file, Razor view, or CMS)
const string html = """
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Quarterly Report</title>
  <style>
     body { font-family:'Segoe UI', sans-serif; margin:1.2rem; }
     header { margin-bottom:2rem; }
     h1 { color:#3056d3; }
     table { width:100%; border-collapse:collapse; margin-top:1rem; }
     th,td { border:1px solid #ddd; padding:0.5rem; text-align:right; }
     tr:nth-child(even){ background-color:#f8f9fa; }
  </style>
</head>
<body>
  <header><h1>Q2 Revenue Summary</h1></header>
  <table>
    <thead><tr><th>Product</th><th>Revenue ($)</th></tr></thead>
    <tbody>
      <tr><td>IronPDF for .NET</td><td>1,200,000</td></tr>
      <tr><td>IronOCR for .NET</td><td>890,000</td></tr>
      <tr><td>IronXL for .NET</td><td>610,000</td></tr>
    </tbody>
  </table>
</body>
</html>
""";

// 1. Create a renderer once and reuse it across conversions
var renderer = new ChromePdfRenderer
{
    RenderingOptions =
    {
        PaperSize    = PdfPaperSize.A4,                  // ISO-standard paper size
        PaperOrientation = PdfPaperOrientation.Portrait,
        CssMediaType = PdfCssMediaType.Screen,           // Respect on-screen CSS
        RenderDelay  = 100,                              // Wait 100 ms for JS/animations
        FallbackEncoding = "utf-8"                       // Handle non-ASCII correctly
    }
};

// 2. Render the HTML fragment
using PdfDocument pdf = renderer.RenderHtmlAsPdf(html);

// 3. Persist to disk or return via ASP.NET Core FileStreamResult
pdf.SaveAs("q2-report.pdf");
// Program.cs — compatible with .NET 8 and newer
using IronPdf;

// Sample HTML fragment (could also be read from a file, Razor view, or CMS)
const string html = """
<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <title>Quarterly Report</title>
  <style>
     body { font-family:'Segoe UI', sans-serif; margin:1.2rem; }
     header { margin-bottom:2rem; }
     h1 { color:#3056d3; }
     table { width:100%; border-collapse:collapse; margin-top:1rem; }
     th,td { border:1px solid #ddd; padding:0.5rem; text-align:right; }
     tr:nth-child(even){ background-color:#f8f9fa; }
  </style>
</head>
<body>
  <header><h1>Q2 Revenue Summary</h1></header>
  <table>
    <thead><tr><th>Product</th><th>Revenue ($)</th></tr></thead>
    <tbody>
      <tr><td>IronPDF for .NET</td><td>1,200,000</td></tr>
      <tr><td>IronOCR for .NET</td><td>890,000</td></tr>
      <tr><td>IronXL for .NET</td><td>610,000</td></tr>
    </tbody>
  </table>
</body>
</html>
""";

// 1. Create a renderer once and reuse it across conversions
var renderer = new ChromePdfRenderer
{
    RenderingOptions =
    {
        PaperSize    = PdfPaperSize.A4,                  // ISO-standard paper size
        PaperOrientation = PdfPaperOrientation.Portrait,
        CssMediaType = PdfCssMediaType.Screen,           // Respect on-screen CSS
        RenderDelay  = 100,                              // Wait 100 ms for JS/animations
        FallbackEncoding = "utf-8"                       // Handle non-ASCII correctly
    }
};

// 2. Render the HTML fragment
using PdfDocument pdf = renderer.RenderHtmlAsPdf(html);

// 3. Persist to disk or return via ASP.NET Core FileStreamResult
pdf.SaveAs("q2-report.pdf");
' Program.cs — compatible with .NET 8 and newer
Imports IronPdf

' Sample HTML fragment (could also be read from a file, Razor view, or CMS)
Private Const html As String = "<!DOCTYPE html>
<html lang=""en"">
<head>
  <meta charset=""utf-8"">
  <title>Quarterly Report</title>
  <style>
     body { font-family:'Segoe UI', sans-serif; margin:1.2rem; }
     header { margin-bottom:2rem; }
     h1 { color:#3056d3; }
     table { width:100%; border-collapse:collapse; margin-top:1rem; }
     th,td { border:1px solid #ddd; padding:0.5rem; text-align:right; }
     tr:nth-child(even){ background-color:#f8f9fa; }
  </style>
</head>
<body>
  <header><h1>Q2 Revenue Summary</h1></header>
  <table>
    <thead><tr><th>Product</th><th>Revenue ($)</th></tr></thead>
    <tbody>
      <tr><td>IronPDF for .NET</td><td>1,200,000</td></tr>
      <tr><td>IronOCR for .NET</td><td>890,000</td></tr>
      <tr><td>IronXL for .NET</td><td>610,000</td></tr>
    </tbody>
  </table>
</body>
</html>"

' 1. Create a renderer once and reuse it across conversions
Private renderer = New ChromePdfRenderer With {
	.RenderingOptions = {
		PaperSize = PdfPaperSize.A4,
		PaperOrientation = PdfPaperOrientation.Portrait,
		CssMediaType = PdfCssMediaType.Screen,
		RenderDelay = 100,
		FallbackEncoding = "utf-8"
	}
}

' 2. Render the HTML fragment
Private PdfDocument As using

' 3. Persist to disk or return via ASP.NET Core FileStreamResult
pdf.SaveAs("q2-report.pdf")
$vbLabelText   $csharpLabel

O que o código demonstra

  • Chromium Embutido — IronPDF vem com o motor Chromium, garantindo paridade HTML5, CSS3 e JavaScript com navegadores modernos.
  • Dependência única — Uma instalação leve do NuGet cobre Windows, Linux, Docker e Azure/AWS sem bibliotecas de sistema adicionais.
  • Opções de renderização — PaperSize, CssMediaType e RenderDelay espelham as configurações de impressão do navegador para que os PDFs correspondam aos layouts na tela.
  • Alvo preparado para o futuro — A superfície da API é a mesma no .NET 8, .NET 9 STS e no próximo .NET 10, portanto, a manutenção de longo prazo é mínima.
  • Ganchos de pós-processamento — PdfDocument expõe auxiliares para mesclagem, proteção por senha e assinaturas digitais — cada um abordado posteriormente neste guia.

Para saber mais: consulte o tutorial passo a passo de conversão de string HTML para PDF e a documentação completa da API ChromePdfRenderer .

Como exportar uma view do .NET Core MVC para PDF?

IronPDF renderiza uma visualização Razor totalmente processada ( .cshtml ) da mesma forma que um navegador faria e transmite o resultado como um PdfDocument. O fluxo de trabalho abaixo mantém a lógica do controlador limpa, não requer plugins de navegador e funciona no .NET 8 LTS, no .NET 9 Preview e na versão .NET 10, com lançamento previsto para novembro de 2025.

Exemplo de controlador de ponta a ponta

// TicketsController.cs — .NET 8 LTS / MVC
using IronPdf;
using Microsoft.AspNetCore.Mvc;
using YourApp.Models;           // TicketViewModel

public class TicketsController : Controller
{
    private readonly ChromePdfRenderer _renderer;

    public TicketsController()
    {
        _renderer = new ChromePdfRenderer
        {
            RenderingOptions =
            {
                PaperSize        = PdfPaperSize.A5,            // Compact ticket size
                PaperOrientation = PdfPdfOrientation.Portrait,
                FitToPaperWidth  = true,
                CssMediaType     = PdfCssMediaType.Print,
                Margins = new PdfMargins(5, 10, 5, 10)         // mm
            }
        };
    }

    // GET /Tickets/Print/42
    public async Task<IActionResult> Print(int id)
    {
        TicketViewModel vm = await _service.GetTicketAsync(id);

        // 1. Render the Razor view to an HTML string
        string html  = await RazorTemplateEngine.RenderViewAsync(
                           HttpContext, "~/Views/Tickets/Print.cshtml", vm);

        // 2. Convert HTML → PDF
        using PdfDocument pdf = _renderer.RenderHtmlAsPdf(html);

        // 3. Stream back as a file
        return File(pdf.BinaryData, "application/pdf",
                    $"ticket-{id}.pdf");
    }
}
// TicketsController.cs — .NET 8 LTS / MVC
using IronPdf;
using Microsoft.AspNetCore.Mvc;
using YourApp.Models;           // TicketViewModel

public class TicketsController : Controller
{
    private readonly ChromePdfRenderer _renderer;

    public TicketsController()
    {
        _renderer = new ChromePdfRenderer
        {
            RenderingOptions =
            {
                PaperSize        = PdfPaperSize.A5,            // Compact ticket size
                PaperOrientation = PdfPdfOrientation.Portrait,
                FitToPaperWidth  = true,
                CssMediaType     = PdfCssMediaType.Print,
                Margins = new PdfMargins(5, 10, 5, 10)         // mm
            }
        };
    }

    // GET /Tickets/Print/42
    public async Task<IActionResult> Print(int id)
    {
        TicketViewModel vm = await _service.GetTicketAsync(id);

        // 1. Render the Razor view to an HTML string
        string html  = await RazorTemplateEngine.RenderViewAsync(
                           HttpContext, "~/Views/Tickets/Print.cshtml", vm);

        // 2. Convert HTML → PDF
        using PdfDocument pdf = _renderer.RenderHtmlAsPdf(html);

        // 3. Stream back as a file
        return File(pdf.BinaryData, "application/pdf",
                    $"ticket-{id}.pdf");
    }
}
Imports IronPdf
Imports Microsoft.AspNetCore.Mvc
Imports YourApp.Models ' TicketViewModel

Public Class TicketsController
    Inherits Controller

    Private ReadOnly _renderer As ChromePdfRenderer

    Public Sub New()
        _renderer = New ChromePdfRenderer With {
            .RenderingOptions = New PdfRenderingOptions With {
                .PaperSize = PdfPaperSize.A5, ' Compact ticket size
                .PaperOrientation = PdfPdfOrientation.Portrait,
                .FitToPaperWidth = True,
                .CssMediaType = PdfCssMediaType.Print,
                .Margins = New PdfMargins(5, 10, 5, 10) ' mm
            }
        }
    End Sub

    ' GET /Tickets/Print/42
    Public Async Function Print(id As Integer) As Task(Of IActionResult)
        Dim vm As TicketViewModel = Await _service.GetTicketAsync(id)

        ' 1. Render the Razor view to an HTML string
        Dim html As String = Await RazorTemplateEngine.RenderViewAsync(
            HttpContext, "~/Views/Tickets/Print.cshtml", vm)

        ' 2. Convert HTML → PDF
        Using pdf As PdfDocument = _renderer.RenderHtmlAsPdf(html)
            ' 3. Stream back as a file
            Return File(pdf.BinaryData, "application/pdf", $"ticket-{id}.pdf")
        End Using
    End Function
End Class
$vbLabelText   $csharpLabel

O que este código ilustra

  • Sem arquivos temporários — a visualização Razor é renderizada na memória e, em seguida, passada diretamente para RenderHtmlAsPdf , evitando E/S de disco e condições de corrida de pasta temporária.
  • Impressão em tamanho de ingresso — PaperSize = A5 e margens estreitas mantêm os ingressos para impressão em casa compactos.
  • Estilos de impressão consistentes — CssMediaType = Print aplica as mesmas regras CSS @media print que os navegadores usam.
  • Streaming binário — pdf.BinaryData transmite o documento sem acessar o sistema de arquivos; Ideal para endpoints de API e funções Lambda.
  • Renderizador reutilizável — ChromePdfRenderer é instanciado uma vez por controlador e, em seguida, reutilizado, minimizando a sobrecarga de criação de processos.

PaperSize , PaperOrientation , FitToPaperWidth

Margins , Header , Footer , Watermark

Próximo passo: adicione criptografia, assinaturas digitais ou combine vários ingressos em um único arquivo. Veja o exemplo de combinação e o guia de instruções para assinatura digital .

Como posso ajustar com precisão o tamanho do papel, as margens, os cabeçalhos, as marcas d'água e a segurança antes da renderização?

O IronPDF expõe um único objeto ChromePdfRenderOptions que controla todos os aspectos da saída — dimensões do papel, orientação, cabeçalhos e rodapés, temporização do JavaScript , marcas d'água, criptografia e assinaturas digitais — tudo sem plugins adicionais do navegador.

Exemplo de código — aplicar várias opções simultaneamente

// AdvancedOptions.cs — .NET 8 compatible
using IronPdf;

var renderer = new ChromePdfRenderer();

// Configure everything in one place
renderer.RenderingOptions = new ChromePdfRenderOptions
{
    // 1. Page layout
    PaperSize        = PdfPaperSize.A4,                     // ISO size
    PaperOrientation = PdfPdfOrientation.Portrait,
    Margins          = new PdfMargins { Top = 20, Bottom = 25, Left = 15, Right = 15 }, // mm

    // 2. Timing & media
    CssMediaType     = PdfCssMediaType.Print,               // Respect @media print
    EnableJavaScript = true,
    RenderDelay      = 200,                                 // Wait 200 ms for animations

    // 3. Headers & footers (HTML gives full design freedom)
    HtmlHeader       = "<header style='font:14px Segoe UI'>Invoice — {{date}}</header>",
    HtmlFooter       = "<footer style='text-align:right;font-size:10px'>Page {{page}} / {{total-pages}}</footer>",

    // 4. Watermark
    Watermark        = new HtmlStamp
    {
        HtmlTemplate = "<div style='font-size:50px;color:#cccccc;opacity:0.3;'>CONFIDENTIAL</div>",
        VerticalAlignment = VerticalAlignment.Center,
        HorizontalAlignment = HorizontalAlignment.Center
    },

    // 5. Security
    SecurityOptions = new PdfSecurityOptions
    {
        OwnerPassword = "StrongOwnerPwd!",
        UserPassword  = "ReadOnly",
        AllowUserPrinting = false,
        AllowUserCopyPasteContent = false
    }
};

// Render any HTML
using PdfDocument pdf = renderer.RenderHtmlAsPdf("<h1>Advanced Options Demo</h1>");

// Digitally sign with a PFX certificate (optional)
pdf.SignAndStamp("./certs/company.pfx", "Iron Software", "Bangkok", "Approval");

// Save
pdf.SaveAs("advanced-options-demo.pdf");
// AdvancedOptions.cs — .NET 8 compatible
using IronPdf;

var renderer = new ChromePdfRenderer();

// Configure everything in one place
renderer.RenderingOptions = new ChromePdfRenderOptions
{
    // 1. Page layout
    PaperSize        = PdfPaperSize.A4,                     // ISO size
    PaperOrientation = PdfPdfOrientation.Portrait,
    Margins          = new PdfMargins { Top = 20, Bottom = 25, Left = 15, Right = 15 }, // mm

    // 2. Timing & media
    CssMediaType     = PdfCssMediaType.Print,               // Respect @media print
    EnableJavaScript = true,
    RenderDelay      = 200,                                 // Wait 200 ms for animations

    // 3. Headers & footers (HTML gives full design freedom)
    HtmlHeader       = "<header style='font:14px Segoe UI'>Invoice — {{date}}</header>",
    HtmlFooter       = "<footer style='text-align:right;font-size:10px'>Page {{page}} / {{total-pages}}</footer>",

    // 4. Watermark
    Watermark        = new HtmlStamp
    {
        HtmlTemplate = "<div style='font-size:50px;color:#cccccc;opacity:0.3;'>CONFIDENTIAL</div>",
        VerticalAlignment = VerticalAlignment.Center,
        HorizontalAlignment = HorizontalAlignment.Center
    },

    // 5. Security
    SecurityOptions = new PdfSecurityOptions
    {
        OwnerPassword = "StrongOwnerPwd!",
        UserPassword  = "ReadOnly",
        AllowUserPrinting = false,
        AllowUserCopyPasteContent = false
    }
};

// Render any HTML
using PdfDocument pdf = renderer.RenderHtmlAsPdf("<h1>Advanced Options Demo</h1>");

// Digitally sign with a PFX certificate (optional)
pdf.SignAndStamp("./certs/company.pfx", "Iron Software", "Bangkok", "Approval");

// Save
pdf.SaveAs("advanced-options-demo.pdf");
Imports IronPdf

Dim renderer As New ChromePdfRenderer()

' Configure everything in one place
renderer.RenderingOptions = New ChromePdfRenderOptions With {
    ' 1. Page layout
    .PaperSize = PdfPaperSize.A4, ' ISO size
    .PaperOrientation = PdfPdfOrientation.Portrait,
    .Margins = New PdfMargins With {.Top = 20, .Bottom = 25, .Left = 15, .Right = 15}, ' mm

    ' 2. Timing & media
    .CssMediaType = PdfCssMediaType.Print, ' Respect @media print
    .EnableJavaScript = True,
    .RenderDelay = 200, ' Wait 200 ms for animations

    ' 3. Headers & footers (HTML gives full design freedom)
    .HtmlHeader = "<header style='font:14px Segoe UI'>Invoice — {{date}}</header>",
    .HtmlFooter = "<footer style='text-align:right;font-size:10px'>Page {{page}} / {{total-pages}}</footer>",

    ' 4. Watermark
    .Watermark = New HtmlStamp With {
        .HtmlTemplate = "<div style='font-size:50px;color:#cccccc;opacity:0.3;'>CONFIDENTIAL</div>",
        .VerticalAlignment = VerticalAlignment.Center,
        .HorizontalAlignment = HorizontalAlignment.Center
    },

    ' 5. Security
    .SecurityOptions = New PdfSecurityOptions With {
        .OwnerPassword = "StrongOwnerPwd!",
        .UserPassword = "ReadOnly",
        .AllowUserPrinting = False,
        .AllowUserCopyPasteContent = False
    }
}

' Render any HTML
Using pdf As PdfDocument = renderer.RenderHtmlAsPdf("<h1>Advanced Options Demo</h1>")
    ' Digitally sign with a PFX certificate (optional)
    pdf.SignAndStamp("./certs/company.pfx", "Iron Software", "Bangkok", "Approval")

    ' Save
    pdf.SaveAs("advanced-options-demo.pdf")
End Using
$vbLabelText   $csharpLabel

Por que essas opções são importantes?

  • PaperSize, Margins e CssMediaType espelham a caixa de diálogo de impressão de um navegador, de modo que os layouts na tela e o PDF permaneçam idênticos no Windows, Linux e Docker.
  • cabeçalhos e rodapés HTML suportam tokens Razor, CSS e JavaScript—úteis para números de página dinâmicos ou branding.
  • HtmlStamp permite criar marcas d'água personalizadas com uma única linha de código, com controle total de HTML e CSS.
  • As opções de segurança permitem criptografia de 128 bits, senhas de proprietário/usuário e permissões granulares sem a necessidade de ferramentas de terceiros.
  • As assinaturas digitais adicionam um selo criptográfico diretamente no código, mantendo a autenticidade legal e a inviolabilidade.
  • Auxiliares de extração como ExtractAllText e ExtractAllImages revertem o processo quando a análise é necessária.

Referência rápida — Configurações populares

PaperSize , PaperOrientation , Margins , CssMediaType , RenderDelay

HtmlHeader , HtmlFooter , marcadores Razor dinâmicos, tokens de número de página

Watermark , HtmlStamp , opacidade, alinhamento

SecurityOptions , SignAndStamp , senhas de proprietário/usuário, selagem de certificado

Próximas tarefas: mesclar vários PDFs, extrair texto e imagens e implantar em Docker ou em um sistema sem servidor. Continue para a seção de implantação para garantir a paridade entre plataformas.

Como posso implantar um código de geração de PDF no Docker em sistemas Linux e Windows?

IronPdf é distribuído como um único pacote NuGet independente , portanto, a conteinerização de um aplicativo ASP.NET Core (ou de console) é simples tanto no Windows quanto no Linux . A chave é copiar os binários publicados para uma imagem de tempo de execução compacta e, no Linux, adicionar as duas bibliotecas nativas que o IronPDF requer (libnss3 e libatk1.0-0).

Dockerfile de múltiplos estágios (Ubuntu 22.04)

Observe Por que várias etapas? A imagem do SDK (etapa 1) compila o projeto; A imagem final de tempo de execução (estágio 2) permanece compacta — < 120 MB — porque as ferramentas de compilação são descartadas.

####### ---------- stage 1 ----------
FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
WORKDIR /src
COPY ["MyPdfApp.csproj", "."]
RUN dotnet restore

COPY . .
RUN dotnet publish -c Release -o /app/publish

####### ---------- stage 2 ----------
FROM mcr.microsoft.com/dotnet/aspnet:8.0-jammy
######## Install two native libs required by Chromium
RUN apt-get update && \
    apt-get install -y --no-install-recommends libnss3 libatk1.0-0 && \
    rm -rf /var/lib/apt/lists/*

WORKDIR /app
COPY --from=build /app/publish .
ENTRYPOINT ["dotnet", "MyPdfApp.dll"]

Contêineres do Windows? Substitua o segundo estágio por: nenhum pacote adicional é necessário, pois as DLLs do Chromium já estão incluídas.

Script de validação de ponta a ponta

docker build -t pdf-demo .
docker run --rm -p 8080:80 pdf-demo
######### ↳ Navigate to http://localhost:8080/api/pdf?url=https://example.com
docker build -t pdf-demo .
docker run --rm -p 8080:80 pdf-demo
######### ↳ Navigate to http://localhost:8080/api/pdf?url=https://example.com
SHELL
  • A ação da API chama internamente ChromePdfRenderer.RenderUrlAsPdf assim como na Seção 2. O IronPDF inicia seu processo Chromium em sandbox dentro do contêiner — nenhum servidor X é necessário porque ele renderiza sem interface gráfica.
  • O consumo de memória permanece abaixo de 200 MB mesmo durante renderizações grandes.

Pontas Dica de resolução de problemas: Se os logs do contêiner mostrarem um erro "libnss3.so não encontrado" , confirme se ambos libnss3 e libatk1.0-0 estão presentes. As imagens alpinas não são suportadas porque a biblioteca musl C não possui os símbolos necessários.

Recursos internos

Como posso abrir, mesclar, adicionar marcas d'água e extrair conteúdo de PDFs existentes no .NET Core?

O IronPDF trata todos os PDFs — sejam eles gerados pelo IronPDF, Adobe® Acrobat ou ferramentas de terceiros — como objetos de primeira classe que podem ser abertos, editados, protegidos e salvos novamente sem perda de qualidade. A mesma superfície de API funciona no .NET 8 LTS atualmente e compila sem alterações no .NET 9 Preview e na futura versão do .NET 10.

Amostra unificada — abrir → mesclar → marca d'água → extrair

// ManipulateExistingPdf.cs — .NET 8 LTS compatible
using IronPdf;
using System.Linq;

// Step 1: Open two existing files (password-protected PDFs are supported)
PdfDocument invoice  = PdfDocument.FromFile("invoice.pdf", "ReadOnly");   // open with user pwd
PdfDocument tAndCs   = PdfDocument.FromFile("terms.pdf");                 // no pwd required

// Step 2: Merge them (invoice pages first, then T&Cs)
PdfDocument mergedPdf = PdfDocument.Merge(invoice, tAndCs);               // 1-liner merge

// Step 3: Apply a diagonal CONFIDENTIAL watermark to every page
mergedPdf.ApplyStamp(
    "<div style='font-size:60px;color:#d9534f;opacity:0.2;transform:rotate(-45deg);"
  + "width:100%;text-align:center;'>CONFIDENTIAL</div>",
    verticalAlignment   : VerticalAlignment.Center,
    horizontalAlignment : HorizontalAlignment.Center);

// Step 4: Extract all text and the first image for audit purposes
string fullText = mergedPdf.ExtractAllText();
var    image    = mergedPdf.ExtractAllImages().FirstOrDefault();

// Step 5: Save or stream
mergedPdf.SaveAs("invoice-with-terms.pdf");
// ManipulateExistingPdf.cs — .NET 8 LTS compatible
using IronPdf;
using System.Linq;

// Step 1: Open two existing files (password-protected PDFs are supported)
PdfDocument invoice  = PdfDocument.FromFile("invoice.pdf", "ReadOnly");   // open with user pwd
PdfDocument tAndCs   = PdfDocument.FromFile("terms.pdf");                 // no pwd required

// Step 2: Merge them (invoice pages first, then T&Cs)
PdfDocument mergedPdf = PdfDocument.Merge(invoice, tAndCs);               // 1-liner merge

// Step 3: Apply a diagonal CONFIDENTIAL watermark to every page
mergedPdf.ApplyStamp(
    "<div style='font-size:60px;color:#d9534f;opacity:0.2;transform:rotate(-45deg);"
  + "width:100%;text-align:center;'>CONFIDENTIAL</div>",
    verticalAlignment   : VerticalAlignment.Center,
    horizontalAlignment : HorizontalAlignment.Center);

// Step 4: Extract all text and the first image for audit purposes
string fullText = mergedPdf.ExtractAllText();
var    image    = mergedPdf.ExtractAllImages().FirstOrDefault();

// Step 5: Save or stream
mergedPdf.SaveAs("invoice-with-terms.pdf");
' ManipulateExistingPdf.cs — .NET 8 LTS compatible
Imports IronPdf
Imports System.Linq

' Step 1: Open two existing files (password-protected PDFs are supported)
Private invoice As PdfDocument = PdfDocument.FromFile("invoice.pdf", "ReadOnly") ' open with user pwd
Private tAndCs As PdfDocument = PdfDocument.FromFile("terms.pdf") ' no pwd required

' Step 2: Merge them (invoice pages first, then T&Cs)
Private mergedPdf As PdfDocument = PdfDocument.Merge(invoice, tAndCs) ' 1-liner merge

' Step 3: Apply a diagonal CONFIDENTIAL watermark to every page
mergedPdf.ApplyStamp("<div style='font-size:60px;color:#d9534f;opacity:0.2;transform:rotate(-45deg);" & "width:100%;text-align:center;'>CONFIDENTIAL</div>", verticalAlignment := VerticalAlignment.Center, horizontalAlignment := HorizontalAlignment.Center)

' Step 4: Extract all text and the first image for audit purposes
Dim fullText As String = mergedPdf.ExtractAllText()
Dim image = mergedPdf.ExtractAllImages().FirstOrDefault()

' Step 5: Save or stream
mergedPdf.SaveAs("invoice-with-terms.pdf")
$vbLabelText   $csharpLabel

Por que isso é importante?

  • Abrir e mesclar – PdfDocument.FromFile carrega qualquer PDF compatível com os padrões, incluindo arquivos criptografados, enquanto PdfDocument.Merge concatena um número arbitrário de documentos em uma única chamada.
  • Marca d'água – ApplyStamp (também conhecida como HtmlStamp) incorpora sobreposições HTML/CSS totalmente estilizadas — logotipo, código QR ou texto diagonal — em páginas selecionadas sem rasterização.
  • Extração de conteúdo – ExtractAllText e ExtractAllImages extraem fluxos de texto UTF-8 bruto ou imagens binárias para arquivamento subsequente ou pipelines de IA.
  • Assinaturas digitais prontas – a mesma instância PdfDocument pode ser selada com SignAndStamp, produzindo hashes compatíveis com RFC 3161 alinhados com os requisitos de assinatura digital ISO 32000-2 .
  • Conformidade com padrões abertos – O IronPDF preserva a estrutura original do PDF (fontes, camadas, metadados XMP), de modo que a saída permaneça compatível com o Adobe® Reader e outros visualizadores ISO 32000-1 .
  • Preparada para o futuro – A API evita assemblies de interoperabilidade e chamadas GDI do Win32, portanto o código é executado sem alterações no Windows, Linux, Docker e nas futuras versões serverless do .NET 10.

Precisa dividir, girar ou excluir páginas? Consulte o tutorial de edição em nível de página para obter informações sobre operações detalhadas.

Como os PDFs podem ser criptografados e assinados digitalmente no .NET Core?

O IronPDF protege um documento em duas etapas: criptografia baseada em AES (senhas de usuário/proprietário + permissões granulares) e assinaturas digitais X.509 que selam o arquivo com um hash criptográfico. Ambas as APIs residem no mesmo objeto PdfDocument, portanto o fluxo de trabalho é idêntico no .NET 8 LTS atualmente e compila sem alterações no .NET 9 preview e na futura versão do .NET 10.

Exemplo — aplicar AES de 256 bits, bloquear direitos de impressão e adicionar uma assinatura visível.

// SecureAndSign.cs — .NET 8 LTS compatible
using IronPdf;

// Step 1: Load an existing PDF (or produce one with RenderHtmlAsPdf)
PdfDocument pdf = PdfDocument.FromFile("financial-report.pdf");

// Step 2: Configure AES-256 encryption & permissions
pdf.SecuritySettings = new PdfSecuritySettings
{
    EncryptionAlgorithm   = PdfEncryptionAlgorithm.AES256Bit,
    OwnerPassword         = "IronAdmin!2025",
    UserPassword          = "ReadOnly",
    AllowUserPrinting     = PdfPrintSecurity.Disabled,
    AllowUserCopyPasteContent = false,
    AllowUserAnnotations  = false
};

// Step 3: Digitally sign with a PFX certificate
pdf.SignAndStamp(
    certificatePath : "./certs/ironsoftware.pfx",
    authority       : "Iron Software Ltd.",
    location        : "Chicago, IL",
    reason          : "Final approval"
);

// Step 4: Persist or stream
pdf.SaveAs("financial-report-secured-signed.pdf");
// SecureAndSign.cs — .NET 8 LTS compatible
using IronPdf;

// Step 1: Load an existing PDF (or produce one with RenderHtmlAsPdf)
PdfDocument pdf = PdfDocument.FromFile("financial-report.pdf");

// Step 2: Configure AES-256 encryption & permissions
pdf.SecuritySettings = new PdfSecuritySettings
{
    EncryptionAlgorithm   = PdfEncryptionAlgorithm.AES256Bit,
    OwnerPassword         = "IronAdmin!2025",
    UserPassword          = "ReadOnly",
    AllowUserPrinting     = PdfPrintSecurity.Disabled,
    AllowUserCopyPasteContent = false,
    AllowUserAnnotations  = false
};

// Step 3: Digitally sign with a PFX certificate
pdf.SignAndStamp(
    certificatePath : "./certs/ironsoftware.pfx",
    authority       : "Iron Software Ltd.",
    location        : "Chicago, IL",
    reason          : "Final approval"
);

// Step 4: Persist or stream
pdf.SaveAs("financial-report-secured-signed.pdf");
' SecureAndSign.cs — .NET 8 LTS compatible
Imports IronPdf

' Step 1: Load an existing PDF (or produce one with RenderHtmlAsPdf)
Private pdf As PdfDocument = PdfDocument.FromFile("financial-report.pdf")

' Step 2: Configure AES-256 encryption & permissions
pdf.SecuritySettings = New PdfSecuritySettings With {
	.EncryptionAlgorithm = PdfEncryptionAlgorithm.AES256Bit,
	.OwnerPassword = "IronAdmin!2025",
	.UserPassword = "ReadOnly",
	.AllowUserPrinting = PdfPrintSecurity.Disabled,
	.AllowUserCopyPasteContent = False,
	.AllowUserAnnotations = False
}

' Step 3: Digitally sign with a PFX certificate
pdf.SignAndStamp(certificatePath := "./certs/ironsoftware.pfx", authority := "Iron Software Ltd.", location := "Chicago, IL", reason := "Final approval")

' Step 4: Persist or stream
pdf.SaveAs("financial-report-secured-signed.pdf")
$vbLabelText   $csharpLabel

Nos bastidores

  • Criptografia AES-256 — IronPDF envolve a carga com chaves AES aprovadas pelo NIST, bloqueando a abertura, impressão ou cópia não autorizadas.
  • Granularidade de permissões — propriedades como AllowUserPrinting e AllowUserFormData ativam ou desativam direitos por ação; É necessária uma senha de proprietário para que qualquer restrição entre em vigor.
  • Assinaturas digitais — SignAndStamp incorpora um carimbo de data/hora RFC 3161 e uma cadeia de certificados, criando hashes à prova de adulteração reconhecidos pelo Adobe® Acrobat e outros visualizadores ISO 32000-2.
  • API unificada — tanto a criptografia quanto a assinatura modificam a mesma instância PdfDocument, evitando múltiplas passagens de arquivo e preservando fontes internas, camadas e metadados.

Dica de solução de problemas: se o Adobe Reader reportar "assinatura inválida", verifique se o arquivo PFX contém um certificado raiz confiável e se as strings location estão livres de caracteres ASCII.

Configurações básicas de segurança

PdfSecuritySettings → OwnerPassword , UserPassword , EncryptionAlgorithm , AllowUserPrinting

PdfDocument.SignAndStamp — Caminho PFX, autoridade, localização, motivo, carimbo de data/hora

Recursos internos para análises mais aprofundadas

Como otimizar e escalar o desempenho da conversão de HTML para PDF no .NET Core?

O motor Chromium do IronPDF já renderiza a maioria das páginas em < 1 s em hardware moderno, mas o throughput pode ser multiplicado por acumular renderizações, habilitar multithreading e reduzir a sobrecarga do Headless Chrome. As dicas abaixo se aplicam igualmente a todas as versões do .NET .

1. Renderizações em lote em um pool de threads em segundo plano

// BatchRender.cs — Thread-safe on .NET 8+
using IronPdf;
using System.Threading.Tasks;

var htmlSources = Directory.GetFiles("./html", "*.html");
var renderer    = new ChromePdfRenderer();                 // reuse 1 instance

Parallel.ForEach(htmlSources, new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount }, file =>
{
    string html = File.ReadAllText(file);
    using PdfDocument pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs(Path.ChangeExtension(file, ".pdf"));
});
// BatchRender.cs — Thread-safe on .NET 8+
using IronPdf;
using System.Threading.Tasks;

var htmlSources = Directory.GetFiles("./html", "*.html");
var renderer    = new ChromePdfRenderer();                 // reuse 1 instance

Parallel.ForEach(htmlSources, new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount }, file =>
{
    string html = File.ReadAllText(file);
    using PdfDocument pdf = renderer.RenderHtmlAsPdf(html);
    pdf.SaveAs(Path.ChangeExtension(file, ".pdf"));
});
' BatchRender.cs — Thread-safe on .NET 8+
Imports IronPdf
Imports System.Threading.Tasks

Private htmlSources = Directory.GetFiles("./html", "*.html")
Private renderer = New ChromePdfRenderer() ' reuse 1 instance

Parallel.ForEach(htmlSources, New ParallelOptions With {.MaxDegreeOfParallelism = Environment.ProcessorCount}, Sub(file)
	Dim html As String = File.ReadAllText(file)
	Using pdf As PdfDocument = renderer.RenderHtmlAsPdf(html)
		pdf.SaveAs(Path.ChangeExtension(file, ".pdf"))
	End Using
End Sub)
$vbLabelText   $csharpLabel

2. Reduzir o custo de inicialização do Headless Chrome

O IronPDF inclui sua própria versão do Chromium, mas cada renderização acarreta uma pequena taxa de inicialização. O agrupamento de recursos ajuda, e os contêineres Linux devem incluir duas bibliotecas nativas:

RUN apt-get update && \
    apt-get install -y --no-install-recommends libnss3 libatk1.0-0

A ausência de qualquer uma das bibliotecas se manifesta como um erro libnss3.so not found nos logs do Docker.

As flags recomendadas para o Chrome (aplicadas automaticamente pelo IronPDF) incluem --disable-gpu e --no-sandbox para reduzir problemas de memória e de acesso do usuário root em contêineres.

3. Aguarde o JavaScript atrasado com RenderDelay ou WaitFor

Páginas que exibem contadores animados ou buscam dados após DOMContentLoaded podem precisar de um pequeno atraso:

renderer.RenderingOptions.RenderDelay = 200;        // ms
// OR: renderer.RenderingOptions.JavaScript = "WaitFor('window.doneLoading')";
renderer.RenderingOptions.RenderDelay = 200;        // ms
// OR: renderer.RenderingOptions.JavaScript = "WaitFor('window.doneLoading')";
renderer.RenderingOptions.RenderDelay = 200 ' ms
' OR: renderer.RenderingOptions.JavaScript = "WaitFor('window.doneLoading')";
$vbLabelText   $csharpLabel

Consulte o tutorial dedicado ao WaitFor para obter informações sobre promessas personalizadas e sondagem do DOM.

4. Ative o registro de depuração para uma solicitação.

renderer.LoggingOptions.DebugMode        = true;
renderer.LoggingOptions.LogsToConsole    = true;
renderer.LoggingOptions.LogFilePath      = "./logs/ironpdf-debug.log";
renderer.LoggingOptions.DebugMode        = true;
renderer.LoggingOptions.LogsToConsole    = true;
renderer.LoggingOptions.LogFilePath      = "./logs/ironpdf-debug.log";
renderer.LoggingOptions.DebugMode = True
renderer.LoggingOptions.LogsToConsole = True
renderer.LoggingOptions.LogFilePath = "./logs/ironpdf-debug.log"
$vbLabelText   $csharpLabel

O recurso Live DevTools permite rastrear fontes ausentes, imagens com erro 404 e eventos de temporização sem a necessidade de recompilar o código.

5. Reutilize PDFs de modelos em vez de renderizá-los novamente.

Para a emissão de faturas, crie um modelo de PDF com marcadores de posição como [[name]] e substitua o texto em vez de reconstruir o HTML complexo. É 10 vezes mais rápido e consome pouca memória.

Lista de verificação para ajuste rápido

Parallel.ForEach , async/await , reutilizar um único ChromePdfRenderer

Use aspnet:8.0-jammy ; instale libnss3 + libatk1.0-0 ; flags --no-sandbox , --disable-gpu

RenderDelay , WaitFor() , registrar a linha do tempo do DevTools para hidratações lentas de SPA

Leitura complementar

Onde posso baixar uma versão de avaliação gratuita, escolher uma licença e encontrar suporte especializado? {#anchor-10-resources}

Uma chave de avaliação de 30 dias é emitida instantaneamente através do formulário Iniciar Avaliação Gratuita e desbloqueia todos os recursos — incluindo conversão de HTML para PDF, assinaturas digitais e criptografia — sem marca d'água.

Após avaliar a biblioteca, escolha uma licença perpétua para desenvolvedores , para implantação ou corporativa ; Cada plano inclui atualizações menores gratuitas, direitos de uso para desenvolvimento/teste/produção e uma garantia de reembolso de 30 dias. Aplicar a chave requer apenas uma linha de código (IronPdf.License.LicenseKey = "YOUR-KEY";) e pode ser automatizado em pipelines de CI/CD.

A documentação completa — incluindo guias de início rápido , referência da API e vídeos tutoriais — está disponível no portal de documentação e é atualizada a cada nova versão do .NET .

Questões técnicas recebem respostas em um dia útil via chat ao vivo , e-mail ou telefone da equipe de suporte sediada em Chicago.

As perguntas frequentes sobre otimização de desempenho e implementação estão reunidas no Centro de Assistência de Desempenho.

Recurso URL Por que isso importa
Obtenha uma chave de avaliação de 30 dias https://ironpdf.com/demos/ Desbloqueia todas as funcionalidades sem marcas d'água.
Licenciamento e preços https://ironpdf.com/licensing/ Planos perpétuos ou por assinatura; O Iron Suite inclui 10 bibliotecas.
Referência da API https://ironpdf.com/object-reference/api/ Documentação completa da classe, por exemplo ChromePdfRenderer
Portal de documentos https://ironpdf.com/docs/ Guias, tutoriais, projetos de exemplo
Assistência de desempenho https://ironpdf.com/troubleshooting/ironpdf-performance-assistance/ Dicas de otimização e escalonamento
Contate o suporte https://ironsoftware.com/contact-us/ Suporte por chat ao vivo, e-mail e telefone.

Próximos passos

  1. Clone o repositório de exemplo que demonstra todos os principais recursos — desde a renderização de visualização MVC até a criptografia AES-256.
  2. Insira a chave de avaliação em uma solução existente e execute os testes unitários para validar a compatibilidade entre plataformas.
  3. Agende uma demonstração ao vivo com a equipe de engenharia para obter recomendações específicas para o seu projeto.

Com esses recursos em mãos, qualquer equipe .NET pode enviar PDFs perfeitos em nível de pixel para produção — localmente, em Docker ou sem servidor — em um único sprint.

Perguntas frequentes

Como posso converter HTML para PDF no .NET Core?

Você pode converter HTML para PDF no .NET Core usando a biblioteca IronPDF. Primeiro, instale o pacote NuGet IronPDF e, em seguida, crie uma instância ChromePdfRenderer . Use o método RenderHtmlAsPdf para converter strings HTML em PDFs.

Como faço para converter um URL de um site em um documento PDF?

Para converter um URL de um site em um documento PDF, instale o pacote NuGet IronPDF, crie uma instância ChromePdfRenderer e use o método RenderUrlAsPdf para renderizar o URL em um PDF. O resultado pode ser salvo usando o método SaveAs .

Qual a melhor maneira de converter views do Razor em PDFs?

A melhor maneira de converter views Razor em PDFs é usando o IronPDF. Primeiro, renderize a view Razor em uma string HTML e, em seguida, passe essa string para o método RenderHtmlAsPdf para criar um documento PDF.

Como posso aumentar a segurança dos meus documentos PDF?

Aprimore a segurança de PDFs usando o IronPDF aplicando criptografia AES-256, definindo senhas e controlando as permissões de usuário. Configure essas opções por meio da propriedade SecuritySettings para restringir ações como impressão e edição.

Quais opções estão disponíveis para personalizar a renderização de PDFs?

O IronPDF oferece diversas opções de renderização por meio da classe ChromePdfRenderOptions , incluindo a configuração do tamanho do papel, orientação, margens e a aplicação de tipos de mídia CSS. Você também pode adicionar cabeçalhos, rodapés e marcas d'água para personalizar a saída do documento.

Como faço para implantar um aplicativo de geração de PDF em um contêiner Docker?

Para implantar um aplicativo de geração de PDF em um contêiner Docker, configure as dependências do Linux no seu Dockerfile e defina as permissões de usuário. Utilize IronPdf.Installation.LinuxAndDockerDependenciesAutoConfig para gerenciamento automático de dependências.

Como posso adicionar marcas d'água a um PDF usando C#?

Você pode adicionar marcas d'água a PDFs usando o IronPDF, utilizando a propriedade Watermark com objetos HtmlStamp . Para opções avançadas, a classe HtmlStamper permite posicionamento personalizado e efeitos de transparência.

Posso adicionar assinaturas digitais a documentos PDF?

Sim, você pode adicionar assinaturas digitais a PDFs usando a classe PdfSignature do IronPDF. Utilize o método Sign em um PdfDocument e forneça um arquivo de certificado para garantir a integridade e autenticidade do documento.

Como posso otimizar o desempenho da geração de PDFs no .NET Core?

Otimize o desempenho da geração de PDFs reutilizando uma instância thread-safe ChromePdfRenderer , habilitando multithreading e removendo flags de inicialização desnecessárias do Chrome em modo headless. Essas práticas ajudam a melhorar a eficiência do seu aplicativo.

O exemplo de conversão de HTML para PDF em .NET Core apresentado neste tutorial também funciona com o .NET 10?

Sim. O IronPDF é totalmente compatível com o .NET 10, então você pode usar o exemplo de HTML para PDF do ChromePdfRenderer deste tutorial em projetos .NET 10 sem alterar o código principal. A principal diferença é que você deve usar o .NET 10 como alvo ao criar o projeto e, em seguida, instalar o pacote IronPDF mais recente do NuGet para gerar PDFs perfeitos em pixels a partir de HTML, views Razor ou URLs.

Jacob Mellor, Diretor de Tecnologia da Team Iron
Jacob Mellor
  Converse agora mesmo com a equipe de engenharia.
Diretor de Tecnologia

Jacob Mellor é Diretor de Tecnologia da Iron Software e um engenheiro visionário pioneiro na tecnologia C# PDF. Como desenvolvedor original do código-fonte principal da Iron Software, ele moldou a arquitetura de produtos da empresa desde sua criação, transformando-a, juntamente com o CEO Cameron Rimington, em uma ...

Leia mais
Analisado por
Jeff Fritz
Jeffrey T. Fritz
Gerente de Programa Principal - Equipe da Comunidade .NET
Jeff também é Gerente de Programa Principal das equipes do .NET e do Visual Studio. Ele é o produtor executivo da série de conferências virtuais .NET Conf e apresenta o "Fritz and Friends", uma transmissão ao vivo para desenvolvedores que vai ao ar duas vezes por semana, onde ele conversa sobre tecnologia e escreve código junto com os espectadores. Jeff cria workshops, apresentações e planeja conteúdo para os maiores eventos de desenvolvedores da Microsoft, incluindo o Microsoft Build, o Microsoft Ignite, a .NET Conf e o Microsoft MVP Summit.
Pronto para começar?
Nuget Downloads 19,014,616 | Versão: 2026.5 just released
Still Scrolling Icon

Ainda está rolando a tela?

Quer provas rápidas? PM > Install-Package IronPdf
executar um exemplo Veja seu HTML se transformar em um PDF.