Ícone de mensagem
Ir para o conteúdo do rodapé
  1. IronPDF
  2. Blog do IronPDF
  3. Usando o IronPDF
  4. Visualizador de PDF ASP.NET Core
USANDO O IRONPDF

Como Construir um Visualizador de PDF ASP.NET Core com IronPDF

Curtis Chau
Curtis Chau
Atualizado:

Exibir documentos PDF diretamente em um navegador da web é um requisito comum para aplicativos ASP.NET Core modernos. Seja para gerar faturas, relatórios ou contratos, os usuários esperam uma experiência de visualização de PDFs tranquila, sem precisar baixar arquivos ou instalar plugins de terceiros, como o Adobe Acrobat Reader. O IronPDF simplifica esse processo, fornecendo geração e transmissão de PDFs no servidor por meio de um mecanismo de renderização baseado no Chrome — sem necessidade de visualizadores externos.

Este tutorial mostra como exibir, salvar e imprimir arquivos PDF no ASP.NET Core usando o IronPDF. Você também aprenderá como a biblioteca lida com implantações em contêineres e na nuvem, tornando-a uma escolha confiável para pipelines DevOps de produção.

! Banner promocional da biblioteca IronPDF C# para PDF, destacando a conversão de HTML para PDF, ferramentas de edição, flexibilidade de implementação e oferta de avaliação gratuita.

Como os navegadores exibem arquivos PDF embutidos?

Os navegadores modernos incluem visualizadores de PDF integrados que são ativados ao receber uma resposta com o tipo MIME application/pdf. Quando o seu controlador ASP.NET Core retorna um PDF com o cabeçalho Content-Type correto, o navegador o renderiza automaticamente em linha — sem necessidade de instalação de plugin. De acordo com a documentação da MDN Web Docs , a configuração correta do tipo MIME é essencial para controlar como os navegadores lidam com as respostas de arquivos.

O IronPDF gera PDFs no servidor usando sua classe ChromePdfRenderer, que incorpora um mecanismo Chromium completo. Isso significa que os documentos são renderizados com suporte completo a CSS, JavaScript, fontes da web e assinatura digital — o mesmo pipeline de renderização que alimenta o Google Chrome. O resultado é uma saída com resolução perfeita em pixels, que os navegadores exibem diretamente na página, sem a necessidade de qualquer biblioteca de visualização do lado do cliente.

Para ambientes conteinerizados, essa arquitetura é particularmente valiosa. O renderizador é executado inteiramente no mesmo processo, sem gerar processos externos de navegador sem interface gráfica ou depender de serviços remotos. A limpeza de recursos ocorre automaticamente, evitando vazamentos de memória em serviços ASP.NET Core de longa duração. Você pode consultar o conjunto completo de recursos do IronPDF para entender todas as capacidades de renderização disponíveis.

Grade de recursos com quatro colunas exibindo as funcionalidades do software de PDF: Criar PDFs, Converter PDFs, Editar PDFs e Assinar e proteger PDFs, com listas detalhadas de recursos em cada categoria.

Por que a renderização do lado do servidor produz resultados consistentes?

A renderização no servidor elimina a variabilidade entre navegadores no processo de geração de PDFs. Quando os PDFs são gerados no lado do cliente, a qualidade da saída depende da versão do navegador, do sistema operacional e das fontes instaladas pelo usuário final. Com o IronPDF, o mesmo mecanismo Chromium é executado em todos os servidores — sejam eles Windows, Linux ou contêineres Docker — garantindo resultados idênticos para documentos de conformidade, faturas e contratos assinados.

O que o mecanismo do Chrome oferece em comparação com conversores simples de HTML para PDF?

Conversores simples de HTML para PDF frequentemente omitem a execução de JavaScript , ignoram as consultas de mídia CSS ou produzem tipografia de baixa qualidade. O mecanismo Chrome do IronPDF aguarda a conclusão do JavaScript, respeita estilos @media print, lida com gráficos SVG e suporta codificação de caracteres UTF-8 para conteúdo internacional. Essa fidelidade é importante ao exibir documentos que os usuários também irão imprimir ou arquivar.

