Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. Utilisation de IronPDF
  4. Génération dynamique de PDF
UTILISATION DE IRONPDF

Génération dynamique de PDF .NET à l'aide d'IronPDF for .NET

Curtis Chau
Curtis Chau
Publié:

Les applications modernes exigent plus que la génération de documents statiques. Qu'il s'agisse d'une plateforme de commerce électronique nécessitant des factures personnalisées, d'un système de reporting qui extrait des données en temps réel pour générer des rapports PDF ou d'une plateforme éducative qui crée des documents et des certificats PDF, la génération dynamique de PDF est devenue essentielle. IronPDF simplifie cette exigence complexe, permettant aux développeurs de se concentrer sur la logique commerciale plutôt que sur les subtilités du rendu basé sur les documents PDF.

Cet article explore des stratégies éprouvées pour créer des documents PDF dans des applications .NET à l'aide du puissant moteur de rendu Chrome d'IronPDF. Vous apprendrez à mettre en œuvre la génération de PDF à partir de modèles, à lier des données provenant de diverses sources de données, à gérer le contenu conditionnel et à optimiser votre flux de travail de génération de documents axés sur les données. Contrairement à des alternatives comme DynamicPDF Core Suite, IronPDF propose une API plus simple tout en maintenant l'accès à d'autres fonctionnalités comme les signatures numériques et la fusion. À la fin du cours, vous disposerez des outils et des connaissances nécessaires pour créer un système .NET complet et dynamique de génération de PDF qui s'adaptera aux besoins de votre application.

Génération dynamique de PDF .NET à l'aide d'IronPDF : Image 1 - IronPDF

Qu'est-ce que la génération dynamique de documents PDF en .NET?

La génération dynamique de PDF .NET fait référence à la création programmatique de documents PDF dont le contenu est modifié en fonction des données saisies, des interactions avec l'utilisateur ou des règles de gestion. Contrairement aux PDF statiques qui contiennent un contenu fixe, les fichiers PDF axés sur les données adaptent leur mise en page, leur texte, leurs tableaux et même des pages web entières en fonction des conditions d'exécution. Notez que cette approche dépasse les solutions plus anciennes telles que les bibliothèques basées sur Java ou les convertisseurs HTML-PDF de base.

Examinez ces scénarios courants dans lesquels la création programmatique de PDF excelle :

  • Génération de factures : Les détails du client, les postes, les totaux et les conditions de paiement varient pour chaque transaction afin de créer des documents PDF
  • Rapports financiers : Les graphiques, tableaux et résumés sont mis à jour avec des données de marché en temps réel pour générer des rapports PDF
  • Certificats et diplômes : Les noms des récipiendaires, les dates et les réalisations changent pour chaque document PDF
  • Documents juridiques : Les contrats sont complétés par des termes et conditions spécifiques au client au format PDF
  • Dossiers médicaux : Les informations sur les patients, les résultats des tests et les plans de traitement nécessitent un formatage personnalisé dans les fichiers PDF

L'approche traditionnelle implique la maintenance de plusieurs modèles PDF ou l'édition manuelle des documents, ce qui conduit à un processus sujet aux erreurs et non évolutif. Le rendu dynamique du contenu automatise entièrement cette tâche. Avec la conversion HTML vers PDF d'IronPDF, les développeurs écrivent du code une seule fois et génèrent des documents PDF par milliers, chacun parfaitement formaté et contenant les données exactes nécessaires. Cette approche de génération de runtime prend en charge le déploiement multiplateforme, y compris Windows, Linux, macOS et les environnements conteneurisés, offrant un accès aux mêmes fonctionnalités sur toutes les plateformes. Les utilisateurs peuvent rechercher un contenu spécifique dans les PDF créés.

Génération dynamique de PDF .NET à l'aide d'IronPDF : Image 2 - Caractéristiques

Comment configurer IronPDF pour créer des documents PDF de façon dynamique?

