Ir para o conteúdo do rodapé
USANDO O IRONPDF

Converter HTML para PDF em ASP.NET Core com C# -- Guia IronPDF

O IronPDF converte HTML em PDF em ASP.NET usando um mecanismo de renderização baseado no Chrome que transforma suas strings HTML, arquivos ou URLs em documentos PDF perfeitos em pixels com apenas algumas linhas de código C#.

Quando sua aplicação ASP.NET precisa gerar faturas, relatórios ou documentos de conformidade sob demanda, a qualidade do PDF gerado é fundamental. Os usuários finais esperam uma saída formatada que seja exatamente igual ao HTML original — incluindo seus estilos CSS, fontes personalizadas e layouts de tabela. O desafio é encontrar uma biblioteca que lide com essa conversão sem exigir soluções alternativas complexas para conteúdo moderno com uso intensivo de CSS ou JavaScript.

IronPDF é uma biblioteca PDF em C# criada para esse desafio. Seu mecanismo de renderização baseado no Chrome processa o HTML da mesma forma que um navegador real, o que significa que suas propriedades CSS3, consultas de mídia e conteúdo renderizado em JavaScript aparecem corretamente no documento final. As seções abaixo abordam a instalação, os três métodos principais de renderização, o tratamento de dados de formulário, os recursos avançados de formatação e o suporte à autenticação — tudo o que você precisa para integrar a geração de PDFs prontos para produção em seu aplicativo ASP.NET Core .

Como converter HTML para PDF rapidamente em ASP.NET Core?

Para começar a converter HTML para PDF em ASP.NET Core , bastam algumas linhas de código. Primeiro, instale o IronPDF através do gerenciador de pacotes NuGet :

Install-Package IronPdf

Uma vez instalado, a classe ChromePdfRenderer é o ponto de entrada principal para todas as operações de renderização. Aqui está um exemplo completo mostrando como converter uma string HTML em um PDF para download dentro de um controlador ASP.NET Core MVC:

  1. Instale IronPDF com o Gerenciador de Pacotes NuGet

    PM > Install-Package IronPdf
  2. Copie e execute este trecho de código.

    using IronPdf;
    using Microsoft.AspNetCore.Mvc;
    
    // program.cs
    var builder = WebApplication.CreateBuilder(args);
    builder.Services.AddControllersWithViews();
    var app = builder.Build();
    app.MapControllerRoute(
        name: "default",
        pattern: "{controller=Home}/{action=Index}/{id?}");
    app.Run();
    
    // PdfController.cs
    public class PdfController : Controller
    {
        public IActionResult GeneratePdf()
        {
            var renderer = new ChromePdfRenderer();
            string html = @"
                <h1>Invoice #2024-001</h1>
                <p>Generated on: " + DateTime.Now.ToString("yyyy-MM-dd") + @"</p>
                <table>
                    <tr><th>Item</th><th>Price</th></tr>
                    <tr><td>Professional License</td><td>$799</td></tr>
                </table>";
            var pdf = renderer.RenderHtmlAsPdf(html);
            return File(pdf.BinaryData, "application/pdf", "invoice.pdf");
        }
    }
  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

Qual é a aparência do PDF gerado?

PDF viewer displaying a simple invoice document with number #2024-001, showing an invoice header, generation date, and a table with Item and Price columns containing a Professional License entry for $799

A classe ChromePdfRenderer lida com toda a renderização complexa, garantindo que sua estrutura HTML, estilos CSS e até mesmo JavaScript sejam renderizados corretamente na saída PDF final. O valor de retorno é um objeto PdfDocument cuja propriedade BinaryData você pode transmitir diretamente para o navegador como um download de arquivo.

Como escolher o método de renderização correto para sua fonte?

O IronPDF oferece três métodos principais de renderização, cada um projetado para uma fonte de conteúdo específica. Entender qual método se adequa ao seu cenário evita complexidade desnecessária e mantém o código do seu controlador limpo.

