ASP.NET Visualizar PDF en Panel Usando IronPDF

¿Cómo simplifica IronPDF la visualización de archivos PDF en paneles?

IronPDF revoluciona la gestión de PDF en ASP.NET Core al trasladar el proceso de renderizado completamente al servidor. Este enfoque fundamental elimina los problemas tradicionales asociados con la visualización de PDF en el cliente, a la vez que proporciona un control programático eficaz sobre la generación y presentación de documentos a través de su motor de renderizado Chrome .

El motor de renderizado del lado del servidor de la biblioteca permite que sus PDF se muestren de forma coherente independientemente del navegador, el sistema operativo o los complementos instalados del usuario. Los usuarios ya no necesitan Adobe Reader, extensiones de navegador ni ningún otro software de terceros para ver archivos PDF dentro de su aplicación . Esta universalidad resulta especialmente valiosa en entornos empresariales donde las políticas de TI pueden restringir la instalación de complementos. El renderizador de PDF de Chrome garantiza una precisión de píxeles perfecta al convertir HTML a PDF.

La arquitectura de IronPDF también aporta ventajas significativas para los escenarios de implantación modernos. La biblioteca ofrece soporte multiplataforma confiable y funciona sin problemas en servidores Windows , Linux y macOS . La implementación de contenedores es totalmente compatible, lo que hace que IronPDF sea ideal para aplicaciones que se ejecutan en contenedores Docker o clústeres de Kubernetes. Esta flexibilidad garantiza que la funcionalidad de visualización de PDF funcione de manera consistente en los entornos de desarrollo, preparación y producción en Azure o AWS .

Descripción general de las funciones de IronPDF, que muestra cuatro categorías principales: Crear PDF, Convertir PDF, Editar PDF y Firmar y proteger PDF, con listas detalladas de funciones en cada categoría.

¿Cómo configurar IronPDF para visualización en panel?

Empezar a utilizar IronPDF en su proyecto ASP.NET Core requiere unos sencillos pasos. Primero, abra Visual Studio y vaya al Explorador de soluciones. Haga clic derecho en su proyecto y seleccione "Administrar administrador de paquetes NuGet" para instalar el paquete NuGet IronPDF . También puede ejecutar el siguiente código en la consola del gestor de paquetes:

Install-Package IronPdf

Consola del administrador de paquetes que muestra el proceso de instalación del paquete NuGet de IronPdf con múltiples dependencias en proceso de descarga.

Alternativamente, para sus aplicaciones .NET Framework o .NET Core , puede usar la CLI de .NET para descargar el paquete:

dotnet add package IronPdf

Una vez instalado, agregue la declaración using necesaria a su controlador o clases de servicio para acceder al espacio de nombres IronPDF :

using IronPdf;
using System;
using System.Web;

using IronPdf;
using System;
using System.Web;

Imports IronPdf
Imports System
Imports System.Web

Para obtener una funcionalidad óptima de visualización del panel para ver archivos PDF , configure su aplicación ASP.NET MVC o Core para manejar el contenido PDF correctamente. En el archivo Program.cs, asegúrese de que su aplicación web pueda servir archivos estáticos y manejar los tipos MIME adecuados. Este código fuente muestra la configuración básica:

var builder = WebApplication.CreateBuilder(args);
// Add services to the container
builder.Services.AddControllersWithViews();
builder.Services.AddRazorPages();
var app = builder.Build();
// Configure the HTTP request pipeline
app.UseStaticFiles();
app.UseRouting();
app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}");
app.Run();

var builder = WebApplication.CreateBuilder(args);
// Add services to the container
builder.Services.AddControllersWithViews();
builder.Services.AddRazorPages();
var app = builder.Build();
// Configure the HTTP request pipeline
app.UseStaticFiles();
app.UseRouting();
app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}");
app.Run();

Imports Microsoft.AspNetCore.Builder
Imports Microsoft.Extensions.DependencyInjection

