Ícono de mensaje
Saltar al pie de página
  1. IronPDF
  2. Blog de IronPDF
  3. Usando IronPDF
  4. Visor de PDF Asp .NET Core
USANDO IRONPDF

Cómo construir un visor de PDF ASP.NET Core con IronPDF

Curtis Chau
Curtis Chau
Actualizado:

Mostrar documentos PDF directamente en un navegador web es un requisito común para las aplicaciones ASP.NET Core modernas. Ya sea que esté generando facturas, informes o contratos, los usuarios esperan una experiencia de visualización de PDF fluida sin descargar archivos ni instalar complementos de terceros como Adobe Acrobat Reader. IronPDF hace que esto sea sencillo al brindar generación y transmisión de PDF del lado del servidor a través de un motor de renderizado basado en Chrome, sin necesidad de depender de un visor externo.

Este tutorial le mostrará cómo mostrar, guardar e imprimir archivos PDF en ASP.NET Core usando IronPDF. También aprenderá cómo la biblioteca maneja las implementaciones de contenedores y de nube, lo que la convierte en una opción confiable para las canalizaciones de DevOps de producción.

Banner promocional de la biblioteca IronPDF C# PDF que destaca la conversión de HTML a PDF, herramientas de edición, flexibilidad de implementación y oferta de prueba gratuita

¿Cómo muestran los navegadores los archivos PDF en línea?

Los navegadores modernos incluyen visores de PDF integrados que se activan al recibir una respuesta con el tipo MIME application/pdf. Cuando el controlador ASP.NET Core devuelve un PDF con el encabezado Content-Type correcto, el navegador lo representa en línea automáticamente: no es necesario instalar ningún complemento. Según MDN Web Docs , la configuración correcta del tipo MIME es esencial para controlar cómo los navegadores manejan las respuestas de los archivos.

IronPDF genera PDFs del lado del servidor usando su clase ChromePdfRenderer, que incorpora un motor completo de Chromium. Esto significa que los documentos se procesan con soporte completo para CSS, JavaScript, fuentes web y firmas digitales, utilizando la misma canalización de renderizado que impulsa a Google Chrome. El resultado es una salida con resolución de píxeles que los navegadores muestran en línea sin ninguna biblioteca de visualización del lado del cliente.

Para entornos en contenedores, esta arquitectura es particularmente valiosa. El renderizador se ejecuta completamente en proceso, sin generar procesos de navegador externos sin cabeza ni depender de servicios remotos. La limpieza de recursos se realiza automáticamente, lo que evita pérdidas de memoria en servicios ASP.NET Core de ejecución prolongada. Puede revisar el conjunto completo de funciones de IronPDF para comprender todas las capacidades de renderizado disponibles.

Cuadrícula de características de cuatro columnas que muestra las capacidades del software PDF: Crear PDFs, Convertir PDFs, Editar PDFs y Firmar y Proteger PDFs, con listas detalladas de características bajo cada categoría

¿Por qué la renderización del lado del servidor produce resultados consistentes?

La renderización del lado del servidor elimina la variabilidad del navegador en el proceso de generación de PDF. Cuando los PDF se generan del lado del cliente, la calidad de salida depende de la versión del navegador del usuario final, el sistema operativo y las fuentes instaladas. Con IronPDF, el mismo motor Chromium se ejecuta en todos los servidores (ya sea Windows, Linux o un contenedor Docker), lo que garantiza una salida idéntica para documentos de cumplimiento, facturas y contratos firmados.

¿Qué ofrece Chrome Engine en comparación con los convertidores HTML a PDF más simples?

Los convertidores simples de HTML a PDF a menudo omiten la ejecución de JavaScript , ignoran las consultas de medios CSS o producen una tipografía deficiente. El motor Chrome de IronPDF espera a que se complete el JavaScript, respeta los estilos @media print, maneja gráficos SVG y admite la codificación de caracteres UTF-8 para contenido internacional. Esta fidelidad es importante cuando se muestran documentos que los usuarios también imprimirán o archivarán.

¿Cómo instalar IronPDF en un proyecto ASP.NET Core ?

Para crear un nuevo proyecto ASP.NET Core se necesita un solo comando. Abra una terminal y ejecute:

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

A continuación, instala el paquete NuGet de IronPDF. Puede utilizar la Consola del Administrador de paquetes o la CLI de .NET :

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