Métodos de renderização do IronPDF por fonte de conteúdo
Tipo de fonte Método Ideal para
String HTML na memória `RenderHtmlAsPdf` Relatórios baseados em banco de dados, faturas padronizadas, conteúdo dinâmico
Arquivo HTML no disco `RenderHtmlFileAsPdf` Modelos estáticos em wwwroot, layouts fornecidos pela agência de design.
URL da web ativa `RenderUrlAsPdf` Arquivamento de páginas, captura de SPAs após a renderização do JavaScript

Como converter strings HTML dinâmicas?

Ao trabalhar com conteúdo dinâmico, como relatórios baseados em banco de dados, use RenderHtmlAsPdf para converter strings HTML diretamente. Este método aceita qualquer marcação HTML válida e retorna um PDF totalmente renderizado:

var renderer = new ChromePdfRenderer();
string htmlContent = BuildDynamicHtml(); // your method to generate HTML
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.SaveAs("dynamic-report.pdf");
var renderer = new ChromePdfRenderer();
string htmlContent = BuildDynamicHtml(); // your method to generate HTML
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.SaveAs("dynamic-report.pdf");
Dim renderer As New ChromePdfRenderer()
Dim htmlContent As String = BuildDynamicHtml() ' your method to generate HTML
Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
pdf.SaveAs("dynamic-report.pdf")
$vbLabelText   $csharpLabel

Relatório de teste do IronPDF exibindo conteúdo HTML renderizado com estilização CSS, incluindo um cabeçalho azul com o texto 'Relatório de Teste do IronPDF', texto de parágrafo estilizado em verde e uma tabela de dados formatada contendo informações de produtos com itens como widgets e ferramentas

Essa abordagem funciona bem para gerar documentos PDF a partir de modelos HTML preenchidos com dados em tempo real, envios de formulários ou qualquer conteúdo gerado dinamicamente. O mecanismo de renderização preserva todo o estilo CSS, incluindo fontes personalizadas, cores e formatação de tabelas. Quando seu HTML faz referência a folhas de estilo ou imagens externas usando caminhos relativos, passe um baseUrl como o segundo argumento para que o renderizador possa resolver esses ativos corretamente.

Como converter arquivos HTML estáticos do disco?

Para modelos HTML armazenados como arquivos físicos, use RenderHtmlFileAsPdf para convertê-los sem carregá-los na memória primeiro. Isso é eficiente para modelos grandes e evita concatenação de strings:

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlFileAsPdf("wwwroot/templates/report-template.html");
pdf.SaveAs("report.pdf");
var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlFileAsPdf("wwwroot/templates/report-template.html");
pdf.SaveAs("report.pdf");
Dim renderer As New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlFileAsPdf("wwwroot/templates/report-template.html")
pdf.SaveAs("report.pdf")
$vbLabelText   $csharpLabel

Este método resolve automaticamente os caminhos relativos para folhas de estilo CSS, imagens e outros recursos externos referenciados no arquivo. Ele funciona bem quando sua equipe de design mantém arquivos de modelo HTML separados, fora da base de código C# do aplicativo. O método suporta consultas de mídia CSS para impressão e fontes personalizadas , de modo que os modelos criados para ambientes de impressão sejam renderizados fielmente sem configuração adicional.

Como converter um URL de página da web em PDF?

Para capturar uma página web ao vivo ou renderizar uma página acessível por URL como PDF, use RenderUrlAsPdf. Este método inicia o mecanismo do Chrome, navega até o URL, aguarda o carregamento completo da página e, em seguida, captura a saída renderizada:

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor.RenderDelay(1000);
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Screen;
var pdf = renderer.RenderUrlAsPdf("https://en.wikipedia.org/wiki/PDF");
pdf.SaveAs("webpage.pdf");
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor.RenderDelay(1000);
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Screen;
var pdf = renderer.RenderUrlAsPdf("https://en.wikipedia.org/wiki/PDF");
pdf.SaveAs("webpage.pdf");
Dim renderer = New ChromePdfRenderer()
renderer.RenderingOptions.EnableJavaScript = True
renderer.RenderingOptions.WaitFor.RenderDelay(1000)
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Screen
Dim pdf = renderer.RenderUrlAsPdf("https://en.wikipedia.org/wiki/PDF")
pdf.SaveAs("webpage.pdf")
$vbLabelText   $csharpLabel

