Ícono de mensaje
Saltar al pie de página
  1. IronPDF
  2. Blog de IronPDF
  3. Usando IronPDF
  4. Generación Dinámica de PDFs
USANDO IRONPDF

Generación dinámica de PDF .NET con IronPDF

Curtis Chau
Curtis Chau
Publicado:

Las aplicaciones modernas exigen algo más que la generación de documentos estáticos. Tanto si estás creando una plataforma de comercio electrónico que necesita facturas personalizadas, un sistema de informes que extrae datos en tiempo real para generar informes en PDF o una plataforma educativa que crea documentos y certificados en PDF, la generación dinámica de PDF se ha convertido en algo esencial. IronPDF simplifica este complejo requisito, permitiendo a los desarrolladores centrarse en la lógica empresarial en lugar de en los entresijos de la renderización basada en documentos PDF.

Este artículo explora estrategias probadas para crear documentos PDF en aplicaciones .NET utilizando el potente motor de renderizado Chrome de IronPDF. Aprenderá a implementar la generación de PDF basada en plantillas, vincular datos de diversas fuentes de datos, manejar contenido condicional y optimizar su flujo de trabajo de generación de documentos basado en datos. A diferencia de otras alternativas como DynamicPDF Core Suite, IronPDF ofrece una API más sencilla al tiempo que mantiene el acceso a otras funciones como las firmas digitales y la fusión. Al final, dispondrá de las herramientas y los conocimientos necesarios para crear un sistema .NET de generación de PDF completo y dinámico que se adapte a las necesidades de su aplicación.

Generación dinámica de PDF .NET con IronPDF: Imagen 1 - IronPDF

¿Qué es la generación dinámica de documentos PDF en .NET?

La generación de PDF dinámicos .NET se refiere a la creación de documentos PDF mediante programación, en los que el contenido cambia en función de las entradas de datos, las interacciones del usuario o las reglas empresariales. A diferencia de los PDF estáticos que contienen contenido fijo, los archivos PDF basados en datos adaptan su diseño, texto, tablas e incluso páginas web enteras en función de las condiciones de ejecución. Tenga en cuenta que este enfoque supera soluciones más antiguas como las bibliotecas basadas en Java o los conversores básicos de HTML a PDF.

Considere estos escenarios comunes en los que destaca la creación programática de PDF:

  • Generación de facturas: Los detalles del cliente, las partidas, los totales y las condiciones de pago varían en cada transacción para crear documentos PDF
  • Informes financieros: Gráficos, tablas y resúmenes actualizados con datos de mercado en tiempo real para generar informes en PDF
  • Certificados y diplomas: Los nombres de los destinatarios, las fechas y los logros cambian para cada documento PDF
  • Documentos legales: Los contratos se rellenan con los términos y condiciones específicos del cliente en formato PDF
  • Historiales médicos: La información del paciente, los resultados de las pruebas y los planes de tratamiento requieren un formato personalizado en archivos PDF

El enfoque tradicional implica mantener varias plantillas PDF o editar manualmente los documentos, lo que da lugar a un proceso propenso a errores y no escalable. La renderización dinámica de contenidos automatiza por completo este proceso. Con La conversión de HTML a PDF de IronPDF, los desarrolladores escriben el código una vez y generan miles de documentos PDF, cada uno de ellos perfectamente formateado y con los datos exactos necesarios. Este enfoque de generación de tiempo de ejecución admite la implementación multiplataforma, incluidos Windows, Linux, macOS y entornos en contenedores, lo que proporciona acceso a las mismas funciones en todas las plataformas. Los usuarios pueden buscar contenido específico en los PDF creados.

Generación dinámica de PDF .NET con IronPDF: Imagen 2 - Características

¿Cómo configurar IronPDF para crear documentos PDF dinámicamente?

Empezar a utilizar IronPDF requiere una configuración mínima. La biblioteca PDF se instala mediante paquetes NuGet, se integra perfectamente con cualquier proyecto .NET, incluidos .NET Core y .NET Framework, y se ejecuta en Windows, Linux, macOS, Docker y Azure. Para acceder a las últimas funciones, asegúrese de que está utilizando el paquete NuGet más reciente de IronPDF.

Generación dinámica de PDF .NET con IronPDF: Imagen 3 - Generación dinámica de PDF .NET - IronPDF

En primer lugar, instale el paquete IronPDF a través de la consola del gestor de paquetes:

Install-Package IronPdf

Generación dinámica de PDF .NET con IronPDF: Imagen 4 - Instalación

O utilizando la CLI de .NET para descargar el paquete:

dotnet add package IronPdf

Para las vistas MVC y las aplicaciones web, consulte la documentación para obtener instrucciones de configuración específicas. Aquí tienes tu primer archivo PDF dinámico con contenido personalizado utilizando el método RenderHtmlAsPdf de IronPDF:

using IronPdf;
// Initialize with new ChromePdfRenderer for dynamic content
var renderer = new ChromePdfRenderer();
// Create dynamic content with runtime data from data source
var customerName = "Alexandra Chen";
var orderNumber = "ORD-2024-001";
var totalAmount = 1499.99m;
// Generate HTML string dynamically for data-driven PDF
var HTML = $@"
    <h1>Order Confirmation</h1>
    <p>Dear {customerName},</p>
    <p>Thank you for your order #{orderNumber}</p>
    <p>Total Amount: ${totalAmount:F2}</p>
    <p>Your order will be processed within 24 hours.</p>