Esto instala todo lo necesario: el motor Chrome, las bibliotecas de procesamiento de PDF y todas las dependencias específicas de la plataforma. IronPDF es compatible con .NET 6, 7, 8, 9 y 10 sin necesidad de configuración de marco adicional. La documentación de IronPDF cubre opciones de instalación avanzadas, incluidos paquetes reducidos para implementaciones con restricciones de tamaño, como AWS Lambda .

Consola del Administrador de paquetes de Visual Studio mostrando el progreso de la instalación del paquete NuGet de IronPDF, mostrando múltiples descargas de dependencias incluyendo componentes de Iron Software, gRPC y System.Threading.Channels

¿Qué variante de paquete debería elegir?

Para implementaciones estándar, usa IronPdf. Para entornos con límites estrictos de tamaño -- como AWS Lambda o funciones de borde -- el paquete IronPdf.Slim reduce la huella de descarga inicial. Ambas variantes exponen la misma API, por lo que no se requieren cambios de código al cambiar.

¿Cuáles son los problemas de instalación más comunes en entornos de contenedores?

Los contenedores de Linux a veces requieren bibliotecas de sistema adicionales para operaciones gráficas. Una configuración mínima de Dockerfile incluye:

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

Los contenedores de Windows normalmente funcionan sin dependencias adicionales. Para solucionar problemas, habilite el registro integrado de IronPDF para capturar errores de representación antes de que aparezcan como respuestas HTTP 500.

¿Cómo mostrar un PDF en línea en el navegador?

Devolver un PDF para visualización en línea en el navegador requiere tres cosas: generar el PDF, establecer el tipo MIME application/pdf, y omitir el parámetro de nombre de archivo del resultado File(). Aquí hay una acción completa del 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

La clave es la llamada File(): devolver application/pdf sin un nombre de archivo establece Content-Disposition: inline, lo que activa el visor de PDF integrado del navegador. Agregar un nombre de archivo cambia a Content-Disposition: attachment, lo que activa una descarga. Para conocer más patrones de conversión de HTML, consulte la guía de cadenas HTML a PDF .

Para aplicaciones de alto tráfico, utilice el método de renderizado asíncrono para evitar el bloqueo de subprocesos:

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

Ejemplo de una factura PDF básica vista en un visor de PDF basado en la web con controles de navegación estándar

¿Cuándo debería utilizar la generación de PDF asíncrona?

La generación asincrónica es importante para cualquier punto final que reciba solicitudes simultáneas. La generación sincrónica bloquea los subprocesos del grupo de subprocesos de ASP.NET Core , lo que reduce la cantidad de solicitudes simultáneas que su aplicación puede manejar. Cambie a métodos asincrónicos tempranamente: la superficie de la API es idéntica, por lo que la migración es sencilla.

¿Qué otras fuentes HTML puedes renderizar?

Más allá de las cadenas HTML, IronPDF procesa desde URL, archivos HTML en disco y vistas Razor . Llamar a renderer.RenderUrlAsPdf("https://example.com/report") captura una URL en vivo, mientras que renderer.RenderHtmlFileAsPdf("wwwroot/templates/invoice.html") lee desde el sistema de archivos local. Esta flexibilidad significa que puede reutilizar plantillas Razor existentes como plantillas PDF sin mantener archivos HTML separados. La lista de la Galería NuGet para IronPDF muestra la versión actual del paquete y las notas de la versión.

¿Cómo habilitar las descargas de archivos PDF en ASP.NET Core?

Activar la descarga de un archivo en lugar de su visualización en línea es un cambio de un solo parámetro. Agregar un nombre de archivo al resultado File() establece el encabezado Content-Disposition a 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 distribuidos entre muchos usuarios, la transmisión reduce el consumo máximo de memoria:

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

La transmisión envía datos PDF de forma progresiva, lo que reduce significativamente el uso máximo de memoria cuando se sirven archivos grandes a usuarios simultáneos. Para conocer patrones de exportación adicionales, consulte la guía sobre cómo fusionar y dividir archivos PDF y cómo extraer texto de archivos PDF .

Ejemplo de un documento PDF generado usando IronPDF for .NET, mostrado en una interfaz estándar de visor de PDF

¿Qué configuraciones de compresión funcionan mejor para diferentes tipos de documentos?

Los PDF con mucho texto se comprimen bien con una calidad de imagen del 70-80% y un impacto visual mínimo. Los documentos ricos en imágenes, como los folletos de marketing, necesitan una calidad del 85 al 95 % para preservar la claridad. Los informes financieros con gráficos deben mantenerse en un 85 % o más para mantener la legibilidad del gráfico. Pruebe los niveles de compresión con documentos representativos antes de implementarlos en producción.