Página principal da Wikipedia exibida em um visualizador de PDF mostrando o layout completo da página web com navegação, seções de conteúdo, visualização do artigo em destaque e logotipo da Wikipedia, demonstrando a conversão HTML para PDF bem-sucedida com formatação e imagens preservadas

A opção WaitFor.RenderDelay diz ao renderizador para pausar após o carregamento da página antes de capturar. Isso é valioso para aplicativos de página única que constroem seu DOM por meio de JavaScript após a chegada da resposta HTML inicial. Definir EnableJavaScript = true ativa o mecanismo completo do JavaScript do Chrome, para que gráficos, grades de dados e outros componentes renderizados em JavaScript apareçam no PDF exatamente como aparecem em um navegador.

Como você lida com dados de formulário e solicitações POST?

O processamento de dados de formulários antes da geração de PDFs é um padrão comum em aplicações ASP.NET — confirmações de pedidos, comprovantes de entrega e recibos seguem esse modelo. A abordagem consiste em vincular os dados do formulário enviados a um modelo, construir uma string HTML a partir desse modelo e, em seguida, renderizar a string como um PDF:

[HttpPost]
public IActionResult ProcessFormToPdf(OrderModel model)
{
    var renderer = new ChromePdfRenderer();
    string html = $@"
        <h2>Order Confirmation</h2>
        <p>Customer: {model.CustomerName}</p>
        <p>Order Date: {model.OrderDate:yyyy-MM-dd}</p>
        <ul>
            {string.Join("", model.Items.Select(i => $"<li>{i.Name} -- ${i.Price}</li>"))}
        </ul>
        <p><strong>Total: ${model.Total}</strong></p>";
    var pdf = renderer.RenderHtmlAsPdf(html);
    string fileName = $"order-{model.OrderId}.pdf";
    return File(pdf.BinaryData, "application/pdf", fileName);
}
[HttpPost]
public IActionResult ProcessFormToPdf(OrderModel model)
{
    var renderer = new ChromePdfRenderer();
    string html = $@"
        <h2>Order Confirmation</h2>
        <p>Customer: {model.CustomerName}</p>
        <p>Order Date: {model.OrderDate:yyyy-MM-dd}</p>
        <ul>
            {string.Join("", model.Items.Select(i => $"<li>{i.Name} -- ${i.Price}</li>"))}
        </ul>
        <p><strong>Total: ${model.Total}</strong></p>";
    var pdf = renderer.RenderHtmlAsPdf(html);
    string fileName = $"order-{model.OrderId}.pdf";
    return File(pdf.BinaryData, "application/pdf", fileName);
}
Imports System
Imports System.Linq
Imports Microsoft.AspNetCore.Mvc

<HttpPost>
Public Function ProcessFormToPdf(model As OrderModel) As IActionResult
    Dim renderer = New ChromePdfRenderer()
    Dim html As String = $"
        <h2>Order Confirmation</h2>
        <p>Customer: {model.CustomerName}</p>
        <p>Order Date: {model.OrderDate:yyyy-MM-dd}</p>
        <ul>
            {String.Join("", model.Items.Select(Function(i) $"<li>{i.Name} -- ${i.Price}</li>"))}
        </ul>
        <p><strong>Total: ${model.Total}</strong></p>"
    Dim pdf = renderer.RenderHtmlAsPdf(html)
    Dim fileName As String = $"order-{model.OrderId}.pdf"
    Return File(pdf.BinaryData, "application/pdf", fileName)
End Function
$vbLabelText   $csharpLabel

Qual é a aparência da interface do formulário?

Interface de formulário web mostrando uma página de criação de pedido com seção de detalhes do cliente contendo campo de nome 'Jane Doe' e data '19/11/2025', seção de itens do pedido exibindo 'Laptop' com preço '1300', resumo do pedido mostrando total e um botão azul 'Gerar PDF'

