Saltar al pie de página
  1. IronPDF
  2. Blog de IronPDF
  3. Uso de IronPDF
  4. Crear PDF sobre la marcha con ASP
USANDO IRONPDF

ASP Crear PDF sobre la marcha: Generación dinámica de PDF en .NET Core

Curtis Chau
Curtis Chau
Actualizado:

Cuando se crean aplicaciones web modernas en ASP.NET Core, la capacidad de generar documentos PDF de forma dinámica es esencial. Tanto si se trata de crear facturas, informes o certificados, los usuarios esperan una generación instantánea de archivos PDF sin almacenamiento en el servidor. La potente biblioteca PDF de IronPDF simplifica la creación de archivos PDF sobre la marcha directamente en sus proyectos .NET Core.

En este artículo, le guiaremos a través de los pasos necesarios para empezar a crear fácilmente documentos PDF sobre la marcha en sus aplicaciones ASP.NET.

¿Qué significa crear archivos PDF sobre la marcha?

Crear PDF sobre la marcha significa generar documentos PDF dinámicamente en memoria y transmitirlos directamente al navegador del usuario. Este proceso del lado del servidor elimina la necesidad de guardar archivos PDF en el disco, lo que mejora tanto el rendimiento como la seguridad. Con el SDK de IronPDF, puede transformar contenido HTML en documentos PDF profesionales al instante, perfecto para aplicaciones web que necesitan crear PDF sin almacenar archivos en el servidor.

Empiece con IronPDF ahora.
green arrow pointer

¿Cómo configurar IronPDF para la generación dinámica de archivos PDF?

En primer lugar, instale IronPDF a través de NuGet Package Manager para añadir esta potente biblioteca PDF a su proyecto ASP.NET Core:

Install-Package IronPdf

A continuación, configure IronPDF en su aplicación ASP.NET Core para crear archivos PDF de forma dinámica:

using IronPdf;
using Microsoft.AspNetCore.Mvc;

namespace PdfGenerator.Controllers
{
    public class DocumentController : Controller
    {
        private readonly ChromePdfRenderer _renderer;

        public DocumentController()
        {
            // Initialize the renderer once for reuse
            _renderer = new ChromePdfRenderer();
            // Optional: Set your license key
            License.LicenseKey = "YOUR-LICENSE-KEY";
        }
    }
}
using IronPdf;
using Microsoft.AspNetCore.Mvc;

namespace PdfGenerator.Controllers
{
    public class DocumentController : Controller
    {
        private readonly ChromePdfRenderer _renderer;