";
// Convert HTML to PDF dynamically - output as byte array or file
var PDF = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("order-confirmation.pdf");
// Optionally get as byte array for streaming
byte[] pdfBytes = pdf.BinaryData;
using IronPdf;
// Initialize with new ChromePdfRenderer for dynamic content
var renderer = new ChromePdfRenderer();
// Create dynamic content with runtime data from data source
var customerName = "Alexandra Chen";
var orderNumber = "ORD-2024-001";
var totalAmount = 1499.99m;
// Generate HTML string dynamically for data-driven PDF
var HTML = $@"
    <h1>Order Confirmation</h1>
    <p>Dear {customerName},</p>
    <p>Thank you for your order #{orderNumber}</p>
    <p>Total Amount: ${totalAmount:F2}</p>
    <p>Your order will be processed within 24 hours.</p>
";
// Convert HTML to PDF dynamically - output as byte array or file
var PDF = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("order-confirmation.pdf");
// Optionally get as byte array for streaming
byte[] pdfBytes = pdf.BinaryData;
Imports IronPdf

' Initialize with new ChromePdfRenderer for dynamic content
Dim renderer As New ChromePdfRenderer()

' Create dynamic content with runtime data from data source
Dim customerName As String = "Alexandra Chen"
Dim orderNumber As String = "ORD-2024-001"
Dim totalAmount As Decimal = 1499.99D

' Generate HTML string dynamically for data-driven PDF
Dim HTML As String = $"
    <h1>Order Confirmation</h1>
    <p>Dear {customerName},</p>
    <p>Thank you for your order #{orderNumber}</p>
    <p>Total Amount: ${totalAmount:F2}</p>
    <p>Your order will be processed within 24 hours.</p>
"

' Convert HTML to PDF dynamically - output as byte array or file
Dim PDF = renderer.RenderHtmlAsPdf(HTML)
PDF.SaveAs("order-confirmation.pdf")

' Optionally get as byte array for streaming
Dim pdfBytes As Byte() = PDF.BinaryData
$vbLabelText   $csharpLabel

Este ejemplo demuestra el concepto fundamental de la generación de PDF basada en plantillas: combinar plantillas HTML con datos en tiempo de ejecución. El objeto ChromePdfRenderer se encarga de toda la renderización compleja, garantizando que su HTML, CSS e incluso JavaScript se rendericen exactamente como lo harían en el navegador Chrome. La interpolación de cadenas ($@"") permite una integración perfecta de las variables de C# en la plantilla HTML, lo que hace que el contenido sea realmente dinámico. El resultado puede guardarse como archivo o devolverse como matriz de bytes para su transmisión a los usuarios. Este enfoque funciona a la perfección con las opciones avanzadas de renderizado de IronPDF para ajustar el resultado.

Resultado

Generación dinámica de PDF .NET con IronPDF: Imagen 5 - Salida PDF

¿Cuáles son las principales estrategias para el contenido dinámico?

IronPDF admite varios enfoques para la generación dinámica de PDF .NET, cada uno de ellos adecuado para diferentes escenarios. Comprender estas estrategias le ayudará a elegir el enfoque adecuado para sus necesidades específicas de PDF basados en datos. El diseño fluido de la API hace que la implementación sea intuitiva para los desarrolladores.

Generación dinámica de PDF .NET con IronPDF: Imagen 6 - Compatibilidad entre plataformas

Generación basada en plantillas con marcadores de posición

La generación basada en plantillas separa el diseño de los datos, lo que facilita el mantenimiento y permite a los no desarrolladores modificar las plantillas. Este enfoque es ampliamente discutido en Stack Overflow's PDF generation threads como una mejor práctica. Tenga en cuenta que los diseñadores pueden descargar y crear plantillas:

using IronPdf;
// Define reusable template with placeholders for dynamic content
var htmlTemplate = @"
    <style>
        .invoice { font-family: Arial; max-width: 800px; }
        .header { background: #f0f0f0; padding: 20px; }
        .line-item { border-bottom: 1px solid #ddd; padding: 10px 0; }
        .label { font-weight: bold; }
    </style>
    <div class='invoice'>
        <div class='header'>
            <h2>Invoice #{{INVOICE_NUMBER}}</h2>
            <p>Date: {{INVOICE_DATE}}</p>
            <p class='label'>Page: <span>{{PAGE_NUMBER}}</span></p>
        </div>
        <p>Bill To: {{CUSTOMER_NAME}}</p>
        <p>Amount Due: ${{TOTAL_AMOUNT}}</p>
    </div>
";
// Replace placeholders with actual data for runtime generation
var invoiceHtml = htmlTemplate
    .Replace("{{INVOICE_NUMBER}}", "INV-2024-1234")
    .Replace("{{INVOICE_DATE}}", DateTime.Now.ToString("MMM dd, yyyy"))
    .Replace("{{CUSTOMER_NAME}}", "TechCorp Industries")
    .Replace("{{TOTAL_AMOUNT}}", "5,750.00")
    .Replace("{{PAGE_NUMBER}}", "1");
// Generate PDF dynamically from template
var renderer = new ChromePdfRenderer();
// Add header with new page numbers
renderer.RenderingOptions.TextHeader = new TextHeaderFooter()
{
    CenterText = "Invoice",
    DrawDividerLine = true
};
var PDF = renderer.RenderHtmlAsPdf(invoiceHtml);
pdf.SaveAs("invoice.pdf");
using IronPdf;
// Define reusable template with placeholders for dynamic content
var htmlTemplate = @"
    <style>
        .invoice { font-family: Arial; max-width: 800px; }
        .header { background: #f0f0f0; padding: 20px; }
        .line-item { border-bottom: 1px solid #ddd; padding: 10px 0; }
        .label { font-weight: bold; }
    </style>
    <div class='invoice'>
        <div class='header'>
            <h2>Invoice #{{INVOICE_NUMBER}}</h2>
            <p>Date: {{INVOICE_DATE}}</p>
            <p class='label'>Page: <span>{{PAGE_NUMBER}}</span></p>
        </div>
        <p>Bill To: {{CUSTOMER_NAME}}</p>
        <p>Amount Due: ${{TOTAL_AMOUNT}}</p>
    </div>
";
// Replace placeholders with actual data for runtime generation
var invoiceHtml = htmlTemplate
    .Replace("{{INVOICE_NUMBER}}", "INV-2024-1234")
    .Replace("{{INVOICE_DATE}}", DateTime.Now.ToString("MMM dd, yyyy"))
    .Replace("{{CUSTOMER_NAME}}", "TechCorp Industries")
    .Replace("{{TOTAL_AMOUNT}}", "5,750.00")
    .Replace("{{PAGE_NUMBER}}", "1");
// Generate PDF dynamically from template
var renderer = new ChromePdfRenderer();
// Add header with new page numbers
renderer.RenderingOptions.TextHeader = new TextHeaderFooter()
{
    CenterText = "Invoice",
    DrawDividerLine = true
};
var PDF = renderer.RenderHtmlAsPdf(invoiceHtml);
pdf.SaveAs("invoice.pdf");
Imports IronPdf

' Define reusable template with placeholders for dynamic content
Dim htmlTemplate As String = "
    <style>
        .invoice { font-family: Arial; max-width: 800px; }
        .header { background: #f0f0f0; padding: 20px; }
        .line-item { border-bottom: 1px solid #ddd; padding: 10px 0; }
        .label { font-weight: bold; }
    </style>
    <div class='invoice'>
        <div class='header'>
            <h2>Invoice #{{INVOICE_NUMBER}}</h2>
            <p>Date: {{INVOICE_DATE}}</p>
            <p class='label'>Page: <span>{{PAGE_NUMBER}}</span></p>
        </div>
        <p>Bill To: {{CUSTOMER_NAME}}</p>
        <p>Amount Due: ${{TOTAL_AMOUNT}}</p>
    </div>
"

' Replace placeholders with actual data for runtime generation
Dim invoiceHtml As String = htmlTemplate _
    .Replace("{{INVOICE_NUMBER}}", "INV-2024-1234") _
    .Replace("{{INVOICE_DATE}}", DateTime.Now.ToString("MMM dd, yyyy")) _
    .Replace("{{CUSTOMER_NAME}}", "TechCorp Industries") _
    .Replace("{{TOTAL_AMOUNT}}", "5,750.00") _
    .Replace("{{PAGE_NUMBER}}", "1")

' Generate PDF dynamically from template
Dim renderer As New ChromePdfRenderer()

' Add header with new page numbers
renderer.RenderingOptions.TextHeader = New TextHeaderFooter() With {
    .CenterText = "Invoice",
    .DrawDividerLine = True
}

Dim PDF = renderer.RenderHtmlAsPdf(invoiceHtml)
PDF.SaveAs("invoice.pdf")
$vbLabelText   $csharpLabel

Este enfoque destaca cuando se dispone de estructuras de documentos coherentes con datos variables. Los marcadores de posición ({{}}) indican claramente dónde aparece el contenido dinámico, lo que facilita la lectura y el mantenimiento de las plantillas. Estas plantillas pueden almacenarse como archivos, lo que permite actualizarlas fácilmente sin necesidad de recompilar la aplicación. Obtenga más información sobre las capacidades de plantilla de IronPDF para escenarios avanzados. El precio de IronPDF lo hace rentable para la generación a escala basada en plantillas.

Generación de contenido programático

Para situaciones complejas que requieran lógica condicional, bucles o cálculos, la creación programática de PDF ofrece la máxima flexibilidad. Según la documentación de Microsoft sobre la creación de cadenas, este enfoque optimiza el rendimiento de los documentos de gran tamaño. Tenga en cuenta que no se requiere clave de API durante el desarrollo cuando se utiliza la versión de prueba gratuita:

using IronPdf;
using System.Text;
// Sample data structure from data source
var orderItems = new[]
{
    new { Product = "Premium License", Quantity = 5, Price = 399.00m },
    new { Product = "Support Package", Quantity = 1, Price = 299.00m },
    new { Product = "Training Session", Quantity = 2, Price = 150.00m }
};
// Build HTML programmatically with fluent API style
var sb = new StringBuilder();
sb.Append("<h2>Order Summary</h2>");
sb.Append("<table style='width:100%; border-collapse: collapse;'>");
sb.Append("<tr style='background:#333; color:white;'>");
sb.Append("<th style='padding:10px;'>Product</th>");
sb.Append("<th>Quantity</th>");
sb.Append("<th>Unit Price</th>");
sb.Append("<th>Total</th></tr>");
decimal grandTotal = 0;
foreach (var item in orderItems)
{
    var lineTotal = item.Quantity * item.Price;
    grandTotal += lineTotal;
    sb.Append($"<tr>");
    sb.Append($"<td style='padding:10px;'>{item.Product}</td>");
    sb.Append($"<td style='text-align:center;'>{item.Quantity}</td>");
    sb.Append($"<td style='text-align:right;'>${item.Price:F2}</td>");
    sb.Append($"<td style='text-align:right;'>${lineTotal:F2}</td>");
    sb.Append($"</tr>");
}
// Add footer with label
sb.Append($"<tr style='font-weight:bold; background:#f0f0f0;'>");
sb.Append($"<td colspan='3' style='padding:10px; text-align:right;'>Grand Total:</td>");
sb.Append($"<td style='text-align:right; padding:10px;'>${grandTotal:F2}</td>");
sb.Append($"</tr>");
sb.Append("</table>");
// Render to PDF with new ChromePdfRenderer
var renderer = new ChromePdfRenderer();
var PDF = renderer.RenderHtmlAsPdf(sb.ToString());
// Output as byte array for web download
byte[] pdfData = pdf.BinaryData;
pdf.SaveAs("order-summary.pdf");
using IronPdf;
using System.Text;
// Sample data structure from data source
var orderItems = new[]
{
    new { Product = "Premium License", Quantity = 5, Price = 399.00m },
    new { Product = "Support Package", Quantity = 1, Price = 299.00m },
    new { Product = "Training Session", Quantity = 2, Price = 150.00m }
};
// Build HTML programmatically with fluent API style
var sb = new StringBuilder();
sb.Append("<h2>Order Summary</h2>");
sb.Append("<table style='width:100%; border-collapse: collapse;'>");
sb.Append("<tr style='background:#333; color:white;'>");
sb.Append("<th style='padding:10px;'>Product</th>");
sb.Append("<th>Quantity</th>");
sb.Append("<th>Unit Price</th>");
sb.Append("<th>Total</th></tr>");
decimal grandTotal = 0;
foreach (var item in orderItems)
{
    var lineTotal = item.Quantity * item.Price;
    grandTotal += lineTotal;
    sb.Append($"<tr>");
    sb.Append($"<td style='padding:10px;'>{item.Product}</td>");
    sb.Append($"<td style='text-align:center;'>{item.Quantity}</td>");
    sb.Append($"<td style='text-align:right;'>${item.Price:F2}</td>");
    sb.Append($"<td style='text-align:right;'>${lineTotal:F2}</td>");
    sb.Append($"</tr>");
}
// Add footer with label
sb.Append($"<tr style='font-weight:bold; background:#f0f0f0;'>");
sb.Append($"<td colspan='3' style='padding:10px; text-align:right;'>Grand Total:</td>");
sb.Append($"<td style='text-align:right; padding:10px;'>${grandTotal:F2}</td>");
sb.Append($"</tr>");
sb.Append("</table>");
// Render to PDF with new ChromePdfRenderer
var renderer = new ChromePdfRenderer();
var PDF = renderer.RenderHtmlAsPdf(sb.ToString());
// Output as byte array for web download
byte[] pdfData = pdf.BinaryData;
pdf.SaveAs("order-summary.pdf");
Imports IronPdf
Imports System.Text

' Sample data structure from data source
Dim orderItems = New() {
    New With {.Product = "Premium License", .Quantity = 5, .Price = 399.0D},
    New With {.Product = "Support Package", .Quantity = 1, .Price = 299.0D},
    New With {.Product = "Training Session", .Quantity = 2, .Price = 150.0D}
}

' Build HTML programmatically with fluent API style
Dim sb As New StringBuilder()
sb.Append("<h2>Order Summary</h2>")
sb.Append("<table style='width:100%; border-collapse: collapse;'>")
sb.Append("<tr style='background:#333; color:white;'>")
sb.Append("<th style='padding:10px;'>Product</th>")
sb.Append("<th>Quantity</th>")
sb.Append("<th>Unit Price</th>")
sb.Append("<th>Total</th></tr>")

Dim grandTotal As Decimal = 0

For Each item In orderItems
    Dim lineTotal = item.Quantity * item.Price
    grandTotal += lineTotal
    sb.Append("<tr>")
    sb.Append($"<td style='padding:10px;'>{item.Product}</td>")
    sb.Append($"<td style='text-align:center;'>{item.Quantity}</td>")
    sb.Append($"<td style='text-align:right;'>${item.Price:F2}</td>")
    sb.Append($"<td style='text-align:right;'>${lineTotal:F2}</td>")
    sb.Append("</tr>")
Next

' Add footer with label
sb.Append("<tr style='font-weight:bold; background:#f0f0f0;'>")
sb.Append("<td colspan='3' style='padding:10px; text-align:right;'>Grand Total:</td>")
sb.Append($"<td style='text-align:right; padding:10px;'>${grandTotal:F2}</td>")
sb.Append("</tr>")
sb.Append("</table>")

' Render to PDF with new ChromePdfRenderer
Dim renderer As New ChromePdfRenderer()
Dim PDF = renderer.RenderHtmlAsPdf(sb.ToString())

' Output as byte array for web download
Dim pdfData As Byte() = PDF.BinaryData
PDF.SaveAs("order-summary.pdf")
$vbLabelText   $csharpLabel

Este método es ideal cuando se trata de contenidos de longitud variable, como artículos de pedidos o tablas de datos. El StringBuilder construye eficazmente HTML de forma dinámica, mientras que el bucle genera dinámicamente filas de tabla basadas en su fuente de datos. El cálculo de grandTotal demuestra cómo la lógica empresarial se integra directamente en la generación de documentos. Los usuarios pueden descargar inmediatamente los archivos PDF generados.

Resultado

Generación dinámica de PDF .NET con IronPDF: Imagen 7 - HTML to PDF Output

¿Cómo manejar funciones dinámicas avanzadas?

Más allá de la sustitución básica de contenido, IronPDF gestiona sofisticados escenarios de generación dinámica de PDF que exigen las aplicaciones reales. Estas capacidades se ajustan a las normas de cumplimiento de PDF/A para la conservación de documentos a largo plazo. El acceso a estas otras funciones no requiere ninguna clave de API adicional.

Tablas dinámicas con filas variables

Cuando se trabaja con conjuntos de datos de tamaño desconocido para la creación de PDF basados en datos, se necesitan tablas que se expandan o paginen automáticamente a través de las páginas. Este patrón se utiliza habitualmente en sistemas de información financiera en los que los volúmenes de datos varían. Los usuarios pueden realizar búsquedas en los informes creados:

using IronPdf;
// Simulate data from database for runtime generation
var salesData = Enumerable.Range(1, 25).Select(i => new
{
    Month = $"Month {i}",
    Revenue = 10000 + (i * 500),
    Growth = 2.5 + (i * 0.3)
});
// Build responsive table for dynamic PDF generation .NET
var tableHtml = @"
<style>
    table { width: 100%; border-collapse: collapse; page-break-inside: auto; }
    th { background: #2c3e50; color: white; padding: 12px; }
    td { padding: 8px; border-bottom: 1px solid #ddd; }
    tr:nth-child(even) { background: #f9f9f9; }
    tr { page-break-inside: avoid; page-break-after: auto; }
    .page-number { text-align: center; margin-top: 20px; }
</style>
<h2>Sales Performance Report</h2>
<table>
    <thead>
        <tr><th>Period</th><th>Revenue</th><th>Growth %</th></tr>
    </thead>
    <tbody>";
foreach (var row in salesData)
{
    // Generate table rows dynamically
    tableHtml += $@"
        <tr>
            <td>{row.Month}</td>
            <td>${row.Revenue:N0}</td>
            <td>{row.Growth:F1}%</td>
        </tr>";
}
tableHtml += "</tbody></table>";
tableHtml += "<div class='page-number'>Page numbers will appear in footer</div>";
// Configure renderer for optimal table rendering in data-driven PDFs
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;
renderer.RenderingOptions.MarginTop = 40;
renderer.RenderingOptions.MarginBottom = 40;
// Add footer with page numbers
renderer.RenderingOptions.TextFooter = new TextHeaderFooter()
{
    CenterText = "{page} of {total-pages}",
    FontSize = 10
};
var PDF = renderer.RenderHtmlAsPdf(tableHtml);
pdf.SaveAs("sales-report.pdf");
using IronPdf;
// Simulate data from database for runtime generation
var salesData = Enumerable.Range(1, 25).Select(i => new
{
    Month = $"Month {i}",
    Revenue = 10000 + (i * 500),
    Growth = 2.5 + (i * 0.3)
});
// Build responsive table for dynamic PDF generation .NET
var tableHtml = @"
<style>
    table { width: 100%; border-collapse: collapse; page-break-inside: auto; }
    th { background: #2c3e50; color: white; padding: 12px; }
    td { padding: 8px; border-bottom: 1px solid #ddd; }
    tr:nth-child(even) { background: #f9f9f9; }
    tr { page-break-inside: avoid; page-break-after: auto; }
    .page-number { text-align: center; margin-top: 20px; }
</style>
<h2>Sales Performance Report</h2>
<table>
    <thead>
        <tr><th>Period</th><th>Revenue</th><th>Growth %</th></tr>
    </thead>
    <tbody>";
foreach (var row in salesData)
{
    // Generate table rows dynamically
    tableHtml += $@"
        <tr>
            <td>{row.Month}</td>
            <td>${row.Revenue:N0}</td>
            <td>{row.Growth:F1}%</td>
        </tr>";
}
tableHtml += "</tbody></table>";
tableHtml += "<div class='page-number'>Page numbers will appear in footer</div>";
// Configure renderer for optimal table rendering in data-driven PDFs
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;
renderer.RenderingOptions.MarginTop = 40;
renderer.RenderingOptions.MarginBottom = 40;
// Add footer with page numbers
renderer.RenderingOptions.TextFooter = new TextHeaderFooter()
{
    CenterText = "{page} of {total-pages}",
    FontSize = 10
};
var PDF = renderer.RenderHtmlAsPdf(tableHtml);
pdf.SaveAs("sales-report.pdf");
Imports IronPdf

' Simulate data from database for runtime generation
Dim salesData = Enumerable.Range(1, 25).Select(Function(i) New With {
    .Month = $"Month {i}",
    .Revenue = 10000 + (i * 500),
    .Growth = 2.5 + (i * 0.3)
})

' Build responsive table for dynamic PDF generation .NET
Dim tableHtml As String = "
<style>
    table { width: 100%; border-collapse: collapse; page-break-inside: auto; }
    th { background: #2c3e50; color: white; padding: 12px; }
    td { padding: 8px; border-bottom: 1px solid #ddd; }
    tr:nth-child(even) { background: #f9f9f9; }
    tr { page-break-inside: avoid; page-break-after: auto; }
    .page-number { text-align: center; margin-top: 20px; }
</style>
<h2>Sales Performance Report</h2>
<table>
    <thead>
        <tr><th>Period</th><th>Revenue</th><th>Growth %</th></tr>
    </thead>
    <tbody>"

For Each row In salesData
    ' Generate table rows dynamically
    tableHtml += $"
        <tr>
            <td>{row.Month}</td>
            <td>${row.Revenue:N0}</td>
            <td>{row.Growth:F1}%</td>
        </tr>"
Next

tableHtml += "</tbody></table>"
tableHtml += "<div class='page-number'>Page numbers will appear in footer</div>"

' Configure renderer for optimal table rendering in data-driven PDFs
Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4
renderer.RenderingOptions.MarginTop = 40
renderer.RenderingOptions.MarginBottom = 40

' Add footer with page numbers
renderer.RenderingOptions.TextFooter = New TextHeaderFooter() With {
    .CenterText = "{page} of {total-pages}",
    .FontSize = 10
}

Dim PDF = renderer.RenderHtmlAsPdf(tableHtml)
PDF.SaveAs("sales-report.pdf")
$vbLabelText   $csharpLabel

Este ejemplo maneja conjuntos de datos de cualquier tamaño para la creación programática de PDF. La tabla fluye automáticamente a través de las páginas cuando es necesario, manteniendo los encabezados y el formato. Los números de página del pie de página ayudan a los usuarios a navegar por informes más largos. Para obtener información más compleja sobre el formato de las tablas y la fusión de celdas, consulte la documentación sobre la representación de tablas de IronPDF.

Bloques de contenido condicional

Los documentos reales a menudo requieren secciones que sólo aparecen bajo ciertas condiciones en la generación dinámica de PDF .NET:

using IronPdf;
// Business logic determines content for data-driven PDFs
var customer = new
{
    Name = "Global Tech Solutions",
    IsPremium = true,
    HasDiscount = true,
    DiscountPercent = 15,
    LoyaltyPoints = 2500
};
// Build content with conditions for template-based generation
var conditionalHtml = $@"
<h2>Customer Profile: {customer.Name}</h2>
<div style='border: 1px solid #ddd; padding: 20px; margin: 20px 0;'>";
// Premium member section - only shows for premium customers
if (customer.IsPremium)
{
    conditionalHtml += @"
    <div style='background: gold; padding: 10px; margin-bottom: 10px;'>
        ⭐ PREMIUM MEMBER - Exclusive Benefits Applied
    </div>";
}
// Discount section - only shows if discount exists
if (customer.HasDiscount)
{
    conditionalHtml += $@"
    <div style='background: #e8f5e9; padding: 10px; margin-bottom: 10px;'>
        💰 Special Discount: {customer.DiscountPercent}% off all orders
    </div>";
}
// Loyalty points - only shows if points > 0
if (customer.LoyaltyPoints > 0)
{
    conditionalHtml += $@"
    <div style='background: #f3e5f5; padding: 10px;'>
        🎁 Loyalty Points Balance: {customer.LoyaltyPoints:N0} points
    </div>";
}
conditionalHtml += "</div>";
var renderer = new ChromePdfRenderer();
var PDF = renderer.RenderHtmlAsPdf(conditionalHtml);
pdf.SaveAs("customer-profile.pdf");
using IronPdf;
// Business logic determines content for data-driven PDFs
var customer = new
{
    Name = "Global Tech Solutions",
    IsPremium = true,
    HasDiscount = true,
    DiscountPercent = 15,
    LoyaltyPoints = 2500
};
// Build content with conditions for template-based generation
var conditionalHtml = $@"
<h2>Customer Profile: {customer.Name}</h2>
<div style='border: 1px solid #ddd; padding: 20px; margin: 20px 0;'>";
// Premium member section - only shows for premium customers
if (customer.IsPremium)
{
    conditionalHtml += @"
    <div style='background: gold; padding: 10px; margin-bottom: 10px;'>
        ⭐ PREMIUM MEMBER - Exclusive Benefits Applied
    </div>";
}
// Discount section - only shows if discount exists
if (customer.HasDiscount)
{
    conditionalHtml += $@"
    <div style='background: #e8f5e9; padding: 10px; margin-bottom: 10px;'>
        💰 Special Discount: {customer.DiscountPercent}% off all orders
    </div>";
}
// Loyalty points - only shows if points > 0
if (customer.LoyaltyPoints > 0)
{
    conditionalHtml += $@"
    <div style='background: #f3e5f5; padding: 10px;'>
        🎁 Loyalty Points Balance: {customer.LoyaltyPoints:N0} points
    </div>";
}
conditionalHtml += "</div>";
var renderer = new ChromePdfRenderer();
var PDF = renderer.RenderHtmlAsPdf(conditionalHtml);
pdf.SaveAs("customer-profile.pdf");
Imports IronPdf

' Business logic determines content for data-driven PDFs
Dim customer = New With {
    .Name = "Global Tech Solutions",
    .IsPremium = True,
    .HasDiscount = True,
    .DiscountPercent = 15,
    .LoyaltyPoints = 2500
}

' Build content with conditions for template-based generation
Dim conditionalHtml As String = $"
<h2>Customer Profile: {customer.Name}</h2>
<div style='border: 1px solid #ddd; padding: 20px; margin: 20px 0;'>"

' Premium member section - only shows for premium customers
If customer.IsPremium Then
    conditionalHtml &= "
    <div style='background: gold; padding: 10px; margin-bottom: 10px;'>
        ⭐ PREMIUM MEMBER - Exclusive Benefits Applied
    </div>"
End If

' Discount section - only shows if discount exists
If customer.HasDiscount Then
    conditionalHtml &= $"
    <div style='background: #e8f5e9; padding: 10px; margin-bottom: 10px;'>
        💰 Special Discount: {customer.DiscountPercent}% off all orders
    </div>"
End If

' Loyalty points - only shows if points > 0
If customer.LoyaltyPoints > 0 Then
    conditionalHtml &= $"
    <div style='background: #f3e5f5; padding: 10px;'>
        🎁 Loyalty Points Balance: {customer.LoyaltyPoints:N0} points
    </div>"
End If

conditionalHtml &= "</div>"

Dim renderer As New ChromePdfRenderer()
Dim PDF = renderer.RenderHtmlAsPdf(conditionalHtml)
PDF.SaveAs("customer-profile.pdf")
$vbLabelText   $csharpLabel

Cada bloque condicional sólo aparece cuando se cumplen criterios específicos en la generación en tiempo de ejecución. Este patrón se extiende a cualquier regla de negocio: mostrar advertencias para cuentas vencidas, añadir avisos legales para regiones específicas o incluir ofertas promocionales basadas en el historial de compras. Para una lógica condicional más compleja, explore las funciones avanzadas de renderizado HTML de IronPDF.

Resultado

Generación dinámica de PDF .NET con IronPDF: Imagen 8 - Dynamic PDF Output

Contenido dinámico renderizado en JavaScript

Para la conversión de contenido dinámico de HTML a PDF, IronPDF ejecuta JavaScript antes de renderizar tablas, gráficos y elementos interactivos. Esta capacidad es esencial para los modernos cuadros de mando de informes basados en la web:

using IronPdf;
var chartHtml = @"
<script src='https://cdn.jsdelivr.net/npm/chart.js'></script>
<canvas id='myChart' width='400' height='200'></canvas>
<script>
    // Dynamic chart data for runtime generation
    var ctx = document.getElementById('myChart').getContext('2d');
    new Chart(ctx, {
        type: 'bar',
        data: {
            labels: ['Q1', 'Q2', 'Q3', 'Q4'],
            datasets: [{
                label: 'Revenue (in thousands)',
                data: [120, 195, 230, 285],
                backgroundColor: '#3498db'
            }]
        }
    });
</script>";
var renderer = new ChromePdfRenderer();
// Enable JavaScript for dynamic content rendering
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor.RenderDelay(1000); // Wait for chart rendering
var PDF = renderer.RenderHtmlAsPdf(chartHtml);
pdf.SaveAs("revenue-chart.pdf");
using IronPdf;
var chartHtml = @"
<script src='https://cdn.jsdelivr.net/npm/chart.js'></script>
<canvas id='myChart' width='400' height='200'></canvas>
<script>
    // Dynamic chart data for runtime generation
    var ctx = document.getElementById('myChart').getContext('2d');
    new Chart(ctx, {
        type: 'bar',
        data: {
            labels: ['Q1', 'Q2', 'Q3', 'Q4'],
            datasets: [{
                label: 'Revenue (in thousands)',
                data: [120, 195, 230, 285],
                backgroundColor: '#3498db'
            }]
        }
    });
</script>";
var renderer = new ChromePdfRenderer();
// Enable JavaScript for dynamic content rendering
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor.RenderDelay(1000); // Wait for chart rendering
var PDF = renderer.RenderHtmlAsPdf(chartHtml);
pdf.SaveAs("revenue-chart.pdf");
Imports IronPdf

Dim chartHtml As String = "
<script src='https://cdn.jsdelivr.net/npm/chart.js'></script>
<canvas id='myChart' width='400' height='200'></canvas>
<script>
    // Dynamic chart data for runtime generation
    var ctx = document.getElementById('myChart').getContext('2d');
    new Chart(ctx, {
        type: 'bar',
        data: {
            labels: ['Q1', 'Q2', 'Q3', 'Q4'],
            datasets: [{
                label: 'Revenue (in thousands)',
                data: [120, 195, 230, 285],
                backgroundColor: '#3498db'
            }]
        }
    });
</script>"

Dim renderer As New ChromePdfRenderer()
' Enable JavaScript for dynamic content rendering
renderer.RenderingOptions.EnableJavaScript = True
renderer.RenderingOptions.WaitFor.RenderDelay(1000) ' Wait for chart rendering
Dim PDF = renderer.RenderHtmlAsPdf(chartHtml)
PDF.SaveAs("revenue-chart.pdf")
$vbLabelText   $csharpLabel

La opción EnableJavaScript garantiza que Chart.js se ejecute para la generación de PDF basada en datos, mientras que RenderDelay proporciona tiempo para que el gráfico se renderice por completo. Este enfoque funciona con cualquier biblioteca de JavaScript: D3.js para visualizaciones complejas, jQuery para la manipulación del DOM o scripts personalizados para cálculos. Más información sobre la renderización de JavaScript en IronPDF.

Conclusión

Dynamic PDF generation .NET transforma el modo en que las aplicaciones gestionan la creación de documentos. Con IronPDF, has visto cómo implementar la generación de PDF basada en plantillas, manejar contenido condicional, crear PDF con tablas dinámicas y construir sistemas completos de generación de documentos basados en datos. La combinación del motor de renderizado Chrome de IronPDF y el sólido manejo de datos de .NET crea infinitas posibilidades para la generación de PDF en tiempo de ejecución y la automatización de documentos.

El enfoque de IronPDF para la creación programática de PDF proporciona la flexibilidad necesaria para las aplicaciones modernas, al tiempo que mantiene la simplicidad en la implementación. Tanto si se trata de generar un único certificado personalizado como miles de facturas, las estrategias que aquí se describen se adaptan a sus necesidades. La biblioteca admite la conversión de PDF, la fusión de varios archivos PDF, la adición de firmas digitales y la extracción de contenido como una matriz de bytes para su transmisión, todas ellas funciones esenciales para las aplicaciones empresariales.

La versión de prueba gratuita no requiere clave API y proporciona acceso a todas las funciones, lo que permite a los desarrolladores probar el sistema a fondo. Para obtener información detallada sobre precios y descargar las últimas funciones, visite el sitio web de IronPDF. Tenga en cuenta que existe documentación completa para todas las plataformas compatibles.

Inicia tu prueba gratuita para implementar estas estrategias de generación dinámica de PDF en tus aplicaciones. Para la implementación en producción, explore las opciones de licencia que se adaptan a sus necesidades, respaldadas por el soporte de ingeniería de IronPDF.

Generación dinámica de PDF .NET con IronPDF: Imagen 9 - Licencias

Preguntas Frecuentes

¿Qué es la generación dinámica de PDF?

La generación dinámica de PDF hace referencia a la creación de documentos PDF sobre la marcha basándose en la entrada de datos en tiempo real, en lugar de utilizar plantillas estáticas preexistentes.

¿Cómo puede IronPDF ayudar con la generación dinámica de PDF en .NET?

IronPDF simplifica la generación dinámica de PDF permitiendo a los desarrolladores crear PDF a partir de HTML, imágenes u otras fuentes, centrándose en la lógica empresarial en lugar de en la compleja renderización de PDF.

¿Cuáles son las ventajas de utilizar IronPDF para generar PDF dinámicos?

El uso de IronPDF para PDF dinámicos permite la personalización, la integración de datos en tiempo real y la reducción de la complejidad en la creación de documentos PDF directamente desde aplicaciones .NET.

¿Puede utilizarse IronPDF para generar facturas personalizadas en una plataforma de comercio electrónico?

Sí, IronPDF puede generar dinámicamente facturas personalizadas integrando datos en tiempo real, lo que lo hace ideal para plataformas de comercio electrónico.

¿Qué tipos de aplicaciones se benefician de la generación dinámica de PDF?

Aplicaciones como plataformas de comercio electrónico, sistemas de generación de informes y plataformas educativas se benefician de la generación dinámica de PDF al proporcionar documentos personalizados en tiempo real.

¿Es IronPDF adecuado para generar informes PDF con datos en tiempo real?

Por supuesto, IronPDF está diseñado para generar informes PDF a partir de datos en tiempo real, por lo que es perfecto para la generación dinámica de documentos.

¿Cómo gestiona IronPDF las complejidades del procesamiento de PDF?

IronPDF abstrae las complejidades de la renderización de PDF, lo que permite a los desarrolladores centrarse en la lógica empresarial de su aplicación mientras crean PDF de alta calidad.

¿Puede IronPDF crear certificados educativos de forma dinámica?

Sí, IronPDF puede generar certificados educativos de forma dinámica utilizando entradas de datos para crear certificados personalizados y de aspecto profesional.

¿Es IronPDF compatible con la creación de archivos PDF a partir de contenido HTML?

IronPDF admite la creación de PDF a partir de contenido HTML, lo que permite a los desarrolladores convertir páginas web o cadenas HTML directamente a formato PDF.

¿Cómo mejora IronPDF la productividad de los desarrolladores?

IronPDF mejora la productividad de los desarrolladores al proporcionar una API sencilla para la generación de PDF, lo que reduce el tiempo y el esfuerzo necesarios para crear documentos dinámicos.

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