¿Cómo generar archivos PDF listos para imprimir en ASP.NET Core?

Los PDFs listos para imprimir requieren una configuración de página específica: tipo de medio CSS para impresión, márgenes definidos y tamaño de papel explícito. IronPDF expone todo esto a través 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

Configurar CssMediaType.Print activa las reglas CSS @media print antes de renderizar. Esto oculta las barras de navegación, las barras laterales y otros elementos que solo aparecen en la pantalla. Los usuarios pueden luego imprimir el PDF desde el visor integrado del navegador usando atajos de teclado estándar, con control total sobre la selección de impresora y el número de copias. Para conocer patrones de encabezado y pie de página avanzados, consulte la guía de encabezados y pies de página .

También puedes añadir marcas de agua a documentos impresos, firmarlos digitalmente antes de la entrega, o protegerlos con configuraciones de contraseñas y permisos. Estas características se integran directamente a través de la API PdfDocument sin requerir un paso de procesamiento separado.

Ejemplo de un documento PDF listo para imprimir tal como aparece en un visor de PDF estándar, mostrando el formato característico para salida impresa

¿Qué configuración de página garantiza la compatibilidad entre impresoras?

Los tamaños estándar A4 o Carta con márgenes de 20 a 25 mm funcionan de manera confiable en todos los modelos de impresora. Evite tamaños de papel personalizados a menos que la implementación esté dirigida a una flota de impresoras conocida. Usa las propiedades CSS page-break-before y page-break-after en lugar de métodos propietarios de salto de página. La especificación CSS Paged Media del W3C define estas propiedades en detalle. Estas propiedades CSS estándar funcionan de manera consistente en el motor de renderizado de Chrome y las impresoras físicas.

¿Cómo implementar un visor de PDF ASP.NET Core en Docker?

IronPDF se ejecuta en contenedores Linux y Windows sin cambios de código. Las imágenes base utilizadas en el Dockerfile a continuación provienen de las imágenes de contenedor .NET oficiales de Microsoft , que se mantienen con parches de seguridad regulares. La siguiente configuración de Docker instala las bibliotecas del sistema necesarias y produce una compilación de varias etapas para un tamaño de imagen 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 las implementaciones de Kubernetes, agregue un punto final de verificación de estado que valide la generación de PDF de extremo a extremo:

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

Esta verificación de estado permite a Kubernetes detectar y reemplazar pods en mal estado antes de que los usuarios encuentren errores. También se integra con el middleware de monitoreo de estado de ASP.NET Core estándar. La licencia de prueba de IronPDF incluye funcionalidad completa para pruebas de Docker sin restricciones.

¿Cuáles son las ventajas de implementación de un renderizador en proceso?

La siguiente tabla compara el enfoque en proceso de IronPDF con las configuraciones de servidor de navegador sin cabeza que se usan comúnmente para la generación de PDF del lado del servidor:

Comparación de enfoques de generación de PDF para ASP.NET Core
Factor IronPDF (en proceso) Servidor de navegador sin cabeza
Complejidad de implementación Solo paquete NuGet Proceso o servicio separado
Latencia de red Ninguno (en proceso) HTTP viaje de ida y vuelta por solicitud
Huella del contenedor Contenedor individual Dos contenedores mínimo
Vigilancia de la salud Middleware estándar de ASP.NET Core Comprobación del estado del servicio por separado
Consistencia de renderizado Motor Chrome, versión bloqueada Varía según la versión del navegador.

¿Cómo agregar funciones avanzadas de PDF al visor?

IronPDF va mucho más allá de la visualización y descarga básicas. La misma biblioteca que convierte HTML a PDF también proporciona manejo de formularios PDF, marcas de agua personalizadas, firmas digitales, y conversión de PDF a imágenes mediante PDF-to-image conversion -- todo sin paquetes adicionales.

Para los flujos de trabajo de gestión de documentos, puede convertir archivos cargados a PDF, extraer texto para indexar, anotar documentos y entregárselos a los usuarios, todo dentro de un único controlador ASP.NET Core . La página de características de IronPDF proporciona una descripción general completa de las capacidades con ejemplos de código para cada área de características.

Capacidades clave que vale la pena destacar para las aplicaciones de visualización:

¿Cómo se gestiona la seguridad y el control de acceso a los archivos PDF?