Dim builder = WebApplication.CreateBuilder(args)
' Add services to the container
builder.Services.AddControllersWithViews()
builder.Services.AddRazorPages()

Dim app = builder.Build()
' Configure the HTTP request pipeline
app.UseStaticFiles()
app.UseRouting()
app.MapControllerRoute(
    name:="default",
    pattern:="{controller=Home}/{action=Index}/{id?}")

app.Run()

Esta configuración establece la base para servir contenido PDF a través de su aplicación ASP.NET Core. El registro del servicio AddControllersWithViews() garantiza que su aplicación pueda manejar tanto los puntos finales de API como la representación de vistas, algo esencial para mostrar archivos PDF dentro de los controles del panel . La configuración de enrutamiento le permite crear puntos finales específicos para la generación y visualización de PDF , proporcionando URL limpias para sus PDF integrados en el panel. Para obtener opciones de configuración más avanzadas, consulte nuestra documentación API completa.

¿Cómo mostrar un archivo PDF directamente en paneles ASP.NET?

Para visualizar archivos PDF dentro de los paneles ASP.NET Core es necesario crear una acción de controlador que genere o recupere contenido PDF y lo transmita directamente al navegador. Aquí se muestra una implementación completa que demuestra la funcionalidad principal para representar páginas PDF en paneles ASP.NET. Este fragmento de código muestra la solución completa:

[ApiController]
[Route("api/[controller]")]
public class PdfPanelController : ControllerBase
{
    [HttpGet("display/{documentId}")]
    public IActionResult DisplayPdfInPanel(string documentId, object sender, EventArgs e)
    {
        // Create a new Chrome PDF renderer instance
        var renderer = new ChromePdfRenderer();
        // Generate a PDF file from HTML string
        string filename = $"document_{documentId}.pdf";
        var htmlContent = $@"
            <html>
            <head>
                <style>
                    body {{ font-family: Arial, sans-serif; margin: 40px; }}
                    h1 {{ color: #333; }}
                    .content {{ line-height: 1.6; }}
                </style>
            </head>
            <body>
                <h1>Document #{documentId}</h1>
                <div class='content'>
                    <p>This generated PDF file is dynamically created and displayed directly in your panel.</p>
                    <p>Current page generated at: {DateTime.Now:yyyy-MM-dd HH:mm:ss}</p>
                </div>
            </body>
            </html>";
        // Render the HTML string as a PDF document
        using var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);
        // Convert to byte array for streaming
        byte[] pdfBytes = pdfDocument.BinaryData;
        // Set HTTP header for content disposition
        Response.Headers.Add("Content-Disposition", $"inline; filename={filename}");
        return File(pdfBytes, "application/pdf");
    }
}

[ApiController]
[Route("api/[controller]")]
public class PdfPanelController : ControllerBase
{
    [HttpGet("display/{documentId}")]
    public IActionResult DisplayPdfInPanel(string documentId, object sender, EventArgs e)
    {
        // Create a new Chrome PDF renderer instance
        var renderer = new ChromePdfRenderer();
        // Generate a PDF file from HTML string
        string filename = $"document_{documentId}.pdf";
        var htmlContent = $@"
            <html>
            <head>
                <style>
                    body {{ font-family: Arial, sans-serif; margin: 40px; }}
                    h1 {{ color: #333; }}
                    .content {{ line-height: 1.6; }}
                </style>
            </head>
            <body>
                <h1>Document #{documentId}</h1>
                <div class='content'>
                    <p>This generated PDF file is dynamically created and displayed directly in your panel.</p>
                    <p>Current page generated at: {DateTime.Now:yyyy-MM-dd HH:mm:ss}</p>
                </div>
            </body>
            </html>";
        // Render the HTML string as a PDF document
        using var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);
        // Convert to byte array for streaming
        byte[] pdfBytes = pdfDocument.BinaryData;
        // Set HTTP header for content disposition
        Response.Headers.Add("Content-Disposition", $"inline; filename={filename}");
        return File(pdfBytes, "application/pdf");
    }
}

Imports Microsoft.AspNetCore.Mvc
Imports System

<ApiController>
<Route("api/[controller]")>
Public Class PdfPanelController
    Inherits ControllerBase