Como os dados do formulário aparecem no PDF gerado?

PDF viewer showing a clean order confirmation document with header 'Order Confirmation', customer name 'Jane Doe', order date '2025-11-19', itemized list showing laptop purchase for $1300, demonstrating successful form-to-PDF conversion

Para cenários de documentos mais complexos, você pode integrar formulários PDF ou editar modelos PDF existentes com campos pré-preenchidos. A biblioteca também oferece suporte a assinaturas digitais para documentos e contratos legais, permitindo adicionar assinaturas criptograficamente verificáveis ​​a qualquer documento gerado.

Um aspecto importante a considerar ao incorporar dados do usuário em strings HTML é a higienização. Sempre utilize caracteres de escape para strings fornecidas pelo usuário antes de inseri-las no HTML para evitar problemas de injeção de código. Uma chamada simples System.Web.HttpUtility.HtmlEncode(model.CustomerName) em cada campo mantém o modelo seguro antes de passá-lo para o renderizador.

Como adicionar formatação profissional, cabeçalhos e marcas d'água?

Como configurar cabeçalhos, rodapés e marcas d'água?

Documentos PDF profissionais geralmente exigem cabeçalhos e rodapés em todas as páginas, além de marcas d'água para documentos rascunho ou confidenciais. IronPDF lida com ambos através de propriedades no objeto RenderingOptions e o método ApplyWatermark no resultante PdfDocument:

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
    MaxHeight = 25,
    HtmlFragment = "<div style='text-align:center'>Annual Report 2024</div>"
};
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
    MaxHeight = 20,
    HtmlFragment = "<div style='text-align:center'>Page {page} of {total-pages}</div>"
};
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.ApplyWatermark("<h2 style='color:red;opacity:0.3'>CONFIDENTIAL</h2>",
    30, VerticalAlignment.Middle, HorizontalAlignment.Center);
pdf.SaveAs("report-with-watermark.pdf");
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter
{
    MaxHeight = 25,
    HtmlFragment = "<div style='text-align:center'>Annual Report 2024</div>"
};
renderer.RenderingOptions.HtmlFooter = new HtmlHeaderFooter
{
    MaxHeight = 20,
    HtmlFragment = "<div style='text-align:center'>Page {page} of {total-pages}</div>"
};
var pdf = renderer.RenderHtmlAsPdf(htmlContent);
pdf.ApplyWatermark("<h2 style='color:red;opacity:0.3'>CONFIDENTIAL</h2>",
    30, VerticalAlignment.Middle, HorizontalAlignment.Center);
pdf.SaveAs("report-with-watermark.pdf");
Imports IronPdf

Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.HtmlHeader = New HtmlHeaderFooter With {
    .MaxHeight = 25,
    .HtmlFragment = "<div style='text-align:center'>Annual Report 2024</div>"
}
renderer.RenderingOptions.HtmlFooter = New HtmlHeaderFooter With {
    .MaxHeight = 20,
    .HtmlFragment = "<div style='text-align:center'>Page {page} of {total-pages}</div>"
}
Dim pdf = renderer.RenderHtmlAsPdf(htmlContent)
pdf.ApplyWatermark("<h2 style='color:red;opacity:0.3'>CONFIDENTIAL</h2>", 30, VerticalAlignment.Middle, HorizontalAlignment.Center)
pdf.SaveAs("report-with-watermark.pdf")
$vbLabelText   $csharpLabel

Relatório de teste do IronPDF mostrando um documento PDF com cabeçalho azul personalizado 'Relatório de Teste do IronPDF', formatação de texto em linha verde, uma tabela de dados com informações de produtos e uma marca d'água vermelha 'CONFIDENCIAL' posicionada diagonalmente na página

Os espaços reservados {page} e {total-pages} no HTML do rodapé são automaticamente substituídos no momento da renderização, para que você obtenha números de página corretos sem qualquer pós-processamento. Você também pode adicionar números de página , imagens de fundo ou sobreposições em primeiro plano , e carimbos de texto ou imagem personalizados .