Como instalar o IronPDF em um projeto ASP.NET Core ?

Criar um novo projeto ASP.NET Core requer apenas um comando. Abra um terminal e execute o seguinte comando:

dotnet new mvc -n PdfViewerApp
cd PdfViewerApp
dotnet new mvc -n PdfViewerApp
cd PdfViewerApp
SHELL

Em seguida, instale o pacote NuGet IronPDF . Você pode usar o Console do Gerenciador de Pacotes ou a CLI do .NET :

Install-Package IronPdf
dotnet add package IronPdf
Install-Package IronPdf
dotnet add package IronPdf
SHELL

Isso instala tudo o que é necessário: o mecanismo do Chrome, as bibliotecas de processamento de PDF e todas as dependências específicas da plataforma. O IronPDF é compatível com .NET 6, 7, 8, 9 e 10 sem necessidade de configuração adicional do framework. A documentação do IronPDF abrange opções avançadas de instalação, incluindo pacotes compactos para implantações com restrições de tamanho, como o AWS Lambda .

! Console do Gerenciador de Pacotes do Visual Studio exibindo o progresso da instalação do pacote NuGet IronPDF, mostrando vários downloads de dependências, incluindo componentes da Iron Software, gRPC e System.Threading.Channels

Qual variante de pacote você deve escolher?

Para implantações padrão, use IronPdf. Para ambientes com limites de tamanho rigorosos -- como AWS Lambda ou funções de borda -- o pacote IronPdf.Slim reduz o tamanho do download inicial. Ambas as variantes expõem a mesma API, portanto, nenhuma alteração de código é necessária ao alternar entre elas.

Quais são os problemas de instalação mais comuns em ambientes de contêineres?

Os contêineres Linux às vezes exigem bibliotecas de sistema adicionais para operações gráficas. Uma configuração mínima de Dockerfile inclui:

apt-get update && apt-get install -y libgdiplus libc6-dev libx11-dev
apt-get update && apt-get install -y libgdiplus libc6-dev libx11-dev
SHELL

Os contêineres do Windows normalmente funcionam sem dependências adicionais. Para solucionar problemas, habilite o registro de logs integrado do IronPDF para capturar erros de renderização antes que eles se manifestem como respostas HTTP 500.

Como exibir um PDF diretamente no navegador?

Retornar um PDF para visualização embutida no navegador requer três coisas: gerar o PDF, definir o tipo MIME application/pdf e omitir o parâmetro de nome do arquivo do resultado File(). Aqui está uma ação completa do controlador:

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

// PdfController.cs
public class PdfController : Controller
{
    public IActionResult ViewPdf()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PrintHtmlBackgrounds = true;
        renderer.RenderingOptions.CreatePdfFormsFromHtml = true;
        renderer.RenderingOptions.EnableJavaScript = true;
        renderer.RenderingOptions.RenderDelay = 100;

        var html = @"
            <html>
            <head>
                <style>
                    body { font-family: Arial, sans-serif; padding: 20px; }
                    h1 { color: #2c3e50; }
                    .content { line-height: 1.6; }
                </style>
            </head>
            <body>
                <h1>Invoice #12345</h1>
                <div class='content'>
                    <p>Date: " + DateTime.Now.ToString("yyyy-MM-dd") + @"</p>
                    <p>Thank you for your business!</p>
                </div>
            </body>
            </html>";

        var pdf = renderer.RenderHtmlAsPdf(html);

        // Omitting the filename tells the browser to display inline
        return File(pdf.BinaryData, "application/pdf");
    }
}
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();

// PdfController.cs
public class PdfController : Controller
{
    public IActionResult ViewPdf()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PrintHtmlBackgrounds = true;
        renderer.RenderingOptions.CreatePdfFormsFromHtml = true;
        renderer.RenderingOptions.EnableJavaScript = true;
        renderer.RenderingOptions.RenderDelay = 100;

