Ícono de mensaje
Saltar al pie de página
  1. IronPDF
  2. Blog de IronPDF
  3. Usando IronPDF
  4. Asp Crear PDF sobre la marcha
USANDO IRONPDF

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

Curtis Chau
Curtis Chau
Actualizado:

Cree archivos PDF dinámicamente en ASP.NET Core utilizando IronPDF para convertir contenido HTML en documentos PDF profesionales al instante y transmitirlos directamente a los usuarios sin necesidad de almacenamiento del lado del servidor.

Al crear aplicaciones web modernas en ASP.NET Core , la capacidad de generar documentos PDF de forma dinámica es esencial. Ya sea que esté creando facturas , informes o certificados , los usuarios esperan la generación inmediata de archivos PDF sin almacenamiento del lado del servidor. La eficaz biblioteca de PDF de IronPDF facilita la creación de archivos PDF directamente en sus proyectos .NET Core .

En este artículo, lo guiaremos a través de los pasos para crear documentos PDF en sus aplicaciones ASP.NET , utilizando capacidades de conversión de HTML a PDF y operaciones de flujo de memoria .

¿Qué significa crear archivos PDF sobre la marcha?

Crear archivos PDF sobre la marcha significa generar documentos PDF dinámicamente en la 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. El motor de renderizado de Chrome garantiza una salida con píxeles perfectos que coincide exactamente con su diseño HTML.

Empiece con IronPDF ahora.
green arrow pointer

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

Primero, instale IronPDF a través del Administrador de paquetes NuGet para agregar esta efectiva 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 dinámicamente:

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";
        }
    }
}
$vbLabelText   $csharpLabel

Esta configuración inicializa ChromePdfRenderer , el eficaz motor de renderizado de IronPDF que convierte documentos HTML a PDF usando Chromium. Al crear una única instancia de renderizador, mejora el uso de memoria cuando crea archivos PDF repetidamente. Obtenga más información sobre la conversión de HTML a PDF para técnicas avanzadas, incluida la representación de JavaScript , la compatibilidad con CSS y las fuentes personalizadas . Para configurar la clave de licencia , explore nuestra guía de licencias .

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

La funcionalidad principal para crear archivos PDF implica la conversión de cadenas HTML en documentos PDF. A continuación se muestra 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");
}
$vbLabelText   $csharpLabel

Este código demuestra cómo generar archivos PDF dinámicos combinando plantillas de página 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 ejecución de JavaScript . Puedes ver el resultado en una nueva pestaña. Para obtener funciones más avanzadas, explore tamaños de página personalizados , encabezados y pies de página y marcas de agua .

¿Cómo se ve el PDF de la factura generada?

Factura profesional en PDF que muestra la factura n.° 123, con fecha del 13/11/2025, con encabezado con estilo y una tabla organizada que contiene el producto A (10,99 $) y el producto B (5,49 $), con funciones de generación dinámica de PDF y estilo CSS personalizado.

¿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 cual 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");
    }
}
$vbLabelText   $csharpLabel

¿Cómo funciona la generación de PDF basada en memoria?

Informe PDF generado con el título "Revisión de Rendimiento Mensual" y contenido formateado que muestra la generación de documentos empresariales reales, incluyendo gráficos, métricas y secciones de análisis detallados generados a partir de una plantilla HTML.

El enfoque de matriz de bytes le permite crear archivos PDF completamente en la memoria. El tipo de contenido "application/pdf" le indica al navegador cómo manejar el archivo, mientras que el encabezado 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 presiona el botón para enviar la solicitud, el servidor procesa este código para generar el PDF dinámicamente. Esta técnica es particularmente útil para implementaciones de Azure Functions y AWS Lambda donde el acceso al sistema de archivos puede estar restringido.

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 de 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");
}
$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 archivos PDF a partir de documentos existentes para escenarios más complejos . Para mejorar el formato, considere usar estilos de impresión CSS , márgenes personalizados y saltos de página . Es posible que también desee agregar gráficos o imágenes desde Azure Blob Storage .

¿Cómo manejar escenarios de generación avanzada de PDF?

Para requisitos más complejos, IronPDF ofrece funciones avanzadas para mejorar la generación de PDF sobre la marcha:

[HttpPost("generate/advanced")]
public async Task<IActionResult> GenerateAdvancedPdf([FromBody] AdvancedRequest request)
{
    // Configure rendering options
    _renderer.RenderingOptions = new ChromePdfRenderOptions()
    {
        PaperSize = PdfPaperSize.A4,
        MarginTop = 40,
        MarginBottom = 40,
        MarginLeft = 20,
        MarginRight = 20,
        EnableJavaScript = true,
        WaitFor = new WaitFor()
        {
            RenderDelay = 500 // Wait for JavaScript execution
        }
    };

    // Add headers and footers
    _renderer.RenderingOptions.TextHeader = new TextHeaderFooter()
    {
        CenterText = request.DocumentTitle,
        DrawDividerLine = true,
        FontSize = 12
    };

    _renderer.RenderingOptions.TextFooter = new TextHeaderFooter()
    {
        LeftText = "{date} {time}",
        RightText = "Page {page} of {total-pages}",
        FontSize = 10
    };

    // Generate PDF with custom settings
    var pdf = await _renderer.RenderHtmlAsPdfAsync(request.HtmlContent);

    // Add security if requested
    if (request.RequirePassword)
    {
        pdf.SecuritySettings.OwnerPassword = "admin_password";
        pdf.SecuritySettings.UserPassword = request.UserPassword;
        pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.NoPrint;
        pdf.SecuritySettings.AllowUserCopyPasteContent = false;
    }

    return File(pdf.BinaryData, "application/pdf", $"{request.FileName}.pdf");
}
[HttpPost("generate/advanced")]
public async Task<IActionResult> GenerateAdvancedPdf([FromBody] AdvancedRequest request)
{
    // Configure rendering options
    _renderer.RenderingOptions = new ChromePdfRenderOptions()
    {
        PaperSize = PdfPaperSize.A4,
        MarginTop = 40,
        MarginBottom = 40,
        MarginLeft = 20,
        MarginRight = 20,
        EnableJavaScript = true,
        WaitFor = new WaitFor()
        {
            RenderDelay = 500 // Wait for JavaScript execution
        }
    };

    // Add headers and footers
    _renderer.RenderingOptions.TextHeader = new TextHeaderFooter()
    {
        CenterText = request.DocumentTitle,
        DrawDividerLine = true,
        FontSize = 12
    };

    _renderer.RenderingOptions.TextFooter = new TextHeaderFooter()
    {
        LeftText = "{date} {time}",
        RightText = "Page {page} of {total-pages}",
        FontSize = 10
    };

    // Generate PDF with custom settings
    var pdf = await _renderer.RenderHtmlAsPdfAsync(request.HtmlContent);

    // Add security if requested
    if (request.RequirePassword)
    {
        pdf.SecuritySettings.OwnerPassword = "admin_password";
        pdf.SecuritySettings.UserPassword = request.UserPassword;
        pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.NoPrint;
        pdf.SecuritySettings.AllowUserCopyPasteContent = false;
    }

    return File(pdf.BinaryData, "application/pdf", $"{request.FileName}.pdf");
}
$vbLabelText   $csharpLabel

Este ejemplo demuestra las opciones de representación , numeración de páginas , configuraciones de seguridad y operaciones asincrónicas . También puede implementar firmas digitales , conformidad con PDF/A , compresión y marcas de agua . Para escenarios de múltiples subprocesos , IronPDF proporciona operaciones seguras para subprocesos.

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

Al crear archivos PDF dinámicamente en ASP.NET Core , tenga en cuenta estas estrategias de optimización:

Operaciones asincrónicas: utilice métodos asincrónicos para evitar el bloqueo del grupo de subprocesos del servidor cuando genere varios PDF:

var pdfTask = _renderer.RenderHtmlAsPdfAsync(htmlContent);
var pdf = await pdfTask;
var pdfTask = _renderer.RenderHtmlAsPdfAsync(htmlContent);
var pdf = await pdfTask;
$vbLabelText   $csharpLabel

Administración de memoria: para archivos PDF grandes, deseche los recursos adecuadamente y considere 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");
}
$vbLabelText   $csharpLabel

Reutilización del renderizador: comparta instancias de ChromePdfRenderer entre solicitudes para mejorar el rendimiento cuando genere varios PDF. El renderizador es seguro para subprocesos y maneja operaciones simultáneas de manera eficiente. Reutilizar el renderizador ahorra tiempo de inicialización en cada solicitud. Considere implementar un registro personalizado para supervisar el rendimiento y solucionar problemas.

Según las mejores prácticas de ASP.NET Core de Microsoft , minimizar las asignaciones de objetos y reutilizar recursos son claves para las aplicaciones web de alto rendimiento. Para la implementación, explore nuestras guías para entornos de Azure , AWS , Docker y Linux . También puedes implementar estrategias de almacenamiento en caché para mejorar los tiempos de renderizado .

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.

¿Qué has aprendido sobre la creación de archivos PDF sobre la marcha?

La creación de documentos PDF sobre la marcha con IronPDF transforma la generación de documentos complejos en código sencillo. Desde facturas simples hasta informes complejos, el eficaz SDK de IronPDF se encarga del trabajo pesado mientras usted se concentra 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 eficientes y seguras.

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. Ya sea que esté creando un sistema de informes , un generador de facturas o una solución de gestión de documentos , IronPDF proporciona toda la funcionalidad que necesita para implementar una generación de PDF confiable. También puedes pedir ayuda si la necesitas. Explore funciones adicionales como formularios PDF , anotaciones , marcadores , metadatos y conformidad con PDF/UA para accesibilidad.

¿Está listo para transformar su aplicación ASP.NET Core con capacidades de PDF dinámicos? Compre una licencia para revelar todas las funciones y recibir soporte profesional de nuestro equipo de ingeniería. Para desarrolladores de VB.NET , desarrolladores de F# y aquellos que trabajan con MAUI o Blazor , ofrecemos soporte completo de la plataforma. Consulte nuestra referencia de API para obtener documentación detallada y explorar comparaciones con la competencia para ver por qué los desarrolladores eligen IronPDF.

Preguntas Frecuentes

¿Cómo puedo generar PDF dinámicamente 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. Prueba gratis