    <HttpGet("display/{documentId}")>
    Public Function DisplayPdfInPanel(documentId As String, sender As Object, e As EventArgs) As IActionResult
        ' Create a new Chrome PDF renderer instance
        Dim renderer As New ChromePdfRenderer()
        ' Generate a PDF file from HTML string
        Dim filename As String = $"document_{documentId}.pdf"
        Dim htmlContent As String = $"
            <html>
            <head>
                <style>
                    body {{ font-family: Arial, sans-serif; margin: 40px; }}
                    h1 {{ color: #333; }}
                    .content {{ line-height: 1.6; }}
                </style>
            </head>
            <body>
                <h1>Document #{documentId}</h1>
                <div class='content'>
                    <p>This generated PDF file is dynamically created and displayed directly in your panel.</p>
                    <p>Current page generated at: {DateTime.Now:yyyy-MM-dd HH:mm:ss}</p>
                </div>
            </body>
            </html>"
        ' Render the HTML string as a PDF document
        Using pdfDocument = renderer.RenderHtmlAsPdf(htmlContent)
            ' Convert to byte array for streaming
            Dim pdfBytes As Byte() = pdfDocument.BinaryData
            ' Set HTTP header for content disposition
            Response.Headers.Add("Content-Disposition", $"inline; filename={filename}")
            Return File(pdfBytes, "application/pdf")
        End Using
    End Function
End Class

El código anterior demuestra varios conceptos clave para mostrar archivos PDF en paneles. La clase ChromePdfRenderer actúa como motor de renderizado principal de IronPDF en el lado del servidor, utilizando internamente un navegador Chrome sin cabeza para garantizar una conversión precisa de HTML a PDF . Puede generar dinámicamente contenido HTML basado en los datos de su aplicación, lo que le permitirá crear documentos PDF personalizados sobre la marcha que se muestran perfectamente en los paneles ASP.NET.

El método RenderHtmlAsPdf maneja el proceso de conversión, transformando su HTML en un documento PDF completamente formateado. Este método conserva el estilo CSS , lo que garantiza que sus archivos PDF mantengan el diseño visual que especifique al renderizar en paneles. El objeto PdfDocument resultante proporciona acceso a los datos binarios del archivo PDF a través de la propiedad BinaryData. Para estructuras HTML más complejas, también puedes utilizar plantillas y opciones de estilo .

La configuración de la respuesta resulta crucial para la correcta visualización del panel en aplicaciones ASP.NET. Establecer el encabezado HTTP Content-Disposition en "en línea" le indica al navegador que muestre el PDF directamente en lugar de solicitar la descarga. Esto permite una incrustación fluida dentro de los controles del panel, creando una experiencia de usuario fluida al visualizar documentos PDF en aplicaciones web ASP.NET. También puedes agregar encabezados y pies de página para mejorar tus PDF.

Para mostrar archivos PDF en el panel de vista de Razor , cree una estructura de panel simple con soporte para el atributo de servidor runat:

@page
@model IndexModel
<div class="container mt-4">
    <div class="card">
        <div class="card-header">
            <h3>PDF Display Panel</h3>
        </div>
        <div class="card-body">
            <div class="pdf-panel" style="height: 600px;">
                <iframe src="/api/PdfPanel/display/12345"
                        width="100%"
                        height="100%"
                        frameborder="0"
                        runat="server">
                </iframe>
            </div>
        </div>
    </div>
</div>

@page
@model IndexModel
<div class="container mt-4">
    <div class="card">
        <div class="card-header">
            <h3>PDF Display Panel</h3>
        </div>
        <div class="card-body">
            <div class="pdf-panel" style="height: 600px;">
                <iframe src="/api/PdfPanel/display/12345"
                        width="100%"
                        height="100%"
                        frameborder="0"
                        runat="server">
                </iframe>
            </div>
        </div>
    </div>
</div>

The provided code is a Razor page markup, which is not directly translatable to VB.NET as it is not C# code. Razor pages are used in ASP.NET Core for building web applications and are typically written in a combination of HTML and C#.

If you have any C# code-behind logic or specific C# code within this Razor page that you need converted to VB.NET, please provide that code, and I can assist with the conversion.

Esta estructura HTML crea un panel responsivo que contiene un iframe que apunta a su punto final PDF. El iframe muestra el archivo PDF generado por el servidor sin necesidad de ninguna biblioteca o complemento de visualización de PDF del lado del cliente. El panel se ajusta automáticamente a los diferentes tamaños de pantalla manteniendo la legibilidad de las páginas PDF, lo que lo hace ideal para mostrar archivos PDF en aplicaciones ASP.NET Core. Para obtener opciones de personalización adicionales, explore nuestra documentación de configuración de renderizado . También puede implementar márgenes personalizados para un mejor control sobre el diseño.

¿Cómo integrar un documento PDF con paneles dinámicos?

Las actualizaciones dinámicas de paneles y las ventanas emergentes modales requieren un enfoque más sofisticado de la integración de PDF. Según la documentación de ASP.NET Core de Microsoft , los patrones asincrónicos son esenciales para mantener interfaces receptivas. A continuación se explica cómo implementar la carga de PDF basada en AJAX para interfaces de usuario con capacidad de respuesta que muestren archivos PDF en paneles con una gestión de errores adecuada:

[HttpPost("generate")]
public async Task<IActionResult> GenerateDynamicPdf([FromBody] PdfRequestModel request)
{
    try
    {
        var renderer = new ChromePdfRenderer();
        // Configure rendering options for optimal display
        renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;
        renderer.RenderingOptions.MarginTop = 20;
        renderer.RenderingOptions.MarginBottom = 20;
        renderer.RenderingOptions.MarginLeft = 20;
        renderer.RenderingOptions.MarginRight = 20;
        // Build HTML string from request data
        var htmlBuilder = new StringBuilder();
        htmlBuilder.Append("<html><body>");
        htmlBuilder.Append($"<h2>{request.Title}</h2>");
        htmlBuilder.Append($"<div>{request.Content}</div>");
        // Add any dynamic data tables or charts
        if (request.IncludeData)
        {
            htmlBuilder.Append("<table border='1' style='width:100%;'>");
            foreach (var item in request.DataItems)
            {
                htmlBuilder.Append($"<tr><td>{item.Key}</td><td>{item.Value}</td></tr>");
            }
            htmlBuilder.Append("</table>");
        }
        htmlBuilder.Append("</body></html>");
        // Generate the PDF file asynchronously
        var pdfDocument = await Task.Run(() =>
            renderer.RenderHtmlAsPdf(htmlBuilder.ToString())
        );
        // Return PDF as base64 string for JavaScript handling
        byte[] byteArray = pdfDocument.BinaryData;
        var base64Pdf = Convert.ToBase64String(byteArray);
        return Ok(new { success = true, pdfData = base64Pdf });
    }
    catch (Exception ex)
    {
        return BadRequest(new { success = false, error = ex.Message });
    }
}

[HttpPost("generate")]
public async Task<IActionResult> GenerateDynamicPdf([FromBody] PdfRequestModel request)
{
    try
    {
        var renderer = new ChromePdfRenderer();
        // Configure rendering options for optimal display
        renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;
        renderer.RenderingOptions.MarginTop = 20;
        renderer.RenderingOptions.MarginBottom = 20;
        renderer.RenderingOptions.MarginLeft = 20;
        renderer.RenderingOptions.MarginRight = 20;
        // Build HTML string from request data
        var htmlBuilder = new StringBuilder();
        htmlBuilder.Append("<html><body>");
        htmlBuilder.Append($"<h2>{request.Title}</h2>");
        htmlBuilder.Append($"<div>{request.Content}</div>");
        // Add any dynamic data tables or charts
        if (request.IncludeData)
        {
            htmlBuilder.Append("<table border='1' style='width:100%;'>");
            foreach (var item in request.DataItems)
            {
                htmlBuilder.Append($"<tr><td>{item.Key}</td><td>{item.Value}</td></tr>");
            }
            htmlBuilder.Append("</table>");
        }
        htmlBuilder.Append("</body></html>");
        // Generate the PDF file asynchronously
        var pdfDocument = await Task.Run(() =>
            renderer.RenderHtmlAsPdf(htmlBuilder.ToString())
        );
        // Return PDF as base64 string for JavaScript handling
        byte[] byteArray = pdfDocument.BinaryData;
        var base64Pdf = Convert.ToBase64String(byteArray);
        return Ok(new { success = true, pdfData = base64Pdf });
    }
    catch (Exception ex)
    {
        return BadRequest(new { success = false, error = ex.Message });
    }
}

Imports System.Text
Imports System.Threading.Tasks
Imports Microsoft.AspNetCore.Mvc

<HttpPost("generate")>
Public Async Function GenerateDynamicPdf(<FromBody> request As PdfRequestModel) As Task(Of IActionResult)
    Try
        Dim renderer As New ChromePdfRenderer()
        ' Configure rendering options for optimal display
        renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4
        renderer.RenderingOptions.MarginTop = 20
        renderer.RenderingOptions.MarginBottom = 20
        renderer.RenderingOptions.MarginLeft = 20
        renderer.RenderingOptions.MarginRight = 20
        ' Build HTML string from request data
        Dim htmlBuilder As New StringBuilder()
        htmlBuilder.Append("<html><body>")
        htmlBuilder.Append($"<h2>{request.Title}</h2>")
        htmlBuilder.Append($"<div>{request.Content}</div>")
        ' Add any dynamic data tables or charts
        If request.IncludeData Then
            htmlBuilder.Append("<table border='1' style='width:100%;'>")
            For Each item In request.DataItems
                htmlBuilder.Append($"<tr><td>{item.Key}</td><td>{item.Value}</td></tr>")
            Next
            htmlBuilder.Append("</table>")
        End If
        htmlBuilder.Append("</body></html>")
        ' Generate the PDF file asynchronously
        Dim pdfDocument = Await Task.Run(Function() renderer.RenderHtmlAsPdf(htmlBuilder.ToString()))
        ' Return PDF as base64 string for JavaScript handling
        Dim byteArray As Byte() = pdfDocument.BinaryData
        Dim base64Pdf = Convert.ToBase64String(byteArray)
        Return Ok(New With {.success = True, .pdfData = base64Pdf})
    Catch ex As Exception
        Return BadRequest(New With {.success = False, .error = ex.Message})
    End Try
End Function

Este enfoque asíncrono permite la generación no bloqueante de PDF, esencial para mantener interfaces de usuario receptivas al renderizar PDF en paneles ASP.NET. La propiedad RenderingOptions proporciona un control detallado sobre el diseño del PDF, incluido el tamaño del papel , los márgenes y la orientación . Estos ajustes garantizan que sus PDF se muestren de forma óptima dentro de las limitaciones del panel. Para escenarios avanzados, también puede agregar encabezados y pies de página a sus PDF generados dinámicamente.

El método acepta un modelo de solicitud que contiene datos dinámicos, demostrando cómo crear PDF a partir de la entrada del usuario o del contenido de una base de datos. El proceso de construcción HTML muestra cómo incorporar tablas , listas y otros datos estructurados en sus PDF mediante programación, lo que lo hace perfecto para mostrar PDF controlados por datos en paneles ASP.NET Core. IronPDF también admite la representación de JavaScript y CSS para contenido dinámico más complejo.

¿Cómo manejar diferentes fuentes de PDF?

IronPDF se destaca en la generación de archivos PDF desde diversas fuentes, cada uno adecuado para diferentes escenarios en la visualización del panel. Exploremos los principales enfoques para crear y cargar documentos PDF:

[HttpGet("from-html")]
 public IActionResult GenerateFromHtmlString(string reportType)
 {
     var renderer = new ChromePdfRenderer();
     // Load HTML template from your application
     var htmlTemplate = GetHtmlTemplate(reportType);
     // Safely get the user name, fallback to "Unknown" if null
     var userName = User?.Identity?.Name ?? "Unknown";
     // Inject dynamic data into HTML string
     var processedHtml = htmlTemplate
         .Replace("{{DATE}}", DateTime.Now.ToString("yyyy-MM-dd"))
         .Replace("{{USER}}", userName)
         .Replace("{{REPORT_TYPE}}", reportType);
     // Render with custom CSS for specific page formatting
     renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;
     var PDF = renderer.RenderHtmlAsPdf(processedHtml);
     // Save the generated PDF file
     string path = $"{reportType}.pdf";
     var webRootPath = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot");
     var fullPath = Path.Combine(webRootPath, path.TrimStart('/').Replace('/', Path.DirectorySeparatorChar));
     pdf.SaveAs(fullPath);
     return File(pdf.BinaryData, "application/pdf");
 }
 // Add this private method inside the PdfPanel class to resolve CS0103
 private string GetHtmlTemplate(string reportType)
 {
     // Example: return a simple HTML template with placeholders
     return @"
         <html>
         <head>
             <title>{{REPORT_TYPE}} Report</title>
         </head>
         <body>
             <h1>{{REPORT_TYPE}} Report</h1>
             <p>Date: {{DATE}}</p>
             <p>User: {{USER}}</p>
             <div>Report content goes here.</div>
         </body>
         </html>";
 }

[HttpGet("from-html")]
 public IActionResult GenerateFromHtmlString(string reportType)
 {
     var renderer = new ChromePdfRenderer();
     // Load HTML template from your application
     var htmlTemplate = GetHtmlTemplate(reportType);
     // Safely get the user name, fallback to "Unknown" if null
     var userName = User?.Identity?.Name ?? "Unknown";
     // Inject dynamic data into HTML string
     var processedHtml = htmlTemplate
         .Replace("{{DATE}}", DateTime.Now.ToString("yyyy-MM-dd"))
         .Replace("{{USER}}", userName)
         .Replace("{{REPORT_TYPE}}", reportType);
     // Render with custom CSS for specific page formatting
     renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;
     var PDF = renderer.RenderHtmlAsPdf(processedHtml);
     // Save the generated PDF file
     string path = $"{reportType}.pdf";
     var webRootPath = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot");
     var fullPath = Path.Combine(webRootPath, path.TrimStart('/').Replace('/', Path.DirectorySeparatorChar));
     pdf.SaveAs(fullPath);
     return File(pdf.BinaryData, "application/pdf");
 }
 // Add this private method inside the PdfPanel class to resolve CS0103
 private string GetHtmlTemplate(string reportType)
 {
     // Example: return a simple HTML template with placeholders
     return @"
         <html>
         <head>
             <title>{{REPORT_TYPE}} Report</title>
         </head>
         <body>
             <h1>{{REPORT_TYPE}} Report</h1>
             <p>Date: {{DATE}}</p>
             <p>User: {{USER}}</p>
             <div>Report content goes here.</div>
         </body>
         </html>";
 }

Imports System
Imports System.IO
Imports Microsoft.AspNetCore.Mvc
Imports IronPdf

<HttpGet("from-html")>
Public Function GenerateFromHtmlString(reportType As String) As IActionResult
    Dim renderer As New ChromePdfRenderer()
    ' Load HTML template from your application
    Dim htmlTemplate As String = GetHtmlTemplate(reportType)
    ' Safely get the user name, fallback to "Unknown" if null
    Dim userName As String = If(User?.Identity?.Name, "Unknown")
    ' Inject dynamic data into HTML string
    Dim processedHtml As String = htmlTemplate _
        .Replace("{{DATE}}", DateTime.Now.ToString("yyyy-MM-dd")) _
        .Replace("{{USER}}", userName) _
        .Replace("{{REPORT_TYPE}}", reportType)
    ' Render with custom CSS for specific page formatting
    renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print
    Dim pdf = renderer.RenderHtmlAsPdf(processedHtml)
    ' Save the generated PDF file
    Dim path As String = $"{reportType}.pdf"
    Dim webRootPath As String = Path.Combine(Directory.GetCurrentDirectory(), "wwwroot")
    Dim fullPath As String = Path.Combine(webRootPath, path.TrimStart("/"c).Replace("/"c, Path.DirectorySeparatorChar))
    pdf.SaveAs(fullPath)
    Return File(pdf.BinaryData, "application/pdf")
End Function

' Add this private method inside the PdfPanel class to resolve CS0103
Private Function GetHtmlTemplate(reportType As String) As String
    ' Example: return a simple HTML template with placeholders
    Return "
        <html>
        <head>
            <title>{{REPORT_TYPE}} Report</title>
        </head>
        <body>
            <h1>{{REPORT_TYPE}} Report</h1>
            <p>Date: {{DATE}}</p>
            <p>User: {{USER}}</p>
            <div>Report content goes here.</div>
        </body>
        </html>"
End Function

[HttpGet("from-url")]
public async Task<IActionResult> GenerateFromUrl(string encodedUrl)
{
    var url = HttpUtility.UrlDecode(encodedUrl);
    var renderer = new ChromePdfRenderer();
    // Configure for web page capture to display PDF pages
    renderer.RenderingOptions.ViewPortWidth = 1920;
    renderer.RenderingOptions.ViewPortHeight = 1080;
    renderer.RenderingOptions.EnableJavaScript = true;
    renderer.RenderingOptions.WaitFor.RenderDelay(2000); // Wait for JS execution
    // Generate PDF from URL
    var PDF = await renderer.RenderUrlAsPdfAsync(url);
    // Return the generated PDF file
    string filename = "webpage.pdf";
    Response.Headers.Append("Content-Disposition", $"inline; filename={filename}");
    return File(pdf.BinaryData, "application/pdf");
}

[HttpGet("from-url")]
public async Task<IActionResult> GenerateFromUrl(string encodedUrl)
{
    var url = HttpUtility.UrlDecode(encodedUrl);
    var renderer = new ChromePdfRenderer();
    // Configure for web page capture to display PDF pages
    renderer.RenderingOptions.ViewPortWidth = 1920;
    renderer.RenderingOptions.ViewPortHeight = 1080;
    renderer.RenderingOptions.EnableJavaScript = true;
    renderer.RenderingOptions.WaitFor.RenderDelay(2000); // Wait for JS execution
    // Generate PDF from URL
    var PDF = await renderer.RenderUrlAsPdfAsync(url);
    // Return the generated PDF file
    string filename = "webpage.pdf";
    Response.Headers.Append("Content-Disposition", $"inline; filename={filename}");
    return File(pdf.BinaryData, "application/pdf");
}

Imports System.Web
Imports Microsoft.AspNetCore.Mvc

<HttpGet("from-url")>
Public Async Function GenerateFromUrl(encodedUrl As String) As Task(Of IActionResult)
    Dim url = HttpUtility.UrlDecode(encodedUrl)
    Dim renderer = New ChromePdfRenderer()
    ' Configure for web page capture to display PDF pages
    renderer.RenderingOptions.ViewPortWidth = 1920
    renderer.RenderingOptions.ViewPortHeight = 1080
    renderer.RenderingOptions.EnableJavaScript = True
    renderer.RenderingOptions.WaitFor.RenderDelay(2000) ' Wait for JS execution
    ' Generate PDF from URL
    Dim pdf = Await renderer.RenderUrlAsPdfAsync(url)
    ' Return the generated PDF file
    Dim filename As String = "webpage.pdf"
    Response.Headers.Append("Content-Disposition", $"inline; filename={filename}")
    Return File(pdf.BinaryData, "application/pdf")
End Function

public IActionResult OptimizedPdfGeneration()
{
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.CreatePdfFormsFromHtml = false;
    var htmlTemplate = GetHtmlTemplate("improve");
    var processedHtml = htmlTemplate
       .Replace("{{DATE}}", DateTime.Now.ToString("yyyy-MM-dd"))
       .Replace("{{USER}}", "Test")
       .Replace("{{REPORT_TYPE}}", "Improve");
    // Create the PDF document
    using (var PDF = renderer.RenderHtmlAsPdf(processedHtml))
    {
        // Process and return immediately
        byte[] byteArray = pdf.BinaryData;
        pdf.SaveAs("output.pdf");
        return File(byteArray, "application/pdf");
    }
}

public IActionResult OptimizedPdfGeneration()
{
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.CreatePdfFormsFromHtml = false;
    var htmlTemplate = GetHtmlTemplate("improve");
    var processedHtml = htmlTemplate
       .Replace("{{DATE}}", DateTime.Now.ToString("yyyy-MM-dd"))
       .Replace("{{USER}}", "Test")
       .Replace("{{REPORT_TYPE}}", "Improve");
    // Create the PDF document
    using (var PDF = renderer.RenderHtmlAsPdf(processedHtml))
    {
        // Process and return immediately
        byte[] byteArray = pdf.BinaryData;
        pdf.SaveAs("output.pdf");
        return File(byteArray, "application/pdf");
    }
}

Public Function OptimizedPdfGeneration() As IActionResult
    Dim renderer = New ChromePdfRenderer()
    renderer.RenderingOptions.CreatePdfFormsFromHtml = False
    Dim htmlTemplate = GetHtmlTemplate("improve")
    Dim processedHtml = htmlTemplate _
        .Replace("{{DATE}}", DateTime.Now.ToString("yyyy-MM-dd")) _
        .Replace("{{USER}}", "Test") _
        .Replace("{{REPORT_TYPE}}", "Improve")
    ' Create the PDF document
    Using PDF = renderer.RenderHtmlAsPdf(processedHtml)
        ' Process and return immediately
        Dim byteArray As Byte() = PDF.BinaryData
        PDF.SaveAs("output.pdf")
        Return File(byteArray, "application/pdf")
    End Using
End Function

¿Por qué elegir IronPDF para sus necesidades de visualización de PDF?

IronPDF simplifica la compleja tarea de mostrar archivos PDF en controles de panel ASP.NET en una solución sencilla y fácil de mantener. Al utilizar la representación del lado del servidor y una integración fluida con la arquitectura de ASP.NET Core, puede crear una funcionalidad de visualización de PDF confiable sin dependencias del lado del cliente ni preocupaciones de compatibilidad del navegador. La capacidad de generar , renderizar y mostrar documentos PDF directamente dentro de los paneles hace de IronPDF la opción ideal para las aplicaciones web modernas. Con soporte para varias versiones de PDF y conformidad con PDF/A , IronPDF garantiza que sus documentos cumplan con los estándares de la industria.

Inicie su prueba gratuita hoy para experimentar cómo IronPDF simplifica el manejo de PDF en sus aplicaciones ASP.NET. No se requiere tarjeta de crédito para empezar. Para implementaciones de producción, explore nuestras flexibles opciones de licencia que se adaptan a sus necesidades. Ya sea que necesite convertir HTML a PDF , editar PDF existentes o implementar funciones de seguridad , IronPDF proporciona las herramientas completas que necesita para la gestión profesional de PDF.

Página de licencias de IronPDF con niveles de precios para licencias de equipo, desde Lite ($749) hasta Unlimited ($3,999), con límites de desarrollador, ubicación y proyecto.