La mise en route d'IronPDF ne nécessite qu'une installation minimale. La bibliothèque PDF s'installe via des packages NuGet, s'intègre de manière transparente à tout projet .NET, y compris .NET Core et .NET Framework, et s'exécute sous Windows, Linux, macOS, Docker et Azure. Pour accéder aux dernières fonctionnalités, assurez-vous d'utiliser le package NuGet IronPDF le plus récent.

Génération dynamique de PDF .NET à l'aide d'IronPDF : Image 3 - Génération dynamique de PDF .NET - IronPDF

Tout d'abord, installez le paquet IronPDF via la console du gestionnaire de paquets :

Install-Package IronPdf

Génération dynamique de PDF .NET à l'aide d'IronPDF : Image 4 - Installation

Ou en utilisant le CLI .NET pour télécharger le paquet :

dotnet add package IronPdf

Pour les vues MVC et les applications web, reportez-vous à la documentation pour des instructions d'installation spécifiques. Voici votre premier fichier PDF dynamique au contenu personnalisé à l'aide de la méthode RenderHtmlAsPdf d'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

Cet exemple illustre le concept fondamental de la génération de PDF à partir de modèles : combiner des modèles HTML avec des données d'exécution. L'objet ChromePdfRenderer prend en charge tous les rendus complexes, en veillant à ce que votre HTML, votre CSS et même votre JavaScript soient rendus exactement comme ils le seraient dans le navigateur Chrome. L'interpolation de chaînes ($@"") permet une intégration transparente des variables C# dans votre modèle HTML, rendant le contenu véritablement dynamique. Le résultat peut être enregistré sous forme de fichier ou renvoyé sous forme de tableau d'octets pour être transmis aux utilisateurs. Cette approche fonctionne en toute transparence avec les options de rendu avancées d'IronPDF pour affiner la sortie.

Sortie

Génération dynamique de PDF .NET à l'aide d'IronPDF : Image 5 - Sortie PDF

Quelles sont les principales stratégies en matière de contenu dynamique ?

IronPDF prend en charge plusieurs approches pour la génération dynamique de PDF .NET, chacune adaptée à différents scénarios. La compréhension de ces stratégies vous permet de choisir l'approche la mieux adaptée à vos besoins spécifiques en matière de PDF pilotés par les données. La conception fluide de l'API rend la mise en œuvre intuitive pour les développeurs.

Génération dynamique de PDF .NET à l'aide d'IronPDF : Image 6 - Compatibilité multiplateforme

Génération basée sur un modèle avec placeholders

La génération basée sur les modèles sépare la conception des données, ce qui facilite la maintenance et permet aux non-développeurs de modifier les modèles. Cette approche est largement discutée dans les fils de discussion sur la génération de PDF deStack Overflow en tant que meilleure pratique. Notez que les modèles peuvent être téléchargés et créés par les concepteurs :

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

Cette approche est particulièrement efficace lorsque les structures des documents sont cohérentes et que les données sont variables. Les caractères génériques ({{}}) indiquent clairement où le contenu dynamique apparaît, ce qui rend les modèles lisibles et faciles à maintenir. Vous pouvez stocker ces modèles sous forme de fichiers, ce qui permet de les mettre à jour facilement sans recompiler votre application. En savoir plus sur les capacités de template d'IronPDF pour les scénarios avancés. La tarification d'IronPDF la rend rentable pour la génération à l'échelle basée sur des modèles.

Génération de contenu programmatique

Pour les scénarios complexes nécessitant une logique conditionnelle, des boucles ou des calculs, la création programmatique de PDF offre une flexibilité maximale. Selon la documentation de Microsoft sur la construction de chaînes de caractères, cette approche optimise les performances pour les documents volumineux. Notez qu'aucune clé API n'est requise pendant le développement lors de l'utilisation de la version d'essai gratuite :

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