Como usar o CSS Print Media para controlar o layout de PDFs?

Para garantir que sua saída em PDF corresponda às expectativas, use regras de CSS @media print e a configuração PdfCssMediaType.Print. O IronPDF oferece suporte completo ao controle de quebras de página e tamanhos de papel personalizados :

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
renderer.RenderingOptions.ViewPortWidth = 1024;
renderer.RenderingOptions.MarginTop = 10;
renderer.RenderingOptions.MarginBottom = 10;
renderer.RenderingOptions.MarginLeft = 10;
renderer.RenderingOptions.MarginRight = 10;
string html = @"
    <style>
        @media print {
            .no-print { display: none; }
            body { font-size: 12pt; }
            .page-break { page-break-after: always; }
        }
        @page {
            size: A4;
            margin: 1cm;
        }
    </style>
    <div class='content'>
        <h1>Professional Report</h1>
        <div class='page-break'></div>
        <h2>Section 2</h2>
    </div>";
var pdf = renderer.RenderHtmlAsPdf(html);
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
renderer.RenderingOptions.ViewPortWidth = 1024;
renderer.RenderingOptions.MarginTop = 10;
renderer.RenderingOptions.MarginBottom = 10;
renderer.RenderingOptions.MarginLeft = 10;
renderer.RenderingOptions.MarginRight = 10;
string html = @"
    <style>
        @media print {
            .no-print { display: none; }
            body { font-size: 12pt; }
            .page-break { page-break-after: always; }
        }
        @page {
            size: A4;
            margin: 1cm;
        }
    </style>
    <div class='content'>
        <h1>Professional Report</h1>
        <div class='page-break'></div>
        <h2>Section 2</h2>
    </div>";
var pdf = renderer.RenderHtmlAsPdf(html);
Imports IronPdf

Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print
renderer.RenderingOptions.ViewPortWidth = 1024
renderer.RenderingOptions.MarginTop = 10
renderer.RenderingOptions.MarginBottom = 10
renderer.RenderingOptions.MarginLeft = 10
renderer.RenderingOptions.MarginRight = 10

Dim html As String = "
    <style>
        @media print {
            .no-print { display: none; }
            body { font-size: 12pt; }
            .page-break { page-break-after: always; }
        }
        @page {
            size: A4;
            margin: 1cm;
        }
    </style>
    <div class='content'>
        <h1>Professional Report</h1>
        <div class='page-break'></div>
        <h2>Section 2</h2>
    </div>"

Dim pdf = renderer.RenderHtmlAsPdf(html)
$vbLabelText   $csharpLabel

Visualizador de documentos PDF exibindo um relatório profissional de duas páginas a 76% de zoom, com título 'Relatório Profissional' na página 1 e cabeçalho 'Seção 2' na página 2, mostrando layout limpo com quebras de página adequadas e formatação CSS aplicada

O uso de CSS para impressão garante que seus documentos PDF mantenham a formatação profissional, ocultando elementos desnecessários da web, como menus de navegação ou botões interativos. Definindo CssMediaType = PdfCssMediaType.Print informa ao renderizador para aplicar suas regras @media print em vez dos estilos de tela, o que normalmente remove decorações de plano de fundo e ajusta a tipografia para saída de impressão. Você também pode configurar margens personalizadas por página e controlar a orientação e rotação da página para relatórios em formato amplo ou rotacionados.

A especificação W3C CSS Paged Media define como propriedades como @page, page-break-before e widows devem se comportar na saída em páginas. O mecanismo Chrome do IronPDF segue essa especificação de perto, portanto, os estilos escritos de acordo com o padrão CSS são traduzidos com precisão para o PDF sem ajustes manuais.

Como você lida com a autenticação para páginas protegidas?

Para aplicações seguras, o IronPDF suporta vários métodos de autenticação, incluindo cookies , cabeçalhos de requisição HTTP e credenciais de rede . Isso permite renderizar páginas que exigem uma sessão com sessão iniciada ou autenticação básica:

var renderer = new ChromePdfRenderer();
renderer.RequestContext.Cookies.Add(new Cookie
{
    Name = "SessionId",
    Value = "your-session-token",
    Domain = "example.com"
});
renderer.ChromePdfRenderOptions.HttpLoginCredentials = new HttpLoginCredentials
{
    Username = "user",
    Password = "password"
};
var pdf = renderer.RenderUrlAsPdf("https://app.example.com/protected/report");
var renderer = new ChromePdfRenderer();
renderer.RequestContext.Cookies.Add(new Cookie
{
    Name = "SessionId",
    Value = "your-session-token",
    Domain = "example.com"
});
renderer.ChromePdfRenderOptions.HttpLoginCredentials = new HttpLoginCredentials
{
    Username = "user",
    Password = "password"
};
var pdf = renderer.RenderUrlAsPdf("https://app.example.com/protected/report");
Dim renderer = New ChromePdfRenderer()
renderer.RequestContext.Cookies.Add(New Cookie With {
    .Name = "SessionId",
    .Value = "your-session-token",
    .Domain = "example.com"
})
renderer.ChromePdfRenderOptions.HttpLoginCredentials = New HttpLoginCredentials With {
    .Username = "user",
    .Password = "password"
}
Dim pdf = renderer.RenderUrlAsPdf("https://app.example.com/protected/report")
$vbLabelText   $csharpLabel

Você também pode criptografar o PDF resultante com uma senha de proprietário e uma senha de usuário, restringindo ações como impressão, cópia ou edição. A combinação da renderização baseada em autenticação com permissões em nível de PDF permite controlar quem pode gerar um documento e o que os destinatários podem fazer com ele depois de recebê-lo.

Para ambientes corporativos, considere usar a API de renderização assíncrona ao gerar PDFs dentro de manipuladores de requisições web. A renderização assíncrona mantém o pool de threads do ASP.NET livre enquanto o mecanismo do Chrome processa o documento, o que melhora o desempenho sob carga simultânea. A biblioteca também oferece suporte à renderização multithread para cenários de geração de documentos em lote.

Por que o mecanismo de renderização do Chrome é importante para a conversão de HTML para PDF?

A maioria das bibliotecas de geração de PDF funciona analisando o HTML por conta própria, usando um mecanismo personalizado. Isso significa que elas suportam apenas um subconjunto de propriedades CSS, não executam JavaScript e têm dificuldades com técnicas modernas de layout, como CSS Grid ou Flexbox. O IronPDF adota uma abordagem diferente, incorporando o mecanismo do Chrome — a mesma tecnologia que alimenta o navegador Google Chrome.

Na prática, o resultado é que qualquer página HTML que seja exibida corretamente no Chrome será renderizada corretamente como um PDF através do IronPDF. Isso elimina uma classe comum de erros em que a saída em PDF diverge da aparência esperada porque o mecanismo de renderização interpreta o CSS de forma diferente do navegador usado pelo desenvolvedor durante o projeto.

A documentação da MDN Web Docs sobre CSS Paged Media e a documentação do ASP.NET Core da Microsoft descrevem recursos que o IronPDF suporta por meio de sua base no Chrome. Os desenvolvedores que já estão familiarizados com HTML, CSS e JavaScript padrão podem aplicar esse conhecimento diretamente à geração de PDFs sem precisar aprender uma linguagem de formatação de documentos separada.

As opções de renderização do IronPDF expõem controles para tamanho do papel, margens, execução de JavaScript e atrasos de renderização. A biblioteca é compatível com texto UTF-8 e conjuntos de caracteres internacionais, fontes da web referenciadas via Google Fonts ou arquivos locais, e pode até converter documentos Markdown para PDF . Para atender aos requisitos de arquivamento ou conformidade com a acessibilidade, ele suporta os formatos de saída PDF/A e PDF/UA . A biblioteca funciona em Windows, Linux e macOS e pode ser implantada no Azure e na AWS sem configuração adicional.

Quais são os seus próximos passos?