Para aplicaciones que muestran documentos sensibles, combina las características de contraseña y permiso de IronPDF con el middleware de autorización de ASP.NET Core. Configure la acción del controlador para requerir autenticación y luego transmita el PDF: el documento nunca toca el sistema de archivos ni un punto final no autenticado.

Para cumplir con los requisitos de registro de auditoría, firme digitalmente los archivos PDF antes de transmitirlos. La firma registra la marca de tiempo de la firma y valida la integridad del documento, lo cual es importante para los documentos financieros y legales que se muestran a través de un visor de navegador.

¿Qué opciones de licencia están disponibles?

La licencia de IronPDF comienza con una prueba gratuita que incluye funcionalidad completa, adecuada para trabajos de desarrollo, preparación y prueba de concepto en entornos Docker y Kubernetes. Las licencias de producción cubren una variedad de escenarios de implementación, desde un solo desarrollador hasta implementaciones de servidores ilimitados.

La documentación de IronPDF proporciona referencias de API detalladas, guías de migración para actualizar entre versiones de .NET e instrucciones de configuración específicas de la plataforma para Windows, Linux, macOS, AWS y Azure.

IronPDF offers flexible licensing options starting at $749 for single developers up to $3,999 for unlimited usage, with significant discounts currently available

Crear un visor de PDF en ASP.NET Core lleva minutos con IronPDF. El motor de renderizado basado en Chrome maneja la complejidad de la conversión de HTML a PDF, el resultado File() de ASP.NET Core maneja el comportamiento en línea vs. descarga, y el mismo paquete cubre impresión, marcas de agua, firmas digitales y despliegues en contenedores. Comience con la prueba gratuita y agregue funciones avanzadas de documentos a medida que crezcan los requisitos.

Preguntas Frecuentes

¿Cómo puede IronPDF ayudar a mostrar archivos PDF en aplicaciones ASP.NET Core?

IronPDF simplifica el proceso utilizando un potente motor de renderizado basado en Chrome para mostrar archivos PDF directamente en navegadores web sin necesidad de descargas ni plugins adicionales.

¿Cuáles son las ventajas de utilizar un visor de PDF en ASP.NET Core?

El uso de un visor de PDF como IronPDF en ASP.NET Core mejora la experiencia del usuario, ya que permite ver, guardar e imprimir PDF sin problemas dentro del navegador, eliminando la necesidad de aplicaciones externas como Adobe Acrobat Reader.

¿Es necesario instalar Adobe Acrobat Reader para ver archivos PDF con IronPDF?

No, IronPDF permite ver archivos PDF directamente en el navegador, eliminando la necesidad de Adobe Acrobat Reader o cualquier otro plugin.

¿Qué tipos de documentos pueden mostrarse con IronPDF en una aplicación ASP.NET Core?

IronPDF puede utilizarse para mostrar sin problemas diversos tipos de documentos, como facturas, informes y contratos, en aplicaciones ASP.NET Core.

¿Es IronPDF compatible con la impresión de documentos PDF en ASP.NET Core?

Sí, IronPDF admite la impresión de documentos PDF directamente desde la aplicación web, proporcionando una solución completa de gestión de PDF.

¿Puede IronPDF renderizar diseños PDF complejos con precisión en ASP.NET Core?

IronPDF utiliza un motor de renderizado basado en Chrome para renderizar con precisión diseños PDF complejos, garantizando una visualización de alta calidad sin pérdida de fidelidad.

¿Necesito descargar archivos PDF para verlos con IronPDF en ASP.NET Core?

No, IronPDF permite a los usuarios ver archivos PDF directamente en el navegador web sin necesidad de descargarlos.

¿Cómo mejora IronPDF la experiencia de visualización de PDF en aplicaciones web?

IronPDF mejora la experiencia de visualización de PDF al ofrecer una integración perfecta con ASP.NET Core, lo que permite a los usuarios ver, guardar e imprimir PDF directamente en el navegador.

Curtis Chau
Curtis Chau
  Chatea con el equipo de ingeniería ahora
Escritor Técnico

Curtis Chau tiene una licenciatura en Ciencias de la Computación (Carleton University) y se especializa en el desarrollo front-end con experiencia en Node.js, TypeScript, JavaScript y React. Apasionado por crear interfaces de usuario intuitivas y estéticamente agradables, disfruta trabajando con frameworks modernos y creando manuales bien ...

Leer más

Artículos Relacionados
Prueba de 30 días → Producto completo. Sin límites. Sin tarjeta. Prueba gratis

Equipo de soporte de Iron

Estamos disponibles online las 24 horas, 5 días a la semana.
Chat
Email
Llámame