Cette méthode est particulièrement efficace lorsqu'il s'agit de contenus de longueur variable, tels que des éléments de commande ou des tableaux de données. Le StringBuilder construit efficacement le HTML de manière dynamique, tandis que la boucle génère dynamiquement des lignes de tableau en fonction de votre source de données. Le calcul du total général montre comment la logique commerciale s'intègre directement dans la génération de documents. Les utilisateurs peuvent télécharger immédiatement les fichiers PDF générés.

Sortie

Génération dynamique de PDF .NET à l'aide d'IronPDF : Image 7 - Sortie HTML vers PDF

Comment gérer les fonctions dynamiques avancées ?

Au-delà du remplacement de contenu de base, IronPDF gère des scénarios sophistiqués de génération dynamique de PDF que les applications réelles exigent. Ces capacités s'alignent sur les normes de conformité PDF/A pour la conservation à long terme des documents. L'accès à ces autres fonctionnalités ne nécessite pas de clé API supplémentaire.

Tableaux dynamiques avec lignes variables

Lorsque vous traitez des ensembles de données de taille inconnue pour la création de PDF pilotés par les données, vous avez besoin de tableaux qui se développent ou se paginent automatiquement d'une page à l'autre. Ce modèle est couramment utilisé dans les systèmes d'information financière où les volumes de données varient. Les utilisateurs peuvent effectuer des recherches dans les rapports créés :

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

Cet exemple traite des ensembles de données de toutes tailles pour la création programmatique de PDF. Le tableau passe automatiquement d'une page à l'autre lorsque cela est nécessaire, en conservant les en-têtes et le formatage. Les numéros de page en bas de page aident les utilisateurs à naviguer dans les rapports plus longs. Pour une mise en forme plus complexe des tableaux et la fusion des cellules, consultez la documentation sur le rendu des tableaux d'IronPDF.

Blocs de contenu conditionnel

Les documents réels nécessitent souvent des sections qui n'apparaissent que sous certaines conditions dans la génération dynamique 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

Chaque bloc conditionnel n'apparaît que lorsque des critères spécifiques sont remplis lors de la génération du temps d'exécution. Ce modèle s'applique à n'importe quelle règle commerciale : affichage d'avertissements pour les comptes en souffrance, ajout d'avertissements légaux pour des régions spécifiques ou inclusion d'offres promotionnelles basées sur l'historique d'achat. Pour une logique conditionnelle plus complexe, explorez les fonctionnalités avancées de rendu HTML d'IronPDF.

Sortie

Génération dynamique de PDF .NET à l'aide d'IronPDF : Image 8 - Sortie PDF dynamique

Contenu dynamique rendu JavaScript

Pour la conversion de contenu dynamique de HTML en PDF, IronPDF exécute JavaScript avant de rendre les tableaux, les graphiques et les éléments interactifs. Cette capacité est essentielle pour les tableaux de bord modernes basés sur le 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

L'option EnableJavaScript garantit l'exécution de Chart.js pour la génération de PDF à partir de données, tandis que l'option RenderDelay laisse le temps au graphique de s'afficher complètement. Cette approche fonctionne avec n'importe quelle bibliothèque JavaScript - D3.js pour les visualisations complexes, jQuery pour la manipulation du DOM ou des scripts personnalisés pour les calculs. En savoir plus sur le rendu JavaScript dans IronPDF.

Conclusion

La génération dynamique de PDF .NET transforme la façon dont les applications gèrent la création de documents. Avec IronPDF, vous avez vu comment mettre en œuvre la génération de PDF basée sur des modèles, gérer le contenu conditionnel, créer des PDF avec des tableaux dynamiques et construire des systèmes complets de génération de documents axés sur les données. La combinaison du moteur de rendu Chrome d'IronPDF et du traitement robuste des données de .NET crée des possibilités infinies pour la génération de PDF en cours d'exécution et l'automatisation des documents.

