Integrar um visualizador de PDF em uma aplicação ASP.NET Core é mais fácil do que a maioria dos desenvolvedores imagina. Ao gerar PDFs no servidor e retorná-los com o tipo MIME correto, você pode exibir documentos diretamente em qualquer navegador moderno — sem plugins, sem necessidade do Adobe Acrobat Reader. O IronPDF realiza a renderização por meio de seu mecanismo baseado no Chrome , transformando HTML, CSS e JavaScript em PDFs de alta fidelidade que aparecem diretamente no visualizador integrado do navegador.
Este tutorial aborda todos os principais cenários: exibição de PDFs gerados a partir de strings HTML, renderização de URLs em tempo real, conversão de views Razor , streaming de arquivos grandes e integração de tudo isso em um controlador ASP.NET Core MVC. Os exemplos de código são direcionados ao .NET 10 com instruções de nível superior quando aplicável.
Os navegadores modernos vêm com um visualizador de PDF integrado. Quando um servidor responde com o cabeçalho Content-Type: application/pdf, o navegador renderiza o documento embutido em vez de acionar um download de arquivo. A chave é emparelhar esse cabeçalho com Content-Disposition: inline.
No lado do servidor, seu trabalho é produzir um binário PDF válido e retorná-lo através de um FileResult. O navegador gerencia a paginação, o zoom, a seleção de texto, a pesquisa, a impressão e o download sem a necessidade de qualquer código adicional de interface do usuário da sua parte.
O IronPDF se encaixa nesse padrão naturalmente. Sua classe ChromePdfRenderer converte HTML (ou uma URL ativa) em um binário PDF, e você passa esse binário diretamente para o auxiliar File() do ASP.NET. O resultado é um visualizador de documentos completo que funciona no Chrome, Firefox, Edge e Safari.
Os navegadores modernos implementam a especificação de renderização de PDF da W3C por meio de seus mecanismos de visualização nativos, o que significa que qualquer PDF compatível retornado pelo seu servidor será exibido corretamente sem configuração adicional. A saída do IronPDF está em total conformidade com os padrões, para que você possa contar com uma renderização consistente em todas as versões do navegador.
Para implantações em contêineres, o IronPDF fornece imagens Docker oficiais que pré-configuram as dependências do Chromium, para que você não precise instalar o Chrome manualmente em cada nó. Contêineres Linux e Windows são suportados. Se você precisar dimensionar a geração de PDFs de forma independente, a imagem Docker do IronPDF Engine permite executar o processo de renderização como um microsserviço separado.
Abra seu projeto ASP.NET Core no Visual Studio e instale o IronPDF através do Console do Gerenciador de Pacotes NuGet :
Ou utilize a CLI do .NET :
Após a instalação, adicione sua chave de licença a Program.cs antes de chamar quaisquer APIs do IronPDF:
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"Se você estiver implantando no Azure , armazene a chave de licença no Azure Key Vault ou na Configuração do Aplicativo, em vez de codificá-la diretamente no código. Para implantações do AWS Lambda, use as variáveis de ambiente configuradas nas configurações da sua função Lambda.
Essa é toda a configuração. O IronPDF detecta e configura automaticamente o Chromium em tempo de execução no Windows. No Linux, consulte o guia de instalação do Linux para obter informações sobre os poucos pacotes de sistema necessários.
Você pode começar com um teste gratuito para avaliar o conjunto completo de recursos antes de escolher um nível de licença para produção.
A forma mais rápida de colocar um PDF na frente de um usuário é renderizar uma string HTML e retorná-la embutida. Crie um controlador chamado PdfController e adicione uma ação assim:
using IronPdf;
using Microsoft.AspNetCore.Mvc;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllersWithViews();
var app = builder.Build();
app.MapControllerRoute(name: "default", pattern: "{controller=Home}/{action=Index}/{id?}");
app.Run();
public class PdfController : Controller
{
private readonly ChromePdfRenderer _renderer;
public PdfController()
{
_renderer = new ChromePdfRenderer();
_renderer.RenderingOptions.WaitFor.RenderDelay(100);
_renderer.RenderingOptions.Timeout = 30;
}
public IActionResult DisplayFromHtml()
{
string html = @"
<html>
<head>
<style>
body { font-family: Arial, sans-serif; padding: 40px; }
h1 { color: #2c3e50; }
p { line-height: 1.7; color: #444; }
</style>
</head>
<body>
<h1>Sample PDF Document</h1>
<p>This PDF was generated using IronPDF in an ASP.NET Core application.</p>
</body>
</html>";
PdfDocument pdf = _renderer.RenderHtmlAsPdf(html);
Response.Headers.Append("Content-Disposition", "inline; filename=document.pdf");
return File(pdf.BinaryData, "application/pdf");
}
}Imports IronPdf
Imports Microsoft.AspNetCore.Mvc
Dim builder = WebApplication.CreateBuilder(args)
builder.Services.AddControllersWithViews()
Dim app = builder.Build()
app.MapControllerRoute(name:="default", pattern:="{controller=Home}/{action=Index}/{id?}")
app.Run()
Public Class PdfController
Inherits Controller
Private ReadOnly _renderer As ChromePdfRenderer
Public Sub New()
_renderer = New ChromePdfRenderer()
_renderer.RenderingOptions.WaitFor.RenderDelay(100)
_renderer.RenderingOptions.Timeout = 30
End Sub
Public Function DisplayFromHtml() As IActionResult
Dim html As String = "
<html>
<head>
<style>
body { font-family: Arial, sans-serif; padding: 40px; }
h1 { color: #2c3e50; }
p { line-height: 1.7; color: #444; }
</style>
</head>
<body>
<h1>Sample PDF Document</h1>
<p>This PDF was generated using IronPDF in an ASP.NET Core application.</p>
</body>
</html>"
Dim pdf As PdfDocument = _renderer.RenderHtmlAsPdf(html)
Response.Headers.Append("Content-Disposition", "inline; filename=document.pdf")
Return File(pdf.BinaryData, "application/pdf")
End Function
End Class
ChromePdfRenderer usa Chromium internamente, então grid CSS, flexbox, fontes web e recursos modernos de CSS são todos renderizados com precisão. Configurar Content-Disposition para inline é o que diz ao navegador para exibir o arquivo em vez de salvá-lo. Se você alterar esse valor para attachment, o navegador solicita ao usuário que faça o download.
Para documentos com layouts complexos, você pode ajustar a saída por meio de opções de renderização , como tamanhos de papel personalizados, margens e tipo de mídia CSS de impressão. A API WaitFor é especialmente útil em ambientes conteinerizados, onde a latência da rede pode atrasar o carregamento de recursos externos.
Para uma análise mais detalhada das opções de conversão de HTML, consulte o guia de conversão de string HTML para PDF .
O IronPDF consegue capturar qualquer página web em tempo real como um PDF — ideal para arquivar conteúdo da web ou gerar relatórios a partir de páginas existentes. A documentação do ASP.NET Core aborda como as ações do controlador retornam resultados, que é o padrão usado aqui.
public IActionResult RenderFromUrl(string url = "https://en.wikipedia.org/wiki/Main_Page")
{
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;
renderer.RenderingOptions.WaitFor.NetworkIdle();
PdfDocument pdf = renderer.RenderUrlAsPdf(url);
Response.Headers.Append("Content-Disposition", "inline; filename=webpage.pdf");
Response.Headers.Append("Cache-Control", "public, max-age=3600");
return File(pdf.BinaryData, "application/pdf");
}Public Function RenderFromUrl(Optional url As String = "https://en.wikipedia.org/wiki/Main_Page") As IActionResult
Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.EnableJavaScript = True
renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print
renderer.RenderingOptions.WaitFor.NetworkIdle()
Dim pdf As PdfDocument = renderer.RenderUrlAsPdf(url)
Response.Headers.Append("Content-Disposition", "inline; filename=webpage.pdf")
Response.Headers.Append("Cache-Control", "public, max-age=3600")
Return File(pdf.BinaryData, "application/pdf")
End Function
Quando você precisa converter uma visualização Razor -- como um modelo de fatura ou extrato -- primeiro você renderiza a visualização em uma string HTML e, em seguida, passa essa string para o IronPDF. Isso permite que seus modelos sejam reutilizados tanto na web quanto em PDFs:
public async Task<IActionResult> ViewToPdf()
{
var model = new InvoiceModel
{
InvoiceNumber = 1001,
InvoiceDate = DateTime.Now,
CustomerName = "Acme Corp.",
Items = new List<ItemModel>
{
new ItemModel { Description = "Product A", Quantity = 2, UnitPrice = 50.00m },
new ItemModel { Description = "Service B", Quantity = 1, UnitPrice = 150.00m }
}
};
model.TotalAmount = model.Items.Sum(i => i.LineTotal);
string htmlContent = await RenderViewToStringAsync("Invoice", model);
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.MarginTop = 40;
renderer.RenderingOptions.MarginBottom = 40;
string baseUrl = $"{HttpContext.Request.Scheme}://{HttpContext.Request.Host}";
PdfDocument pdf = renderer.RenderHtmlAsPdf(htmlContent, baseUrl);
return File(pdf.BinaryData, "application/pdf");
}
private async Task<string> RenderViewToStringAsync(string viewName, object model)
{
var actionContext = new ActionContext(
HttpContext, RouteData, ControllerContext.ActionDescriptor);
var viewEngine = HttpContext.RequestServices.GetRequiredService<IRazorViewEngine>();
var tempDataFactory = HttpContext.RequestServices.GetRequiredService<ITempDataDictionaryFactory>();
var tempData = tempDataFactory.GetTempData(HttpContext);
ViewData.Model = model;
var viewResult = viewEngine.FindView(actionContext, viewName, isMainPage: false);
if (!viewResult.Success)
{
string searched = string.Join(
Environment.NewLine,
viewResult.SearchedLocations ?? Array.Empty<string>());
throw new InvalidOperationException(
$"Could not find view '{viewName}'. Searched:{Environment.NewLine}{searched}");
}
await using var writer = new StringWriter();
var viewContext = new ViewContext(
actionContext, viewResult.View, ViewData, tempData,
writer, new HtmlHelperOptions());
await viewResult.View.RenderAsync(viewContext);
return writer.ToString();
}Imports System
Imports System.Collections.Generic
Imports System.Linq
Imports System.Threading.Tasks
Imports Microsoft.AspNetCore.Mvc
Imports Microsoft.AspNetCore.Mvc.ViewEngines
Imports Microsoft.AspNetCore.Mvc.Rendering
Imports Microsoft.AspNetCore.Mvc.ViewFeatures
Imports Microsoft.Extensions.DependencyInjection
Imports IronPdf
Public Class YourController
Inherits Controller
Public Async Function ViewToPdf() As Task(Of IActionResult)
Dim model As New InvoiceModel With {
.InvoiceNumber = 1001,
.InvoiceDate = DateTime.Now,
.CustomerName = "Acme Corp.",
.Items = New List(Of ItemModel) From {
New ItemModel With {.Description = "Product A", .Quantity = 2, .UnitPrice = 50.0D},
New ItemModel With {.Description = "Service B", .Quantity = 1, .UnitPrice = 150.0D}
}
}
model.TotalAmount = model.Items.Sum(Function(i) i.LineTotal)
Dim htmlContent As String = Await RenderViewToStringAsync("Invoice", model)
Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.MarginTop = 40
renderer.RenderingOptions.MarginBottom = 40
Dim baseUrl As String = $"{HttpContext.Request.Scheme}://{HttpContext.Request.Host}"
Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(htmlContent, baseUrl)
Return File(pdf.BinaryData, "application/pdf")
End Function
Private Async Function RenderViewToStringAsync(viewName As String, model As Object) As Task(Of String)
Dim actionContext As New ActionContext(HttpContext, RouteData, ControllerContext.ActionDescriptor)
Dim viewEngine As IRazorViewEngine = HttpContext.RequestServices.GetRequiredService(Of IRazorViewEngine)()
Dim tempDataFactory As ITempDataDictionaryFactory = HttpContext.RequestServices.GetRequiredService(Of ITempDataDictionaryFactory)()
Dim tempData As ITempDataDictionary = tempDataFactory.GetTempData(HttpContext)
ViewData.Model = model
Dim viewResult As ViewEngineResult = viewEngine.FindView(actionContext, viewName, isMainPage:=False)
If Not viewResult.Success Then
Dim searched As String = String.Join(Environment.NewLine, viewResult.SearchedLocations ?? Array.Empty(Of String)())
Throw New InvalidOperationException($"Could not find view '{viewName}'. Searched:{Environment.NewLine}{searched}")
End If
Await Using writer As New StringWriter()
Dim viewContext As New ViewContext(actionContext, viewResult.View, ViewData, tempData, writer, New HtmlHelperOptions())
Await viewResult.View.RenderAsync(viewContext)
Return writer.ToString()
End Using
End Function
End Class
Public Class InvoiceModel
Public Property InvoiceNumber As Integer
Public Property InvoiceDate As DateTime
Public Property CustomerName As String
Public Property Items As List(Of ItemModel)
Public Property TotalAmount As Decimal
End Class
Public Class ItemModel
Public Property Description As String
Public Property Quantity As Integer
Public Property UnitPrice As Decimal
Public ReadOnly Property LineTotal As Decimal
Get
Return Quantity * UnitPrice
End Get
End Property
End Class
O parâmetro baseUrl é importante quando sua visualização Razor referencia caminhos CSS ou de imagens relativos. Ao passar o URL do host atual, o IronPDF consegue resolver esses caminhos corretamente. Consulte o tutorial Razor to PDF para obter um passo a passo completo, incluindo padrões de aplicativos Blazor .
Para documentos que podem ter vários megabytes, o streaming reduz o pico de uso de memória e começa a entregar bytes ao cliente mais cedo. Use FileStreamResult em vez de File() com uma matriz de bytes bruta:
public async Task<IActionResult> StreamLargePdf()
{
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CreatePdfFormsFromHtml = false;
PdfDocument pdf = await renderer.RenderHtmlAsPdfAsync(
"<h1>Large Document</h1><p>Full content here...</p>");
pdf.CompressImages(80);
var stream = new MemoryStream(pdf.BinaryData);
Response.Headers.Append("Content-Length", pdf.BinaryData.Length.ToString());
Response.Headers.Append("Accept-Ranges", "bytes");
return new FileStreamResult(stream, "application/pdf");
}Imports System.IO
Imports System.Threading.Tasks
Imports Microsoft.AspNetCore.Mvc
Public Class YourController
Inherits Controller
Public Async Function StreamLargePdf() As Task(Of IActionResult)
Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.CreatePdfFormsFromHtml = False
Dim pdf As PdfDocument = Await renderer.RenderHtmlAsPdfAsync("<h1>Large Document</h1><p>Full content here...</p>")
pdf.CompressImages(80)
Dim stream As New MemoryStream(pdf.BinaryData)
Response.Headers.Append("Content-Length", pdf.BinaryData.Length.ToString())
Response.Headers.Append("Accept-Ranges", "bytes")
Return New FileStreamResult(stream, "application/pdf")
End Function
End ClassCompressImages(80) reduz a qualidade JPEG para 80%, o que reduz significativamente o tamanho do arquivo para documentos pesados em imagens com perda mínima de qualidade visível. Definir Accept-Ranges: bytes sinaliza para o navegador que ele pode solicitar partes de um intervalo de bytes, permitindo uma busca mais rápida em PDFs grandes sem baixar o arquivo inteiro primeiro.
A especificação PDF/A da ISO define os requisitos de qualidade de arquivo para PDFs. Se a sua aplicação precisa gerar documentos arquiváveis a longo prazo, o modo de conformidade com PDF/A do IronPDF garante que a saída atenda a esses padrões, o que é particularmente relevante para fluxos de trabalho regulatórios ou jurídicos.
Para projetos legados do ASP.NET Web Forms, o padrão é ligeiramente diferente, pois você escreve diretamente na resposta HTTP:
protected void btnGeneratePdf_Click(object sender, EventArgs e)
{
using var renderer = new ChromePdfRenderer();
PdfDocument pdf = renderer.RenderHtmlAsPdf("<h1>Web Form PDF</h1>");
Response.ContentType = "application/pdf";
Response.BinaryWrite(pdf.BinaryData);
Response.End();
}Protected Sub btnGeneratePdf_Click(sender As Object, e As EventArgs)
Using renderer As New ChromePdfRenderer()
Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf("<h1>Web Form PDF</h1>")
Response.ContentType = "application/pdf"
Response.BinaryWrite(pdf.BinaryData)
Response.End()
End Using
End SubPara cargas de trabalho que geram muitos PDFs simultaneamente, consulte o guia da API assíncrona do IronPDF e a referência de otimização de desempenho para configurações que reduzem a sobrecarga de memória em cenários de alto rendimento.
Quando um navegador exibe um PDF embutido, ele automaticamente expõe um visualizador completo. Seus usuários terão seleção de texto para copiar conteúdo, uma barra de pesquisa integrada para localizar palavras ou números específicos, controles de impressão e download com um clique — tudo isso sem precisar escrever nenhum código na interface.
Além da visualização básica, o IronPDF oferece suporte a uma ampla gama de recursos de documentos que afetam o que os usuários veem no visualizador:
O tabela seguinte resume os principais métodos de conversão disponíveis na biblioteca e quando usar cada um:
| Método | Entrada | Ideal para |
|---|---|---|
RenderHtmlAsPdf | string HTML | Documentos padronizados, faturas, relatórios |
RenderUrlAsPdf | URL | Arquivamento de páginas web, capturas instantâneas de conteúdo ao vivo |
RenderHtmlAsPdf + Razor | HTML da visualização renderizada | Reutilizando modelos MVC existentes como PDFs |
RenderHtmlFileAsPdf | Arquivo HTML local | Modelos estáticos armazenados em disco |
Para implantações em contêineres, o IronPDF também oferece suporte a mecanismos remotos , permitindo que você execute a geração de PDFs como um microsserviço dedicado. Consulte o guia de otimização de memória para obter configurações ajustadas a ambientes com recursos limitados.
Para uma visão geral completa das funcionalidades, visite a página de recursos do IronPDF .
O IronPDF vai muito além da renderização básica. Você pode adicionar estrutura e identidade visual a cada documento usando as opções abaixo.
Os controles de layout de página incluem tamanhos de papel personalizados, configurações de orientação e configuração de margens. O suporte a tipografia cobre a renderização completa de fontes web via declarações CSS @font-face, o que significa que os documentos correspondem exatamente às fontes da sua marca. Você também pode incorporar e redimensionar imagens em páginas PDF, o que lhe dá controle total sobre a fidelidade visual.
Para manipulação de documentos, o IronPDF permite mesclar ou dividir PDFs existentes, adicionar ou remover páginas individuais e extrair texto e imagens programaticamente. A execução de JavaScript antes da captura suporta gráficos dinâmicos e visualizações de dados -- útil ao gerar relatórios que dependem de bibliotecas de renderização do lado do cliente como Chart.js ou D3.js.
Essas funcionalidades permitem que você produza documentos refinados e prontos para impressão diretamente do seu aplicativo, sem a necessidade de uma camada separada de processamento de documentos.
Se você precisa aceitar PDFs enviados pelo usuário e exibi-los juntamente com os gerados automaticamente, o IronPDF lê arquivos binários de PDF existentes com a mesma facilidade com que cria novos. Carregue um arquivo com PdfDocument.FromFile() e retorne seu BinaryData através do mesmo auxiliar File().
Consulte o tutorial de edição de PDF em C# para obter um passo a passo detalhado sobre como editar, anotar e modificar documentos existentes.
As duas alternativas mais comuns a uma abordagem do lado do servidor com o IronPDF são incorporar uma biblioteca visualizadora de PDF do lado do cliente (como o PDF.js , visualizador de código aberto da Mozilla) e direcionar os usuários para um sistema de gerenciamento de documentos separado.
Visualizadores do lado do cliente, como o PDF.js, funcionam bem para casos de exibição simples, mas exigem que você forneça o pacote JavaScript do visualizador, lide com o CORS para PDFs externos e gerencie a compatibilidade com navegadores. A geração no servidor com IronPDF mantém o pipeline de PDF inteiramente na pilha .NET , simplificando a política de segurança e evitando a complexidade de origens cruzadas.
Um sistema dedicado de gerenciamento de documentos adiciona uma sobrecarga operacional que a maioria das aplicações web não precisa. Para equipes que já utilizam o ASP.NET Core, gerar e transmitir PDFs diretamente do controlador é o caminho de menor resistência.
Exibir PDFs em uma aplicação web ASP.NET Core requer apenas algumas linhas de código. Gere o PDF com ChromePdfRenderer, defina Content-Disposition: inline, e retorne um FileResult -- o visualizador embutido do navegador lida com o restante.
Para implantações em produção, considere estas etapas para preparar sua configuração:
Pronto para adicionar a visualização de PDFs ao seu projeto? Comece com um teste gratuito e execute os exemplos acima em minutos. Quando estiver pronto para implementar, revise as opções de licenciamento que melhor se adequam ao tamanho da sua equipe e ao seu nível de uso. Para explorar conversões relacionadas, veja como o IronPDF lida com a conversão de DOCX para PDF , de imagem para PDF e outros formatos na biblioteca de guias práticos .
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.