Converter HTML para PDF em ASP.NET C# com IronPDF oferece à sua aplicação um pipeline de geração de documentos confiável e compatível com navegadores. Os três métodos de renderização — string HTML, arquivo HTML e URL — abrangem toda a gama de fontes de conteúdo que você encontrará na prática. Recursos avançados como cabeçalhos, rodapés, marcas d'água e CSS para impressão permitem produzir resultados profissionais sem a necessidade de pós-processamento manual do PDF.

O próximo passo é instalar o pacote NuGet e executar o exemplo de início rápido da primeira seção deste guia. A partir daí, explore o tutorial completo de PDF em C# para obter uma cobertura mais aprofundada da estrutura do documento ou consulte o guia de edição de PDF para aprender como mesclar, dividir, anotar e extrair conteúdo de PDFs existentes.

Se o seu projeto for direcionado ao Blazor, o tutorial em PDF do Blazor explica passo a passo a integração do lado do servidor e do WebAssembly. Para projetos MVC, o guia PDF para MVC Core e o guia de Páginas Razor abordam a renderização baseada em modelos com visualizações .cshtml. Para depuração e otimização de desempenho, o IronPDF oferece registro personalizado e orientações de desempenho que ajudam a identificar gargalos em fluxos de trabalho de geração de documentos de alto volume.

Comece um teste grátis para testar todos os recursos da biblioteca em seu próprio projeto antes de se comprometer com uma licença. Para implantações em produção, estão disponíveis opções de licenciamento para desenvolvedores individuais, equipes e cenários de redistribuição empresarial.

Perguntas frequentes

Como posso converter HTML para PDF em ASP.NET Core?

Instale o IronPDF via NuGet, crie uma instância de ChromePdfRenderer e chame RenderHtmlAsPdf com sua string HTML. O renderizador retorna um PdfDocument cujo BinaryData você pode transmitir para o navegador.

O que torna o IronPDF adequado para conversão de HTML em PDF?

O IronPDF incorpora o mecanismo de renderização do Chrome, então qualquer página HTML que exiba corretamente no Chrome renderiza corretamente como um PDF. Isso inclui CSS3, conteúdo renderizado em JavaScript, fontes web e layouts responsivos.

É possível gerar faturas e relatórios usando o IronPDF em ASP.NET?

Sim. Construa uma string HTML a partir do seu modelo de dados, passe-a para RenderHtmlAsPdf e retorne o BinaryData como um download de arquivo. O IronPDF preserva a formatação de tabelas, fontes personalizadas e estilização CSS na saída.

O IronPDF suporta consultas de mídia de impressão CSS?

Sim. Defina RenderingOptions.CssMediaType = PdfCssMediaType.Print para ativar regras @media print, que ocultam elementos de navegação e aplicam tipografia otimizada para impressão.

O IronPDF pode lidar com conteúdo renderizado em JavaScript?

Sim. Defina RenderingOptions.EnableJavaScript = true e use WaitFor.RenderDelay para pausar após o carregamento da página, dando tempo ao motor de JavaScript para construir o DOM antes da captura do PDF.

Como o IronPDF lida com a autenticação para páginas protegidas?

O IronPDF suporta cookies de sessão, cabeçalhos HTTP e credenciais básicas de autenticação através das propriedades RequestContext.Cookies e ChromePdfRenderOptions.HttpLoginCredentials.

Quais plataformas o IronPDF suporta?

O IronPDF roda no Windows, Linux e macOS e pode ser implantado no Azure e AWS. Ele é direcionado ao .NET 6, .NET 7, .NET 8 e .NET Framework 4.6.2 e superior.

O IronPDF suporta saída PDF/A para arquivamento?

Sim. O IronPDF suporta conformidade com PDF/A para arquivamento de longo prazo e PDF/UA para acessibilidade. Esses modos de saída podem ser configurados através dos métodos SaveAsPdfA e SaveAsPdfUA.

Curtis Chau
Redator Técnico

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

Leia mais

Equipe de suporte de ferro

Estamos online 24 horas por dia, 5 dias por semana.
Bater papo
E-mail
Liga para mim