        public DocumentController()
        {
            // Initialize the renderer once for reuse
            _renderer = new ChromePdfRenderer();
            // Optional: Set your license key
            License.LicenseKey = "YOUR-LICENSE-KEY";
        }
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Esta configuración inicializa el ChromePdfRenderer, el potente motor de renderizado de IronPDF que convierte documentos HTML a PDF utilizando Chromium. Al crear una única instancia de renderizador, se optimiza el uso de memoria cuando se crean PDF repetidamente. Más información sobre Conversión de HTML a PDF para técnicas avanzadas.

¿Cómo crear documentos PDF a partir de contenido HTML?

La función principal para crear archivos PDF consiste en convertir cadenas HTML en documentos PDF. Aquí tienes un ejemplo completo que muestra cómo generar una factura sobre la marcha:

[HttpGet]
public IActionResult GenerateInvoice(int orderId)
{
    // Fetch data from your database or service
    var orderData = GetOrderData(orderId);
    // Build HTML content with dynamic data
    string htmlContent = $@"
        <!DOCTYPE html>
        <html>
        <head>
            <style>
                body {{ font-family: Arial, sans-serif; }}
                .header {{ background-color: #f0f0f0; padding: 20px; }}
                table {{ width: 100%; border-collapse: collapse; }}
                td, th {{ padding: 10px; border: 1px solid #ddd; }}
            </style>
        </head>
        <body>
            <div class='header'>
                <h1>Invoice #{orderData.InvoiceNumber}</h1>
                <p>Date: {DateTime.Now:yyyy-MM-dd}</p>
            </div>
            <table>
                <tr>
                    <th>Item</th>
                    <th>Quantity</th>
                    <th>Price</th>
                </tr>";
    foreach(var item in orderData.Items)
    {
        htmlContent += $@"
                <tr>
                    <td>{item.Name}</td>
                    <td>{item.Quantity}</td>
                    <td>${item.Price:F2}</td>
                </tr>";
    }
    htmlContent += @"
            </table>
        </body>
        </html>";
    // Create PDF from HTML
    var pdf = _renderer.RenderHtmlAsPdf(htmlContent);
    // Convert to byte array for streaming
    byte[] pdfBytes = pdf.BinaryData;
    // Return PDF to browser
    return File(pdfBytes, "application/pdf", $"invoice_{orderId}.pdf");
}
[HttpGet]
public IActionResult GenerateInvoice(int orderId)
{
    // Fetch data from your database or service
    var orderData = GetOrderData(orderId);
    // Build HTML content with dynamic data
    string htmlContent = $@"
        <!DOCTYPE html>
        <html>
        <head>
            <style>
                body {{ font-family: Arial, sans-serif; }}
                .header {{ background-color: #f0f0f0; padding: 20px; }}
                table {{ width: 100%; border-collapse: collapse; }}
                td, th {{ padding: 10px; border: 1px solid #ddd; }}
            </style>
        </head>
        <body>
            <div class='header'>
                <h1>Invoice #{orderData.InvoiceNumber}</h1>
                <p>Date: {DateTime.Now:yyyy-MM-dd}</p>
            </div>
            <table>
                <tr>
                    <th>Item</th>
                    <th>Quantity</th>
                    <th>Price</th>
                </tr>";
    foreach(var item in orderData.Items)
    {
        htmlContent += $@"
                <tr>
                    <td>{item.Name}</td>
                    <td>{item.Quantity}</td>
                    <td>${item.Price:F2}</td>
                </tr>";
    }
    htmlContent += @"
            </table>
        </body>
        </html>";
    // Create PDF from HTML
    var pdf = _renderer.RenderHtmlAsPdf(htmlContent);
    // Convert to byte array for streaming
    byte[] pdfBytes = pdf.BinaryData;
    // Return PDF to browser
    return File(pdfBytes, "application/pdf", $"invoice_{orderId}.pdf");
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Este código demuestra cómo generar archivos PDF dinámicos combinando plantillas de páginas HTML con datos en tiempo real. El método RenderHtmlAsPdf procesa el contenido HTML, incluidos los estilos CSS, y produce un documento profesional listo para descargar. El método admite diseños complejos, imágenes e incluso la ejecución de JavaScript. Puedes ver el resultado en una nueva pestaña.

Ejemplo de resultado

ASP Crear PDF sobre la marcha: Generación dinámica de PDF en .NET Core: Imagen 1 - Ejemplo de PDF generado sobre la marcha con nuestro programa ASP.NET

¿Cómo transmitir archivos PDF directamente a los usuarios sin guardarlos en el disco?

La transmisión de archivos PDF sobre la marcha requiere trabajar con flujos de memoria y matrices de bytes. Este enfoque garantiza que los documentos PDF nunca toquen el sistema de archivos del servidor, lo que es crucial para las implementaciones en la nube y las aplicaciones en contenedores:

[HttpPost]
public async Task<IActionResult> CreateReport([FromBody] ReportRequest request)
{
    // Generate HTML from request data
    string html = BuildReportHtml(request);
    // Create PDF in memory
    var pdfDocument = _renderer.RenderHtmlAsPdf(html);
    // Use MemoryStream for efficient streaming
    using (var memoryStream = new MemoryStream())
    {
        // Write PDF binary data to the memory stream
        memoryStream.Write(pdfDocument.BinaryData, 0, pdfDocument.BinaryData.Length);
        // Set response headers for inline display
        Response.Headers.Add("Content-Disposition", "inline; filename=report.pdf");
        // Return FileContentResult with proper content type
        return new FileContentResult(memoryStream.ToArray(), "application/pdf");
    }
}
[HttpPost]
public async Task<IActionResult> CreateReport([FromBody] ReportRequest request)
{
    // Generate HTML from request data
    string html = BuildReportHtml(request);
    // Create PDF in memory
    var pdfDocument = _renderer.RenderHtmlAsPdf(html);
    // Use MemoryStream for efficient streaming
    using (var memoryStream = new MemoryStream())
    {
        // Write PDF binary data to the memory stream
        memoryStream.Write(pdfDocument.BinaryData, 0, pdfDocument.BinaryData.Length);
        // Set response headers for inline display
        Response.Headers.Add("Content-Disposition", "inline; filename=report.pdf");
        // Return FileContentResult with proper content type
        return new FileContentResult(memoryStream.ToArray(), "application/pdf");
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Ejemplo de documento PDF de salida

ASP Crear PDF sobre la marcha: Dynamic PDF Generation in .NET Core: Image 2 - PDF created using Byte arrays and streams (en inglés)

El enfoque de matriz de bytes permite crear PDF totalmente en memoria. El tipo de contenido "application/pdf" indica al navegador cómo manejar el archivo, mientras que la cabecera Content-Disposition determina si el archivo PDF se abre en el navegador o activa una descarga. Para obtener más información sobre Conversión de PDF a MemoryStream, consulte nuestra documentación. Cuando el usuario pulse el botón para enviar la solicitud, el servidor ejecutará este código para continuar el proceso.

Inicie su prueba gratuita e implemente la generación dinámica de PDF hoy mismo

¿Cómo se pueden generar archivos PDF a partir del contenido de bases de datos dinámicas?

Las aplicaciones ASP.NET Core del mundo real a menudo necesitan crear informes PDF a partir de consultas a bases de datos. A continuación se explica cómo generar archivos PDF utilizando datos de Entity Framework Core con un tratamiento adecuado de los errores:

[HttpGet("report/monthly")]
public async Task<IActionResult> MonthlyReport(int year, int month)
{
    // Query database for report data
    var reportData = await _context.Transactions
        .Where(t => t.Date.Year == year && t.Date.Month == month)
        .GroupBy(t => t.Category)
        .Select(g => new {
            Category = g.Key,
            Total = g.Sum(t => t.Amount),
            Count = g.Count()
        })
        .ToListAsync();
    // Build HTML template with style
    var htmlTemplate = @"<h2>Monthly Report</h2>
                         <table style='width:100%'>";
    foreach(var item in reportData)
    {
        htmlTemplate += $"<tr><td>{item.Category}</td>" +
                       $"<td>{item.Count} items</td>" +
                       $"<td>${item.Total:F2}</td></tr>";
    }
    htmlTemplate += "</table>";
    // Generate PDF document with settings
    var pdf = _renderer.RenderHtmlAsPdf(htmlTemplate);
    // Add metadata to PDF
    pdf.MetaData.Title = $"Report {month}/{year}";
    pdf.MetaData.Author = "Reporting System";
    // Stream PDF to user
    return File(pdf.BinaryData, "application/pdf");
}
[HttpGet("report/monthly")]
public async Task<IActionResult> MonthlyReport(int year, int month)
{
    // Query database for report data
    var reportData = await _context.Transactions
        .Where(t => t.Date.Year == year && t.Date.Month == month)
        .GroupBy(t => t.Category)
        .Select(g => new {
            Category = g.Key,
            Total = g.Sum(t => t.Amount),
            Count = g.Count()
        })
        .ToListAsync();
    // Build HTML template with style
    var htmlTemplate = @"<h2>Monthly Report</h2>
                         <table style='width:100%'>";
    foreach(var item in reportData)
    {
        htmlTemplate += $"<tr><td>{item.Category}</td>" +
                       $"<td>{item.Count} items</td>" +
                       $"<td>${item.Total:F2}</td></tr>";
    }
    htmlTemplate += "</table>";
    // Generate PDF document with settings
    var pdf = _renderer.RenderHtmlAsPdf(htmlTemplate);
    // Add metadata to PDF
    pdf.MetaData.Title = $"Report {month}/{year}";
    pdf.MetaData.Author = "Reporting System";
    // Stream PDF to user
    return File(pdf.BinaryData, "application/pdf");
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Este patrón permite crear archivos PDF a partir de cualquier fuente de datos, transformando registros de bases de datos en documentos formateados al instante. El enfoque de plantilla HTML facilita el mantenimiento y la modificación de los diseños de los informes. También puede explorar la creación de PDF a partir de documentos existentes para escenarios más complejos, y encontrar un enlace a un índice de información adicional. Esperamos que este sea un buen ejemplo.

¿Cuáles son las mejores prácticas para la generación de PDF sobre la marcha?

Cuando cree archivos PDF de forma dinámica en ASP.NET Core, tenga en cuenta estas estrategias de optimización:

Operaciones asíncronas: Utilice métodos asíncronos para evitar el bloqueo del grupo de hilos del servidor cuando genere varios PDF:

var pdfTask = _renderer.RenderHtmlAsPdfAsync(htmlContent);
var pdf = await pdfTask;
var pdfTask = _renderer.RenderHtmlAsPdfAsync(htmlContent);
var pdf = await pdfTask;
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Gestión de memoria: Para archivos PDF de gran tamaño, disponga de los recursos adecuadamente y considere la posibilidad de transmitir directamente a la respuesta para minimizar el uso de memoria:

using (var pdf = _renderer.RenderHtmlAsPdf(html))
{
    return File(pdf.Stream, "application/pdf");
}
using (var pdf = _renderer.RenderHtmlAsPdf(html))
{
    return File(pdf.Stream, "application/pdf");
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Reutilización del renderizador: comparta instancias de ChromePdfRenderer entre solicitudes para mejorar el rendimiento cuando genere varios PDF. El renderizador es a prueba de hilos y puede manejar operaciones concurrentes de manera eficiente. También es cierto que reutilizar el renderizador ahorra tiempo. No te pierdas esta optimización.

Según las mejores prácticas de Microsoft ASP.NET Core, minimizar las asignaciones de objetos y reutilizar recursos son claves para las aplicaciones web de alto rendimiento.

NuGet Instalar con NuGet

PM >  Install-Package IronPdf

Echa un vistazo a IronPDF en NuGet para una instalación rápida. Con más de 10 millones de descargas, está transformando el desarrollo de PDF con C#. También puede descargar el DLL o el instalador de Windows.

Conclusión

La creación de documentos PDF sobre la marcha con IronPDF transforma la generación de documentos complejos en código sencillo. Desde facturas sencillas hasta informes complejos, el potente SDK de IronPDF se encarga del trabajo pesado mientras usted se centra en la lógica de su aplicación. La capacidad de generar y transmitir archivos PDF sin guardarlos en el disco hace que sus aplicaciones ASP.NET Core sean más eficaces y seguras. Estamos constantemente incorporando nuevas funciones y puedes inspirarte en todos nuestros ejemplos. Se trata de un DOC oficial para la biblioteca.

Con IronPDF, puede crear archivos PDF a partir de contenido HTML, transmitirlos como matrices de bytes y entregar documentos profesionales a los usuarios al instante. Tanto si está creando un sistema de informes, un generador de facturas o una solución de gestión de documentos, IronPDF le ofrece toda la funcionalidad que necesita para implementar una sólida generación de PDF. También puedes redactar un nuevo mensaje para obtener ayuda. El texto debe ser claro.

¿Listo para transformar su aplicación ASP.NET Core con capacidades PDF dinámicas? Compra una licencia para desbloquear todas las funciones y recibir soporte profesional de nuestro equipo de ingenieros.

Preguntas Frecuentes

¿Cómo puedo generar PDF de forma dinámica en ASP.NET Core?

Puede utilizar IronPDF para generar PDF dinámicamente en ASP.NET Core sin guardar archivos en el disco. Permite transmitir PDF directamente a los navegadores.

¿Cuáles son los beneficios de usar IronPDF para la generación de PDF?

IronPDF proporciona un potente motor de renderizado que permite la creación dinámica de PDF directamente dentro de sus proyectos .NET Core, garantizando la generación instantánea de PDF sin necesidad de almacenamiento en el servidor.

¿Se puede utilizar IronPDF para crear facturas e informes?

Sí, IronPDF es adecuado para crear varios tipos de documentos, como facturas, informes y certificados, todos ellos generados sobre la marcha en aplicaciones ASP.NET Core.

¿Es necesario el almacenamiento en el servidor cuando se utiliza IronPDF?

No, IronPDF permite generar y transmitir archivos PDF directamente a los navegadores sin necesidad de almacenamiento en el servidor, lo que lo hace eficiente y rápido.

¿Qué tipo de aplicaciones pueden beneficiarse de la generación de PDF sobre la marcha?

Las aplicaciones web modernas, en particular las que requieren la creación de documentos en tiempo real, como los sistemas de facturación y las herramientas de generación de informes, pueden beneficiarse enormemente de la generación de PDF sobre la marcha que ofrece IronPDF.

¿Es IronPDF compatible con proyectos .NET Core?

Sí, IronPDF es totalmente compatible con proyectos .NET Core, lo que permite a los desarrolladores integrar capacidades de generación de PDF sin problemas en sus aplicaciones.

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. Comenzar prueba gratuita