L'approche d'IronPDF en matière de création programmatique de PDF offre la flexibilité nécessaire aux applications modernes tout en conservant la simplicité de mise en œuvre. Qu'il s'agisse de générer un seul certificat personnalisé ou des milliers de factures, les stratégies abordées ici s'adaptent à vos besoins. La bibliothèque prend en charge la conversion PDF, la fusion de plusieurs fichiers PDF, l'ajout de signatures numériques et l'extraction du contenu sous forme de tableau d'octets pour la diffusion en continu - autant de fonctions essentielles pour les applications d'entreprise.

L'essai gratuit ne nécessite pas de clé API et donne accès à toutes les fonctionnalités, ce qui permet aux développeurs de tester le système en profondeur. Pour obtenir des informations tarifaires détaillées et télécharger les dernières fonctionnalités, visitez le site web d'IronPDF. Notez qu'une documentation complète est disponible pour toutes les plateformes prises en charge.

Commencez votre essai gratuit pour mettre en œuvre ces stratégies de génération dynamique de PDF dans vos applications. Pour un déploiement en production, explorez les options de licence qui s'adaptent à vos besoins, soutenues par l'assistance technique réactive d'IronPDF.

Génération dynamique de PDF .NET à l'aide d'IronPDF : Image 9 - Licence

Questions Fréquemment Posées

Qu'est-ce que la génération dynamique de PDF ?

La génération dynamique de PDF fait référence à la création de documents PDF à la volée sur la base d'entrées de données en temps réel, plutôt qu'à l'utilisation de modèles statiques préexistants.

Comment IronPDF peut-il aider à la génération dynamique de PDF en .NET ?

IronPDF simplifie la génération dynamique de PDF en permettant aux développeurs de créer des PDF à partir de HTML, d'images ou d'autres sources, en se concentrant sur la logique métier plutôt que sur le rendu complexe des PDF.

Quels sont les avantages de l'utilisation d'IronPdf pour la génération de PDF dynamiques ?

L'utilisation d'IronPDF pour les PDF dynamiques permet la personnalisation, l'intégration de données en temps réel et la réduction de la complexité de la création de documents PDF directement à partir d'applications .NET.

IronPDF peut-il être utilisé pour générer des factures personnalisées dans une plateforme de commerce électronique ?

Oui, IronPDF peut générer dynamiquement des factures personnalisées en intégrant des données en temps réel, ce qui le rend idéal pour les plateformes de commerce électronique.

Quels types d'applications bénéficient de la génération dynamique de PDF ?

Les applications telles que les plateformes de commerce électronique, les systèmes de reporting et les plateformes éducatives bénéficient de la génération dynamique de PDF en fournissant des documents personnalisés en temps réel.

IronPDF est-il adapté à la génération de rapports PDF contenant des données en temps réel ?

Dans l'absolu, IronPDF est conçu pour générer des rapports PDF en tirant des données en temps réel, ce qui le rend parfait pour la génération dynamique de documents.

Comment IronPDF gère-t-il la complexité du rendu des fichiers PDF ?

IronPDF fait abstraction des complexités du rendu PDF, ce qui permet aux développeurs de se concentrer sur la logique commerciale de leur application tout en créant des PDF de haute qualité.

IronPDF peut-il créer des certificats de formation de manière dynamique ?

Oui, IronPDF peut générer des certificats éducatifs de manière dynamique en utilisant des entrées de données pour créer des certificats personnalisés et d'aspect professionnel.

IronPDF prend-il en charge la création de PDF à partir de contenu HTML ?

IronPDF prend en charge la création de PDF à partir de contenu HTML, ce qui permet aux développeurs de convertir des pages web ou des chaînes HTML directement au format PDF.

Comment IronPDF améliore-t-il la productivité des développeurs ?

IronPDF améliore la productivité des développeurs en fournissant une API simple pour la génération de PDF, réduisant ainsi le temps et les efforts nécessaires à la création de documents dynamiques.

Curtis Chau
Curtis Chau
  Discutez maintenant avec l'équipe d'ingénierie
Rédacteur technique

Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes ...

Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Essai gratuit