Construir un visor de PDF en una aplicación ASP.NET Core es más fácil de lo que la mayoría de los desarrolladores esperan. Al generar archivos PDF del lado del servidor y devolverlos con el tipo MIME correcto, puede mostrar documentos directamente en cualquier navegador moderno, sin necesidad de complementos ni Adobe Acrobat Reader. IronPDF maneja la renderización a través de su motor basado en Chrome , convirtiendo HTML, CSS y JavaScript en PDF de alta fidelidad que aparecen en línea en el visor integrado del navegador.
Este tutorial lo guiará a través de cada escenario principal: visualización de PDF generados a partir de cadenas HTML, representación de URL en vivo, conversión de vistas de Razor , transmisión de archivos grandes y conexión de todo esto en un controlador ASP.NET Core MVC. Los ejemplos de código apuntan a .NET 10 con declaraciones de nivel superior cuando corresponde.
Los navegadores modernos vienen con un visor de PDF incorporado. Cuando un servidor responde con el encabezado Content-Type: application/pdf, el navegador representa el documento en línea en lugar de activar una descarga de archivo. La clave es emparejar ese encabezado con Content-Disposition: inline.
En el lado del servidor, su trabajo es producir un binario PDF válido y devolverlo a través de un FileResult. El navegador maneja la paginación, el zoom, la selección de texto, la búsqueda, la impresión y la descarga sin ningún código de interfaz de usuario adicional de su parte.
IronPDF encaja en este patrón de forma natural. Su clase ChromePdfRenderer convierte HTML (o una URL activa) en un binario PDF, y usted pasa ese binario directamente al ayudante File() de ASP.NET. El resultado es un visor de documentos con todas las funciones que funciona en Chrome, Firefox, Edge y Safari.
Los navegadores modernos implementan la especificación de representación de PDF del W3C a través de sus motores de visualización nativos, lo que significa que cualquier PDF compatible que devuelva su servidor se mostrará correctamente sin configuración adicional. La salida de IronPDF es totalmente compatible con los estándares, por lo que puede confiar en una representación consistente en todas las versiones del navegador.
Para implementaciones en contenedores, IronPDF proporciona imágenes oficiales de Docker que preconfiguran las dependencias de Chromium para que no necesite instalar Chrome manualmente en cada nodo. Se admiten contenedores tanto de Linux como de Windows. Si necesita escalar la generación de PDF de forma independiente, la imagen Docker de IronPDF Engine le permite ejecutar el proceso de renderizado como un microservicio separado.
Abra su proyecto ASP.NET Core en Visual Studio, luego instale IronPDF a través de la consola del Administrador de paquetes NuGet :
O usa la CLI de .NET:
Después de la instalación, agregue su clave de licencia a Program.cs antes de llamar a cualquier API de IronPDF :
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"Si va a implementar en Azure , almacene la clave de licencia en Azure Key Vault o App Configuration en lugar de codificarla. Para las implementaciones de AWS Lambda, utilice las variables de entorno configuradas en la configuración de la función Lambda.
Esta es la configuración completa. IronPDF detecta y configura Chromium automáticamente durante la ejecución en Windows. En Linux, consulte la guía de instalación de Linux para conocer los pocos paquetes de sistema necesarios.
Puede comenzar con una prueba gratuita para evaluar el conjunto completo de funciones antes de elegir un nivel de licencia para producción.
La forma más rápida de mostrar un PDF al usuario es renderizar una cadena HTML y devolverla en línea. Cree un controlador llamado PdfController y añada una acción como esta:
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 bajo el capó, por lo que la cuadrícula CSS, flexbox, las fuentes web y las características CSS modernas se representan con precisión. La configuración de Content-Disposition en inline es lo que le indica al navegador que muestre el archivo en lugar de guardarlo. Si cambia ese valor a attachment, el navegador solicitará al usuario que lo descargue.
Para documentos con diseños complejos, puede ajustar la salida a través de opciones de renderizado, como tamaños de papel personalizados, márgenes y tipo de medio CSS de impresión. La API WaitFor es especialmente útil en entornos de contenedores donde la latencia de la red puede retrasar la carga de activos externos.
Para obtener una visión más profunda de las opciones de conversión de HTML, consulte la guía de cadena HTML a PDF .
IronPDF puede capturar cualquier página web activa como PDF: ideal para archivar contenido web o generar informes a partir de páginas existentes. La documentación de ASP.NET Core cubre cómo las acciones del controlador devuelven resultados, que es el patrón utilizado aquí.
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
Cuando necesita convertir una vista de Razor (como una factura o una plantilla de estado de cuenta), primero debe representar la vista en una cadena HTML y luego pasar esa cadena a IronPDF. Esto permite que sus plantillas se puedan reutilizar tanto en formato web como PDF:
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
El parámetro baseUrl es importante cuando su vista Razor hace referencia a rutas de imágenes o CSS relativas. Pasar la URL del host actual permite que IronPDF resuelva esas rutas correctamente. Consulta el tutorial de Razor a PDF para obtener el recorrido completo, incluidos los patrones de aplicación de Blazor .
Para documentos que pueden tener varios megabytes de tamaño, la transmisión reduce el uso máximo de memoria y comienza a entregar bytes al cliente antes. Utilice FileStreamResult en lugar de File() con una matriz de bytes sin formato:
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) reduce la calidad JPEG al 80%, lo que reduce significativamente el tamaño del archivo para documentos con muchas imágenes con una pérdida de calidad visible mínima. La configuración de Accept-Ranges: bytes indica al navegador que puede solicitar fragmentos de rango de bytes, lo que permite una búsqueda más rápida dentro de archivos PDF grandes sin tener que descargar primero el archivo completo.
La especificación PDF/A de ISO define los requisitos de PDF con calidad de archivo. Si su aplicación necesita producir documentos de archivo a largo plazo, el modo de cumplimiento PDF/A de IronPDF garantiza que la salida cumpla con esos estándares, lo que es particularmente relevante para flujos de trabajo regulatorios o legales.
Para los proyectos de formularios web ASP.NET heredados, el patrón es ligeramente diferente porque se escribe directamente en la respuesta 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 trabajo que generan muchos archivos PDF simultáneamente, revise la guía de API asíncrona de IronPDF y la referencia de optimización del rendimiento para conocer las configuraciones que reducen la sobrecarga de memoria en escenarios de alto rendimiento.
Cuando un navegador muestra un PDF en línea, expone automáticamente un visor con todas las funciones. Sus usuarios obtienen selección de texto para copiar contenido, una barra de búsqueda incorporada para localizar palabras o números específicos, controles de impresión y descarga con un solo clic, todo sin ningún código de interfaz de su parte.
Más allá de la visualización básica, IronPDF admite una amplia gama de funciones de documentos que afectan lo que los usuarios ven en el visor:
La siguiente tabla resume los principales métodos de conversión disponibles en la biblioteca y cuándo utilizar cada uno:
| Método | Aporte | Mejor para |
|---|---|---|
RenderHtmlAsPdf | Cadena HTML | Documentos, facturas e informes con plantillas |
RenderUrlAsPdf | URL | Archivado de páginas web, instantáneas de contenido en vivo |
RenderHtmlAsPdf + Razor | Vista renderizada HTML | Reutilización de plantillas MVC existentes como archivos PDF |
RenderHtmlFileAsPdf | Archivo HTML local | Plantillas estáticas almacenadas en el disco |
Para implementaciones en contenedores, IronPDF también ofrece compatibilidad con motores remotos para que pueda ejecutar la generación de PDF como un microservicio dedicado. Consulte la guía de optimización de memoria para ver la configuración adaptada a entornos con recursos limitados.
Para obtener una descripción completa de las capacidades, visite la página de características de IronPDF .
IronPDF va mucho más allá de la renderización básica. Puede agregar estructura y marca a cada documento utilizando las opciones siguientes.
Los controles de diseño de página incluyen tamaños de papel personalizados, configuraciones de orientación y configuración de márgenes. El soporte de tipografía cubre la representación completa de fuentes web a través de declaraciones CSS @font-face, lo que significa que los documentos coinciden exactamente con las fuentes de su marca. También puede incrustar y cambiar el tamaño de imágenes dentro de páginas PDF, lo que le brinda control total sobre la fidelidad visual.
Para la manipulación de documentos, IronPDF le permite fusionar o dividir PDF existentes, agregar o eliminar páginas individuales y extraer texto e imágenes mediante programación. La ejecución de JavaScript antes de la captura admite gráficos dinámicos y visualizaciones de datos, lo cual resulta útil al generar informes que dependen de bibliotecas de representación del lado del cliente como Chart.js o D3.js.
Estas capacidades significan que usted puede producir documentos pulidos y listos para imprimir directamente desde su aplicación sin una capa de procesamiento de documentos separada.
Si necesita aceptar archivos PDF cargados por el usuario y mostrarlos junto con los generados, IronPDF lee binarios PDF existentes con la misma facilidad con la que crea nuevos. Cargue un archivo con PdfDocument.FromFile() y devuelva su BinaryData a través del mismo ayudante File().
Consulte el tutorial de edición de PDF en C# para obtener una guía detallada sobre cómo editar, anotar y modificar documentos existentes.
Las dos alternativas más comunes a un enfoque del lado del servidor de IronPDF son incorporar una biblioteca de visualización de PDF del lado del cliente (como PDF.js , el visualizador de código abierto de Mozilla) y enrutar a los usuarios a un sistema de gestión de documentos separado.
Los visores del lado del cliente como PDF.js funcionan bien para casos de visualización sencillos, pero requieren servir el paquete JavaScript del visor, manejar CORS para PDF externos y administrar la compatibilidad del navegador usted mismo. La generación del lado del servidor con IronPDF mantiene la canalización de PDF completamente en la pila .NET , lo que simplifica la política de seguridad y evita la complejidad entre orígenes.
Un sistema de gestión de documentos dedicado agrega una sobrecarga operativa que la mayoría de las aplicaciones web no necesitan. Para los equipos que ya ejecutan ASP.NET Core, generar y transmitir archivos PDF directamente desde el controlador es el camino de menor resistencia.
Mostrar archivos PDF en una aplicación web ASP.NET Core solo requiere unas pocas líneas de código. Genere el PDF con ChromePdfRenderer, configure Content-Disposition: inline y devuelva un FileResult -- el visor integrado del navegador maneja todo lo demás.
Para implementaciones de producción, considere estos pasos para preparar su configuración:
¿Estás listo para agregar visualización de PDF a tu proyecto? Comience con una prueba gratuita y ejecute los ejemplos anteriores en minutos. Cuando esté listo para implementar, revise las opciones de licencia que se ajusten al tamaño y uso de su equipo. Para explorar las conversiones relacionadas, consulte cómo IronPDF maneja DOCX a PDF , imagen a PDF y otros formatos en la biblioteca de guías prácticas .
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 estructurados y visualmente atractivos.
IronPDF es parte de IRONSUITE
10 productos API .NET para tus documentos de oficina
Cuando necesitas que tu PDF se parezca al HTML, rápido.