        var html = @"
            <html>
            <head>
                <style>
                    body { font-family: Arial, sans-serif; padding: 20px; }
                    h1 { color: #2c3e50; }
                    .content { line-height: 1.6; }
                </style>
            </head>
            <body>
                <h1>Invoice #12345</h1>
                <div class='content'>
                    <p>Date: " + DateTime.Now.ToString("yyyy-MM-dd") + @"</p>
                    <p>Thank you for your business!</p>
                </div>
            </body>
            </html>";

        var pdf = renderer.RenderHtmlAsPdf(html);

        // Omitting the filename tells the browser to display inline
        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()

' PdfController.vb
Public Class PdfController
    Inherits Controller

    Public Function ViewPdf() As IActionResult
        Dim renderer = New ChromePdfRenderer()
        renderer.RenderingOptions.PrintHtmlBackgrounds = True
        renderer.RenderingOptions.CreatePdfFormsFromHtml = True
        renderer.RenderingOptions.EnableJavaScript = True
        renderer.RenderingOptions.RenderDelay = 100

        Dim html = "
            <html>
            <head>
                <style>
                    body { font-family: Arial, sans-serif; padding: 20px; }
                    h1 { color: #2c3e50; }
                    .content { line-height: 1.6; }
                </style>
            </head>
            <body>
                <h1>Invoice #12345</h1>
                <div class='content'>
                    <p>Date: " & DateTime.Now.ToString("yyyy-MM-dd") & "</p>
                    <p>Thank you for your business!</p>
                </div>
            </body>
            </html>"

        Dim pdf = renderer.RenderHtmlAsPdf(html)

        ' Omitting the filename tells the browser to display inline
        Return File(pdf.BinaryData, "application/pdf")
    End Function
End Class
$vbLabelText   $csharpLabel

A chave está na chamada File(): retornar application/pdf sem um nome de arquivo define Content-Disposition: inline, o que aciona o visualizador de PDF integrado do navegador. Adicionar um nome de arquivo alterna para Content-Disposition: attachment, o que inicia um download. Para mais padrões de conversão de HTML, consulte o guia de conversão de string HTML para PDF .

Para aplicações com alto tráfego, utilize o método de renderização assíncrona para evitar o bloqueio de threads:

public async Task<IActionResult> ViewPdfAsync()
{
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.Timeout = 60;

    var html = await GetHtmlContentAsync();
    var pdf = await renderer.RenderHtmlAsPdfAsync(html);

    return File(pdf.BinaryData, "application/pdf");
}
public async Task<IActionResult> ViewPdfAsync()
{
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.Timeout = 60;

    var html = await GetHtmlContentAsync();
    var pdf = await renderer.RenderHtmlAsPdfAsync(html);

    return File(pdf.BinaryData, "application/pdf");
}
Imports System.Threading.Tasks

Public Async Function ViewPdfAsync() As Task(Of IActionResult)
    Dim renderer = New ChromePdfRenderer()
    renderer.RenderingOptions.Timeout = 60

    Dim html = Await GetHtmlContentAsync()
    Dim pdf = Await renderer.RenderHtmlAsPdfAsync(html)

    Return File(pdf.BinaryData, "application/pdf")
End Function
$vbLabelText   $csharpLabel

Exemplo de uma fatura em PDF básica visualizada em um visualizador de PDF online com controles de navegação padrão.

Quando você deve usar a geração assíncrona de PDFs?

A geração assíncrona é importante para qualquer endpoint que receba solicitações simultâneas. A geração síncrona bloqueia os threads do pool de threads do ASP.NET Core , reduzindo o número de solicitações simultâneas que seu aplicativo pode processar. Mude para métodos assíncronos o quanto antes -- a interface da API é idêntica, então a migração é simples.

Que outras fontes HTML você consegue renderizar?

Além de strings HTML, o IronPDF renderiza a partir de URLs, arquivos HTML no disco e visualizações Razor . Chamar renderer.RenderUrlAsPdf("https://example.com/report") captura um URL ativo, enquanto renderer.RenderHtmlFileAsPdf("wwwroot/templates/invoice.html") lê do sistema de arquivos local. Essa flexibilidade significa que você pode reutilizar modelos Razor existentes como modelos PDF sem precisar manter arquivos HTML separados. A listagem do IronPDF na Galeria NuGet mostra a versão atual do pacote e as notas de lançamento.

Como habilitar o download de arquivos PDF no ASP.NET Core?

Acionar o download de um arquivo em vez da exibição direta requer uma alteração de um único parâmetro. Adicionar um nome de arquivo ao resultado File() define o cabeçalho Content-Disposition como attachment:

public IActionResult DownloadPdf()
{
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.ImageQuality = 85;

    var html = @"<h1>Quarterly Report</h1>
                 <p>Revenue this quarter exceeded projections by 12%.</p>";
    var pdf = renderer.RenderHtmlAsPdf(html, @"wwwroot/images");

    // Compress images to reduce download size
    pdf.CompressImages(30);

    // The filename parameter triggers download instead of inline view
    return File(pdf.BinaryData, "application/pdf", "quarterly-report-2026.pdf");
}
public IActionResult DownloadPdf()
{
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.ImageQuality = 85;

    var html = @"<h1>Quarterly Report</h1>
                 <p>Revenue this quarter exceeded projections by 12%.</p>";
    var pdf = renderer.RenderHtmlAsPdf(html, @"wwwroot/images");

    // Compress images to reduce download size
    pdf.CompressImages(30);

    // The filename parameter triggers download instead of inline view
    return File(pdf.BinaryData, "application/pdf", "quarterly-report-2026.pdf");
}
Public Function DownloadPdf() As IActionResult
    Dim renderer = New ChromePdfRenderer()
    renderer.RenderingOptions.ImageQuality = 85

    Dim html As String = "<h1>Quarterly Report</h1>
                          <p>Revenue this quarter exceeded projections by 12%.</p>"
    Dim pdf = renderer.RenderHtmlAsPdf(html, "wwwroot/images")

    ' Compress images to reduce download size
    pdf.CompressImages(30)

    ' The filename parameter triggers download instead of inline view
    Return File(pdf.BinaryData, "application/pdf", "quarterly-report-2026.pdf")
End Function
$vbLabelText   $csharpLabel

Para documentos grandes servidos a muitos usuários, o streaming reduz o consumo máximo de memória:

public IActionResult StreamPdf()
{
    var renderer = new ChromePdfRenderer();
    var html = "<h1>Large Report</h1><p>Content spanning many pages.</p>";
    var pdf = renderer.RenderHtmlAsPdf(html);

    var stream = pdf.Stream;
    stream.Position = 0;

    // Stream directly without buffering the full byte array
    return File(stream, "application/pdf", "report.pdf");
}
public IActionResult StreamPdf()
{
    var renderer = new ChromePdfRenderer();
    var html = "<h1>Large Report</h1><p>Content spanning many pages.</p>";
    var pdf = renderer.RenderHtmlAsPdf(html);

    var stream = pdf.Stream;
    stream.Position = 0;

    // Stream directly without buffering the full byte array
    return File(stream, "application/pdf", "report.pdf");
}
Imports IronPdf

Public Function StreamPdf() As IActionResult
    Dim renderer As New ChromePdfRenderer()
    Dim html As String = "<h1>Large Report</h1><p>Content spanning many pages.</p>"
    Dim pdf = renderer.RenderHtmlAsPdf(html)

    Dim stream = pdf.Stream
    stream.Position = 0

    ' Stream directly without buffering the full byte array
    Return File(stream, "application/pdf", "report.pdf")
End Function
$vbLabelText   $csharpLabel

O streaming envia dados PDF progressivamente, o que reduz significativamente o pico de uso de memória ao fornecer arquivos grandes para usuários simultâneos. Para obter mais informações sobre padrões de exportação, consulte o guia sobre como mesclar e dividir PDFs e extrair texto de PDFs .

Exemplo de um documento PDF gerado usando o IronPDF para .NET, exibido em uma interface de visualizador de PDF padrão.

Quais configurações de compressão funcionam melhor para diferentes tipos de documentos?

Arquivos PDF com muito texto são bem comprimidos, mantendo 70-80% da qualidade da imagem e com impacto visual mínimo. Documentos com muitas imagens, como folhetos de marketing, precisam de uma qualidade de 85 a 95% para manter a clareza. Os relatórios financeiros com gráficos devem ter uma ocupação de 85% ou superior para manter a legibilidade dos gráficos. Teste os níveis de compressão em documentos representativos antes de implantá-los em produção.

Como gerar PDFs prontos para impressão no ASP.NET Core?

PDFs prontos para impressão exigem configurações específicas de página: tipo de mídia CSS de impressão, margens definidas e tamanho de papel explícito. O IronPDF expõe todas essas opções por meio de RenderingOptions:

public IActionResult PrintablePdf()
{
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
    renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait;
    renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
    renderer.RenderingOptions.MarginTop = 25;
    renderer.RenderingOptions.MarginBottom = 25;
    renderer.RenderingOptions.MarginLeft = 25;
    renderer.RenderingOptions.MarginRight = 25;

    // Add headers and footers for professional print output
    renderer.RenderingOptions.TextHeader = new TextHeaderFooter
    {
        CenterText = "Confidential Document",
        DrawDividerLine = true
    };
    renderer.RenderingOptions.TextFooter = new TextHeaderFooter
    {
        CenterText = "Page {page} of {total-pages}",
        FontSize = 10
    };

    var html = @"
        <style>
            @media print {
                .no-print { display: none; }
                .page-break { page-break-after: always; }
            }
        </style>
        <h1>Print-Ready Document</h1>
        <p>This document is formatted for A4 printing with standard margins.</p>
        <div class='page-break'></div>
        <h2>Page 2</h2>
        <p>Content continues on the second page.</p>";

    var pdf = renderer.RenderHtmlAsPdf(html);
    return File(pdf.BinaryData, "application/pdf");
}
public IActionResult PrintablePdf()
{
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
    renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait;
    renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
    renderer.RenderingOptions.MarginTop = 25;
    renderer.RenderingOptions.MarginBottom = 25;
    renderer.RenderingOptions.MarginLeft = 25;
    renderer.RenderingOptions.MarginRight = 25;

    // Add headers and footers for professional print output
    renderer.RenderingOptions.TextHeader = new TextHeaderFooter
    {
        CenterText = "Confidential Document",
        DrawDividerLine = true
    };
    renderer.RenderingOptions.TextFooter = new TextHeaderFooter
    {
        CenterText = "Page {page} of {total-pages}",
        FontSize = 10
    };

    var html = @"
        <style>
            @media print {
                .no-print { display: none; }
                .page-break { page-break-after: always; }
            }
        </style>
        <h1>Print-Ready Document</h1>
        <p>This document is formatted for A4 printing with standard margins.</p>
        <div class='page-break'></div>
        <h2>Page 2</h2>
        <p>Content continues on the second page.</p>";

    var pdf = renderer.RenderHtmlAsPdf(html);
    return File(pdf.BinaryData, "application/pdf");
}
Imports System.Web.Mvc

Public Function PrintablePdf() As ActionResult
    Dim renderer = New ChromePdfRenderer()
    renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print
    renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait
    renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
    renderer.RenderingOptions.MarginTop = 25
    renderer.RenderingOptions.MarginBottom = 25
    renderer.RenderingOptions.MarginLeft = 25
    renderer.RenderingOptions.MarginRight = 25

    ' Add headers and footers for professional print output
    renderer.RenderingOptions.TextHeader = New TextHeaderFooter With {
        .CenterText = "Confidential Document",
        .DrawDividerLine = True
    }
    renderer.RenderingOptions.TextFooter = New TextHeaderFooter With {
        .CenterText = "Page {page} of {total-pages}",
        .FontSize = 10
    }

    Dim html = "
        <style>
            @media print {
                .no-print { display: none; }
                .page-break { page-break-after: always; }
            }
        </style>
        <h1>Print-Ready Document</h1>
        <p>This document is formatted for A4 printing with standard margins.</p>
        <div class='page-break'></div>
        <h2>Page 2</h2>
        <p>Content continues on the second page.</p>"

    Dim pdf = renderer.RenderHtmlAsPdf(html)
    Return File(pdf.BinaryData, "application/pdf")
End Function
$vbLabelText   $csharpLabel

A configuração CssMediaType.Print ativa as regras CSS @media print antes da renderização. Isso oculta as barras de navegação, barras laterais e outros elementos que só aparecem na tela. Em seguida, os usuários podem imprimir o PDF a partir do visualizador integrado do navegador usando atalhos de teclado padrão, com controle total sobre a seleção da impressora e a quantidade de cópias. Para padrões avançados de cabeçalho e rodapé, consulte o guia de cabeçalhos e rodapés .

Você também pode adicionar marcas d'água a documentos impressos, assiná-los digitalmente antes da entrega ou protegê-los com senha e configurações de permissões . Essas funcionalidades se integram diretamente por meio da API PdfDocument sem a necessidade de uma etapa de processamento separada.

Exemplo de um documento PDF pronto para impressão, tal como aparece num visualizador de PDF padrão, mostrando a formatação característica para impressão.

Qual configuração de página garante a compatibilidade entre impressoras?

Os tamanhos padrão A4 ou Carta, com margens de 20 a 25 mm, funcionam de forma confiável em todos os modelos de impressora. Evite tamanhos de papel personalizados, a menos que a implementação seja destinada a um conjunto de impressoras conhecido. Use as propriedades CSS page-break-before e page-break-after em vez de métodos proprietários de quebra de página. A especificação CSS Paged Media da W3C define essas propriedades em detalhes. Essas propriedades CSS padrão funcionam de forma consistente tanto no mecanismo de renderização do Chrome quanto em impressoras físicas.

Como implantar um visualizador de PDF ASP.NET Core no Docker?

O IronPDF funciona em contêineres Linux e Windows sem alterações de código. As imagens base usadas no Dockerfile abaixo são provenientes das imagens de contêiner .NET oficiais da Microsoft , que são mantidas com patches de segurança regulares. A configuração do Docker abaixo instala as bibliotecas de sistema necessárias e gera uma compilação em várias etapas para um tamanho de imagem mínimo:

FROM mcr.microsoft.com/dotnet/aspnet:10.0 AS base
WORKDIR /app

RUN apt-get update && apt-get install -y \
    libgdiplus \
    libc6-dev \
    libx11-dev \
    && rm -rf /var/lib/apt/lists/*

FROM mcr.microsoft.com/dotnet/sdk:10.0 AS build
WORKDIR /src
COPY ["PdfViewerApp.csproj", "./"]
RUN dotnet restore "PdfViewerApp.csproj"
COPY . .
RUN dotnet build "PdfViewerApp.csproj" -c Release -o /app/build

FROM build AS publish
RUN dotnet publish "PdfViewerApp.csproj" -c Release -o /app/publish

FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "PdfViewerApp.dll"]

Para implantações do Kubernetes, adicione um endpoint de verificação de integridade que valide a geração de PDFs de ponta a ponta:

builder.Services.AddHealthChecks()
    .AddCheck("pdf_generation", () =>
    {
        try
        {
            var renderer = new ChromePdfRenderer();
            var pdf = renderer.RenderHtmlAsPdf("<p>Health check</p>");
            return pdf.PageCount > 0
                ? HealthCheckResult.Healthy()
                : HealthCheckResult.Unhealthy("PDF generation returned empty document");
        }
        catch (Exception ex)
        {
            return HealthCheckResult.Unhealthy(ex.Message);
        }
    });
builder.Services.AddHealthChecks()
    .AddCheck("pdf_generation", () =>
    {
        try
        {
            var renderer = new ChromePdfRenderer();
            var pdf = renderer.RenderHtmlAsPdf("<p>Health check</p>");
            return pdf.PageCount > 0
                ? HealthCheckResult.Healthy()
                : HealthCheckResult.Unhealthy("PDF generation returned empty document");
        }
        catch (Exception ex)
        {
            return HealthCheckResult.Unhealthy(ex.Message);
        }
    });
Imports System
Imports Microsoft.Extensions.DependencyInjection
Imports Microsoft.Extensions.Diagnostics.HealthChecks

builder.Services.AddHealthChecks().AddCheck("pdf_generation", Function()
    Try
        Dim renderer As New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf("<p>Health check</p>")
        Return If(pdf.PageCount > 0, HealthCheckResult.Healthy(), HealthCheckResult.Unhealthy("PDF generation returned empty document"))
    Catch ex As Exception
        Return HealthCheckResult.Unhealthy(ex.Message)
    End Try
End Function)
$vbLabelText   $csharpLabel

Essa verificação de integridade permite que o Kubernetes detecte e substitua pods com problemas antes que os usuários encontrem erros. Ele também se integra ao middleware padrão de monitoramento de integridade do ASP.NET Core . A licença de avaliação do IronPDF inclui todas as funcionalidades para testes com Docker, sem restrições.

Quais são as vantagens de implantação de um renderizador em processo?

A tabela abaixo compara a abordagem in-process do IronPDF com configurações de servidor de navegador headless comumente usadas para geração de PDFs no lado do servidor:

Comparação de abordagens de geração de PDF para ASP.NET Core
Fator IronPDF (Em andamento) Servidor de navegador sem interface gráfica
Complexidade de implantação pacote NuGet apenas Processo ou serviço separado
Latência da rede Nenhum (em andamento) Tempo de ida e volta HTTP por solicitação
Área ocupada pelo contêiner Recipiente único No mínimo dois recipientes.
Monitoramento da saúde Middleware padrão do ASP.NET Core Verificação de integridade do serviço separada
Consistência de renderização Motor Chrome, versão bloqueada Varia conforme a versão do navegador.

Como adicionar recursos avançados de PDF ao visualizador?

O IronPDF vai muito além da simples visualização e download de arquivos. A mesma biblioteca que renderiza HTML para PDF também oferece manipulação de formulários PDF , marcas d'água personalizadas , assinaturas digitais e conversão de PDF para imagem — tudo sem pacotes adicionais.

Para fluxos de trabalho de gerenciamento de documentos, você pode converter arquivos carregados para PDF, extrair texto para indexação, anotar documentos e entregá-los aos usuários — tudo dentro de um único controlador ASP.NET Core . A página de recursos do IronPDF oferece uma visão geral completa das funcionalidades, com exemplos de código para cada área de recurso.

Funcionalidades importantes a destacar para aplicações de visualização:

  • Extração de texto -- indexar conteúdo de PDF para pesquisa ou arquivamento para fins de conformidade
  • Mesclar e dividir -- combinar vários documentos ou extrair páginas específicas
  • Marca d'água -- carimbar documentos com avisos de confidencialidade ou marca antes da exibição.
  • Assinaturas digitais -- assine PDFs gerados antes de exibi-los no navegador.
  • Cabeçalhos e rodapés -- adicione números de página, títulos de documentos e linhas divisórias

Como você lida com a segurança e o controle de acesso a PDFs?

Para aplicações que exibem documentos confidenciais, combine os recursos de senha e permissão do IronPDF com o middleware de autorização do ASP.NET Core. Configure a ação do controlador para exigir autenticação e, em seguida, transmita o PDF — o documento nunca acessa o sistema de arquivos ou um ponto de extremidade não autenticado.

Para atender aos requisitos de trilha de auditoria, assine digitalmente os PDFs antes de transmiti-los. A assinatura registra o horário da assinatura e valida a integridade do documento, o que é importante para documentos financeiros e jurídicos exibidos em um navegador.

Quais são as opções de licenciamento disponíveis?

O licenciamento do IronPDF começa com um período de avaliação gratuito que inclui todas as funcionalidades — adequado para desenvolvimento, teste e prova de conceito em ambientes Docker e Kubernetes. As licenças de produção abrangem uma variedade de cenários de implantação, desde implantações para um único desenvolvedor até implantações ilimitadas em servidores.

A documentação do IronPDF fornece referências detalhadas da API, guias de migração para atualização entre versões do .NET e instruções de configuração específicas para cada plataforma: Windows, Linux, macOS, AWS e Azure.

O IronPDF oferece opções flexíveis de licenciamento a partir de US$ 749 para desenvolvedores individuais até US$ 3.999 para uso ilimitado, com descontos significativos disponíveis no momento.

Com o IronPDF , integrar um visualizador de PDF ao ASP.NET Core leva apenas alguns minutos. O mecanismo de renderização baseado no Chrome lida com a complexidade da conversão de HTML para PDF, o resultado do ASP.NET Core lida com o comportamento de visualização embutida versus download, e o mesmo pacote abrange impressão, marca d'água, assinaturas digitais e implantações em contêineres. Comece com o teste gratuito e adicione recursos avançados de documentos à medida que suas necessidades aumentarem.

Perguntas frequentes

Como o IronPDF pode ajudar a exibir PDFs em aplicações ASP.NET Core?

O IronPDF simplifica o processo usando um poderoso mecanismo de renderização baseado no Chrome para exibir arquivos PDF diretamente em navegadores da web, sem a necessidade de downloads ou plugins adicionais.

Quais são os benefícios de usar um visualizador de PDF no ASP.NET Core?

Utilizar um visualizador de PDF como o IronPDF no ASP.NET Core melhora a experiência do usuário, permitindo a visualização, o salvamento e a impressão de PDFs diretamente no navegador, eliminando a necessidade de aplicativos externos como o Adobe Acrobat Reader.

É necessário instalar o Adobe Acrobat Reader para visualizar PDFs com o IronPDF?

Não, o IronPDF permite visualizar PDFs diretamente no navegador, eliminando a necessidade do Adobe Acrobat Reader ou de quaisquer outros plugins.

Que tipos de documentos podem ser exibidos usando o IronPDF em uma aplicação ASP.NET Core?

O IronPDF pode ser usado para exibir diversos tipos de documentos, como faturas, relatórios e contratos, de forma integrada em aplicações ASP.NET Core.

O IronPDF suporta a impressão de documentos PDF no ASP.NET Core?

Sim, o IronPDF permite a impressão de documentos PDF diretamente da aplicação web, oferecendo uma solução completa para gestão de PDFs.

O IronPDF consegue renderizar layouts de PDF complexos com precisão no ASP.NET Core?

O IronPDF utiliza um mecanismo de renderização baseado no Chrome para renderizar com precisão layouts de PDF complexos, garantindo uma exibição de alta qualidade sem perda de fidelidade.

Preciso baixar arquivos PDF para visualizá-los usando o IronPDF no ASP.NET Core?

Não, o IronPDF permite que os usuários visualizem arquivos PDF diretamente no navegador da web, sem a necessidade de baixá-los.

Como o IronPDF melhora a experiência de visualização de PDFs em aplicações web?

O IronPDF aprimora a experiência de visualização de PDFs, oferecendo integração perfeita com o ASP.NET Core, permitindo que os usuários visualizem, salvem e imprimam PDFs diretamente no navegador.

Curtis Chau
Curtis Chau
  Converse agora mesmo com a equipe de engenharia.
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

Artigos relacionados

Teste grátis por 30 dias → Produto completo. Sem limites. Sem cartão. Teste gratuito

Equipe de suporte de ferro

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