Comment générer des PDF de manière dynamique en .NET à l'aide d'IronPDF

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

La génération dynamique de PDF consiste à créer des documents PDF en temps réel, où chaque élément de contenu (noms, chiffres, dates, tableaux, graphiques) provient de données en direct plutôt que d'une mise en page fixe. La structure du document peut rester la même, mais son contenu change à chaque requête.

Voici les scénarios dans lesquels cette approche apporte le plus de valeur :

• Génération des factures : les lignes de facturation, les totaux, les taux de taxe et les conditions de paiement varient pour chaque transaction.
• Rapports financiers : graphiques et tableaux récapitulatifs extraits d'une base de données mise à jour en continu.
• Certificats et diplômes : les noms des bénéficiaires, les dates d'obtention et les détails des cours varient selon les dossiers.
• Documents juridiques : les contrats intègrent des clauses spécifiques au client et des règles de juridiction.
• Dossiers médicaux — les données démographiques des patients, les résultats des tests et les plans de soins nécessitent un formatage individuel

L'alternative classique consiste à maintenir une bibliothèque de modèles statiques et à les modifier manuellement pour chaque variante. Cette approche devient rapidement inadaptée à mesure que le volume de documents augmente et que les règles métier se multiplient. Avec le moteur de conversion HTML vers PDF d'IronPDF , vous écrivez la logique de génération une seule fois et produisez des milliers de PDF correctement formatés et aux données précises sans aucune intervention manuelle.

IronPDF fonctionne sous Windows, Linux, macOS, Docker et Azure – la même API fonctionne de manière identique sur toutes les plateformes. Cette cohérence multiplateforme signifie que vous pouvez développer localement et déployer sur un conteneur cloud sans aucun ajustement spécifique à la plateforme. La bibliothèque cible .NET 6 et versions ultérieures, prenant en charge à la fois les dernières versions de .NET et les versions à support à long terme.

Comment installer et configurer la bibliothèque ?

IronPDF est distribué sous forme de package NuGet et s'intègre à tout projet .NET 6 ou ultérieur, y compris ASP.NET Core, Blazor et les applications console. Installez-le via la console du gestionnaire de packages ou l'interface de ligne de commande .NET :

Install-Package IronPdf
dotnet add package IronPdf

Install-Package IronPdf
dotnet add package IronPdf

Une fois le logiciel installé, vous pouvez commencer à générer des PDF immédiatement ; aucun fichier de configuration ni clé API n'est requis pendant la période d'essai gratuite. Pour obtenir une licence de production, rendez-vous sur la page des licences IronPDF et choisissez le forfait qui correspond à votre modèle de déploiement.

Le point d'entrée pour tout rendu est ChromePdfRenderer. L'extrait de code ci-dessous présente le code minimal nécessaire pour transformer une chaîne HTML dynamique en un fichier PDF enregistré :

using IronPdf;

var renderer = new ChromePdfRenderer();

var customerName = "Alexandra Chen";
var orderNumber = "ORD-2025-001";
var totalAmount = 1499.99m;

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>
    """;

var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("order-confirmation.pdf");

// Stream the bytes directly in a web response if needed
byte[] pdfBytes = pdf.BinaryData;

using IronPdf;

var renderer = new ChromePdfRenderer();

var customerName = "Alexandra Chen";
var orderNumber = "ORD-2025-001";
var totalAmount = 1499.99m;

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>
    """;

var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("order-confirmation.pdf");

// Stream the bytes directly in a web response if needed
byte[] pdfBytes = pdf.BinaryData;

Imports IronPdf

Dim renderer As New ChromePdfRenderer()

Dim customerName As String = "Alexandra Chen"
Dim orderNumber As String = "ORD-2025-001"
Dim totalAmount As Decimal = 1499.99D

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>
    "

Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("order-confirmation.pdf")

' Stream the bytes directly in a web response if needed
Dim pdfBytes As Byte() = pdf.BinaryData

ChromePdfRenderer gère toute la complexité du rendu en interne. L'interpolation de chaînes ($"""...""") insère des variables C# dans le HTML au point d'appel, ce qui permet de garder les modèles lisibles et d'éliminer une bibliothèque de modèles dédiée pour les cas simples.

Pour obtenir des instructions complètes sur la configuration, y compris la configuration des vues MVC et des projets serveur Blazor , consultez la documentation IronPDF .

Comment appliquer la génération de PDF à partir de modèles ?

La génération à partir de modèles dissocie la conception des documents de la liaison des données. Un concepteur crée la mise en page HTML une seule fois, en plaçant des espaces réservés nommés ({{TOKEN}}) là où les valeurs d'exécution doivent apparaître, et votre application remplace ces jetons avant le rendu. Il s'agit du modèle recommandé dans les discussions sur la génération de PDF sur Stack Overflow pour les projets où les modèles changent plus souvent que le code de l'application.

using IronPdf;

// Reusable template -- stored in a file or database in production
var htmlTemplate = """
    <style>
        .invoice { font-family: Arial; max-width: 800px; margin: auto; }
        .header  { background: #f0f0f0; padding: 20px; }
        .label   { font-weight: bold; }
    </style>
    <div class='invoice'>
        <div class='header'>
            <h2>Invoice #{{INVOICE_NUMBER}}</h2>
            <p>Date: {{INVOICE_DATE}}</p>
        </div>
        <p>Bill to: {{CUSTOMER_NAME}}</p>
        <p class='label'>Amount due: ${{TOTAL_AMOUNT}}</p>
    </div>
    """;

var invoiceHtml = htmlTemplate
    .Replace("{{INVOICE_NUMBER}}", "INV-2025-1234")
    .Replace("{{INVOICE_DATE}}", DateTime.Now.ToString("MMM dd, yyyy"))
    .Replace("{{CUSTOMER_NAME}}", "TechCorp Industries")
    .Replace("{{TOTAL_AMOUNT}}", "5,750.00");

var renderer = new ChromePdfRenderer();

renderer.RenderingOptions.TextHeader = new TextHeaderFooter
{
    CenterText    = "Invoice",
    DrawDividerLine = true
};

var pdf = renderer.RenderHtmlAsPdf(invoiceHtml);
pdf.SaveAs("invoice.pdf");

using IronPdf;

// Reusable template -- stored in a file or database in production
var htmlTemplate = """
    <style>
        .invoice { font-family: Arial; max-width: 800px; margin: auto; }
        .header  { background: #f0f0f0; padding: 20px; }
        .label   { font-weight: bold; }
    </style>
    <div class='invoice'>
        <div class='header'>
            <h2>Invoice #{{INVOICE_NUMBER}}</h2>
            <p>Date: {{INVOICE_DATE}}</p>
        </div>
        <p>Bill to: {{CUSTOMER_NAME}}</p>
        <p class='label'>Amount due: ${{TOTAL_AMOUNT}}</p>
    </div>
    """;

var invoiceHtml = htmlTemplate
    .Replace("{{INVOICE_NUMBER}}", "INV-2025-1234")
    .Replace("{{INVOICE_DATE}}", DateTime.Now.ToString("MMM dd, yyyy"))
    .Replace("{{CUSTOMER_NAME}}", "TechCorp Industries")
    .Replace("{{TOTAL_AMOUNT}}", "5,750.00");

var renderer = new ChromePdfRenderer();

renderer.RenderingOptions.TextHeader = new TextHeaderFooter
{
    CenterText    = "Invoice",
    DrawDividerLine = true
};

var pdf = renderer.RenderHtmlAsPdf(invoiceHtml);
pdf.SaveAs("invoice.pdf");

Imports IronPdf

' Reusable template -- stored in a file or database in production
Dim htmlTemplate As String = "
    <style>
        .invoice { font-family: Arial; max-width: 800px; margin: auto; }
        .header  { background: #f0f0f0; padding: 20px; }
        .label   { font-weight: bold; }
    </style>
    <div class='invoice'>
        <div class='header'>
            <h2>Invoice #{{INVOICE_NUMBER}}</h2>
            <p>Date: {{INVOICE_DATE}}</p>
        </div>
        <p>Bill to: {{CUSTOMER_NAME}}</p>
        <p class='label'>Amount due: ${{TOTAL_AMOUNT}}</p>
    </div>
    "

Dim invoiceHtml As String = htmlTemplate _
    .Replace("{{INVOICE_NUMBER}}", "INV-2025-1234") _
    .Replace("{{INVOICE_DATE}}", DateTime.Now.ToString("MMM dd, yyyy")) _
    .Replace("{{CUSTOMER_NAME}}", "TechCorp Industries") _
    .Replace("{{TOTAL_AMOUNT}}", "5,750.00")

Dim renderer As New ChromePdfRenderer()

renderer.RenderingOptions.TextHeader = New TextHeaderFooter With {
    .CenterText = "Invoice",
    .DrawDividerLine = True
}

Dim pdf = renderer.RenderHtmlAsPdf(invoiceHtml)
pdf.SaveAs("invoice.pdf")

Les jetons ({{...}}) marquent exactement où les données entrent dans le document, rendant les modèles lisibles par les non-développeurs. Le stockage des modèles sous forme de fichiers externes permet à un concepteur de mettre à jour la mise en page sans toucher au code source de l'application. Pour une explication plus détaillée de ce modèle, consultez le tutoriel sur le modèle IronPDF .

Comment générer des PDF par programmation à partir de données ?

Lorsque le contenu du document dépend de boucles, d'agrégations ou d'une mise en forme conditionnelle, la construction de la chaîne HTML dans le code vous offre le plus de contrôle. Cette approche est courante dans les rapports financiers et opérationnels où le nombre de lignes est inconnu à la compilation. Elle permet également d'appliquer directement les règles de mise en forme en C# plutôt que de les intégrer dans un modèle statique.

using IronPdf;
using System.Text;

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 }
};

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><th>Qty</th><th>Unit Price</th><th>Total</th>");
sb.Append("</tr>");

decimal grandTotal = 0;
foreach (var item in orderItems)
{
    var lineTotal = item.Quantity * item.Price;
    grandTotal += lineTotal;
    sb.Append($"""
        <tr>
            <td style='padding:10px;'>{item.Product}</td>
            <td style='text-align:center;'>{item.Quantity}</td>
            <td style='text-align:right;'>${item.Price:F2}</td>
            <td style='text-align:right;'>${lineTotal:F2}</td>
        </tr>
        """);
}

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

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(sb.ToString());

pdf.SaveAs("order-summary.pdf");

// Get bytes for a web download response
byte[] pdfData = pdf.BinaryData;

using IronPdf;
using System.Text;

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 }
};

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><th>Qty</th><th>Unit Price</th><th>Total</th>");
sb.Append("</tr>");

decimal grandTotal = 0;
foreach (var item in orderItems)
{
    var lineTotal = item.Quantity * item.Price;
    grandTotal += lineTotal;
    sb.Append($"""
        <tr>
            <td style='padding:10px;'>{item.Product}</td>
            <td style='text-align:center;'>{item.Quantity}</td>
            <td style='text-align:right;'>${item.Price:F2}</td>
            <td style='text-align:right;'>${lineTotal:F2}</td>
        </tr>
        """);
}

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

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(sb.ToString());

pdf.SaveAs("order-summary.pdf");

// Get bytes for a web download response
byte[] pdfData = pdf.BinaryData;

Imports IronPdf
Imports System.Text

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}
}

Dim 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><th>Qty</th><th>Unit Price</th><th>Total</th>")
sb.Append("</tr>")

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

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

Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(sb.ToString())

pdf.SaveAs("order-summary.pdf")

' Get bytes for a web download response
Dim pdfData As Byte() = pdf.BinaryData

StringBuilder gère efficacement les grandes chaînes HTML. La boucle foreach s'étend à autant de lignes que votre source de données le permet, et le calcul en cours grandTotal montre comment la logique métier s'intègre naturellement à la construction HTML. Pour les très grands ensembles de données, cette approche se combine bien avec les options de rendu multipages d'IronPDF .

Comment gérer les tableaux dynamiques qui s'étendent sur plusieurs pages ?

Les rapports générés à partir de bases de données contiennent souvent un nombre de lignes imprévisible. La gestion correcte des sauts de page automatiques (sans couper une ligne en deux) nécessite un CSS spécifique en plus des options de rendu d'IronPDF. La règle page-break-inside: avoid, combinée à une configuration de marge correcte, permet de conserver chaque ligne intacte lorsque le tableau se déroule sur plusieurs pages.

using IronPdf;

var salesData = Enumerable.Range(1, 30).Select(i => new
{
    Month   = $"Month {i}",
    Revenue = 10_000 + (i * 500),
    Growth  = 2.5 + (i * 0.3)
});

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; }
    </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)
{
    tableHtml += $"""
        <tr>
            <td>{row.Month}</td>
            <td>${row.Revenue:N0}</td>
            <td>{row.Growth:F1}%</td>
        </tr>
        """;
}

tableHtml += "</tbody></table>";

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize   = IronPdf.Rendering.PdfPaperSize.A4;
renderer.RenderingOptions.MarginTop    = 40;
renderer.RenderingOptions.MarginBottom = 40;

renderer.RenderingOptions.TextFooter = new TextHeaderFooter
{
    CenterText = "{page} of {total-pages}",
    FontSize   = 10
};

var pdf = renderer.RenderHtmlAsPdf(tableHtml);
pdf.SaveAs("sales-report.pdf");

using IronPdf;

var salesData = Enumerable.Range(1, 30).Select(i => new
{
    Month   = $"Month {i}",
    Revenue = 10_000 + (i * 500),
    Growth  = 2.5 + (i * 0.3)
});

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; }
    </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)
{
    tableHtml += $"""
        <tr>
            <td>{row.Month}</td>
            <td>${row.Revenue:N0}</td>
            <td>{row.Growth:F1}%</td>
        </tr>
        """;
}

tableHtml += "</tbody></table>";

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.PaperSize   = IronPdf.Rendering.PdfPaperSize.A4;
renderer.RenderingOptions.MarginTop    = 40;
renderer.RenderingOptions.MarginBottom = 40;

renderer.RenderingOptions.TextFooter = new TextHeaderFooter
{
    CenterText = "{page} of {total-pages}",
    FontSize   = 10
};

var pdf = renderer.RenderHtmlAsPdf(tableHtml);
pdf.SaveAs("sales-report.pdf");

Imports IronPdf

Dim salesData = Enumerable.Range(1, 30).Select(Function(i) New With {
    .Month = $"Month {i}",
    .Revenue = 10000 + (i * 500),
    .Growth = 2.5 + (i * 0.3)
})

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; }
    </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
    tableHtml += $"
        <tr>
            <td>{row.Month}</td>
            <td>${row.Revenue:N0}</td>
            <td>{row.Growth:F1}%</td>
        </tr>
        "
Next

tableHtml += "</tbody></table>"

Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4
renderer.RenderingOptions.MarginTop = 40
renderer.RenderingOptions.MarginBottom = 40

renderer.RenderingOptions.TextFooter = New TextHeaderFooter With {
    .CenterText = "{page} of {total-pages}",
    .FontSize = 10
}

Dim pdf = renderer.RenderHtmlAsPdf(tableHtml)
pdf.SaveAs("sales-report.pdf")

{page} et {total-pages} sont des jetons intégrés d'IronPDF pour la numérotation automatique du pied de page. Les marges empêchent le contenu de déborder sur chaque page, ce qui donne au rapport final une apparence Professional même lorsque le tableau s'étend sur des dizaines de pages.

Pour obtenir des conseils de mise en forme sur les mises en page de tableaux complexes, y compris les cellules fusionnées, reportez-vous à la référence des options de rendu IronPDF .

Comment ajouter du contenu conditionnel à un PDF ?

De nombreux types de documents comportent des sections qui ne doivent apparaître que lorsque certaines conditions sont remplies : un badge premium pour les clients haut de gamme, un blocage de réduction lorsqu'une promotion s'applique, un avertissement lorsqu'un compte est en retard de paiement. La logique conditionnelle de C# correspond directement à cette exigence, et comme la condition est évaluée avant la construction de la chaîne HTML, aucun élément d'espace réservé vide ne se retrouve dans le PDF final.

using IronPdf;

var customer = new
{
    Name           = "Global Tech Solutions",
    IsPremium      = true,
    HasDiscount    = true,
    DiscountPct    = 15,
    LoyaltyPoints  = 2500
};

var html = $"""<h2>Customer Profile: {customer.Name}</h2><div style='border:1px solid #ddd; padding:20px;'>""";

if (customer.IsPremium)
{
    html += """<div style='background:gold; padding:10px; margin-bottom:10px;'>PREMIUM MEMBER -- Exclusive benefits applied</div>""";
}

if (customer.HasDiscount)
{
    html += $"""<div style='background:#e8f5e9; padding:10px; margin-bottom:10px;'>Special discount: {customer.DiscountPct}% off all orders</div>""";
}

if (customer.LoyaltyPoints > 0)
{
    html += $"""<div style='background:#f3e5f5; padding:10px;'>Loyalty points balance: {customer.LoyaltyPoints:N0} points</div>""";
}

html += "</div>";

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("customer-profile.pdf");

using IronPdf;

var customer = new
{
    Name           = "Global Tech Solutions",
    IsPremium      = true,
    HasDiscount    = true,
    DiscountPct    = 15,
    LoyaltyPoints  = 2500
};

var html = $"""<h2>Customer Profile: {customer.Name}</h2><div style='border:1px solid #ddd; padding:20px;'>""";

if (customer.IsPremium)
{
    html += """<div style='background:gold; padding:10px; margin-bottom:10px;'>PREMIUM MEMBER -- Exclusive benefits applied</div>""";
}

if (customer.HasDiscount)
{
    html += $"""<div style='background:#e8f5e9; padding:10px; margin-bottom:10px;'>Special discount: {customer.DiscountPct}% off all orders</div>""";
}

if (customer.LoyaltyPoints > 0)
{
    html += $"""<div style='background:#f3e5f5; padding:10px;'>Loyalty points balance: {customer.LoyaltyPoints:N0} points</div>""";
}

html += "</div>";

var renderer = new ChromePdfRenderer();
var pdf = renderer.RenderHtmlAsPdf(html);
pdf.SaveAs("customer-profile.pdf");

Imports IronPdf

Dim customer = New With {
    .Name = "Global Tech Solutions",
    .IsPremium = True,
    .HasDiscount = True,
    .DiscountPct = 15,
    .LoyaltyPoints = 2500
}

Dim html = $"<h2>Customer Profile: {customer.Name}</h2><div style='border:1px solid #ddd; padding:20px;'>"

If customer.IsPremium Then
    html += "<div style='background:gold; padding:10px; margin-bottom:10px;'>PREMIUM MEMBER -- Exclusive benefits applied</div>"
End If

If customer.HasDiscount Then
    html += $"<div style='background:#e8f5e9; padding:10px; margin-bottom:10px;'>Special discount: {customer.DiscountPct}% off all orders</div>"
End If

If customer.LoyaltyPoints > 0 Then
    html += $"<div style='background:#f3e5f5; padding:10px;'>Loyalty points balance: {customer.LoyaltyPoints:N0} points</div>"
End If

html += "</div>"

Dim renderer = New ChromePdfRenderer()
Dim pdf = renderer.RenderHtmlAsPdf(html)
pdf.SaveAs("customer-profile.pdf")

Vous pouvez étendre ce même modèle à tout contenu basé sur des règles : mentions légales spécifiques à une juridiction, sections promotionnelles déclenchées par la valeur du panier ou avertissements de sécurité déclenchés par la catégorie de produit. Le fichier PDF obtenu contient exactement le contenu attendu – ni plus, ni moins.

Comment intégrer des graphiques JavaScript dans un PDF ?

Les tableaux de bord modernes utilisent souvent des bibliothèques graphiques JavaScript telles que Chart.js ou D3.js pour afficher les graphiques au moment du rendu. IronPDF peut exécuter le JavaScript avant la capture de la page, ce qui permet d'afficher entièrement le graphique avant la prise de l'instantané PDF. Cela signifie que vous n'avez pas besoin d'un service de capture d'écran distinct ni d'une bibliothèque de rendu de graphiques côté serveur.

using IronPdf;

var chartHtml = """
    <script src='https://cdn.jsdelivr.net/npm/chart.js'></script>
    <canvas id='revenueChart' width='500' height='250'></canvas>
    <script>
        var ctx = document.getElementById('revenueChart').getContext('2d');
        new Chart(ctx, {
            type: 'bar',
            data: {
                labels: ['Q1', 'Q2', 'Q3', 'Q4'],
                datasets: [{
                    label: 'Revenue (thousands)',
                    data: [120, 195, 230, 285],
                    backgroundColor: '#3498db'
                }]
            },
            options: { animation: false }
        });
    </script>
    """;

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor.RenderDelay(1500);

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='revenueChart' width='500' height='250'></canvas>
    <script>
        var ctx = document.getElementById('revenueChart').getContext('2d');
        new Chart(ctx, {
            type: 'bar',
            data: {
                labels: ['Q1', 'Q2', 'Q3', 'Q4'],
                datasets: [{
                    label: 'Revenue (thousands)',
                    data: [120, 195, 230, 285],
                    backgroundColor: '#3498db'
                }]
            },
            options: { animation: false }
        });
    </script>
    """;

var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.WaitFor.RenderDelay(1500);

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='revenueChart' width='500' height='250'></canvas>
    <script>
        var ctx = document.getElementById('revenueChart').getContext('2d');
        new Chart(ctx, {
            type: 'bar',
            data: {
                labels: ['Q1', 'Q2', 'Q3', 'Q4'],
                datasets: [{
                    label: 'Revenue (thousands)',
                    data: [120, 195, 230, 285],
                    backgroundColor: '#3498db'
                }]
            },
            options: { animation: false }
        });
    </script>
    "

Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.EnableJavaScript = True
renderer.RenderingOptions.WaitFor.RenderDelay(1500)

Dim pdf = renderer.RenderHtmlAsPdf(chartHtml)
pdf.SaveAs("revenue-chart.pdf")

EnableJavaScript = true active l'exécution du script dans le moteur Chrome sans interface graphique. RenderDelay(1500) ajoute une pause de 1,5 seconde après le chargement de la page, laissant le temps au rendu asynchrone du graphique de se terminer avant la prise de la capture d'écran. Définir animation: false dans les options de Chart.js empêche la capture d'images animées en pleine transition.

Cette technique fonctionne avec n'importe quelle bibliothèque JavaScript . Vous pouvez transmettre des données côté serveur au bloc <script> en utilisant l'interpolation de chaînes C#, afin que chaque graphique reflète les chiffres de la base de données en direct au moment de sa génération. Pour plus de détails sur la configuration JavaScript , consultez le guide de rendu JavaScript d'IronPDF .

Comment exporter et livrer le PDF généré ?

Une fois que RenderHtmlAsPdf renvoie un objet PdfDocument, vous disposez de plusieurs options de livraison en fonction du type de votre application. L'enregistrement sur disque est la méthode la plus simple et convient aux tâches par lots en arrière-plan. Pour les API web et les contrôleurs MVC, le flux direct des octets vers la réponse HTTP évite l'écriture de fichiers temporaires et maintient le système de fichiers du serveur propre.

using IronPdf;
using Microsoft.AspNetCore.Mvc;

// In an ASP.NET Core controller action:
public IActionResult DownloadInvoice(int orderId)
{
    var renderer = new ChromePdfRenderer();
    var html     = BuildInvoiceHtml(orderId);   // your data-binding method
    var pdf      = renderer.RenderHtmlAsPdf(html);

    return File(pdf.BinaryData, "application/pdf", $"invoice-{orderId}.pdf");
}

using IronPdf;
using Microsoft.AspNetCore.Mvc;

// In an ASP.NET Core controller action:
public IActionResult DownloadInvoice(int orderId)
{
    var renderer = new ChromePdfRenderer();
    var html     = BuildInvoiceHtml(orderId);   // your data-binding method
    var pdf      = renderer.RenderHtmlAsPdf(html);

    return File(pdf.BinaryData, "application/pdf", $"invoice-{orderId}.pdf");
}

Imports IronPdf
Imports Microsoft.AspNetCore.Mvc

' In an ASP.NET Core controller action:
Public Function DownloadInvoice(orderId As Integer) As IActionResult
    Dim renderer = New ChromePdfRenderer()
    Dim html = BuildInvoiceHtml(orderId)   ' your data-binding method
    Dim pdf = renderer.RenderHtmlAsPdf(html)

    Return File(pdf.BinaryData, "application/pdf", $"invoice-{orderId}.pdf")
End Function

pdf.BinaryData renvoie les octets bruts sous la forme d'un byte[], qui correspond directement au résultat File() d' ASP.NET Core. Le navigateur reçoit le type MIME correct (application/pdf) et déclenche une boîte de dialogue de téléchargement avec un nom de fichier significatif.

Les fonctionnalités de sortie supplémentaires incluent la fusion de PDF , les signatures numériques , le format d'archivage PDF/A , la protection par mot de passe et l'extraction de texte et d'images . Ces fonctionnalités fonctionnent sur le même objet PdfDocument renvoyé par le moteur de rendu, vous pouvez donc enchaîner les opérations sans créer de fichiers intermédiaires.

Quelles sont vos prochaines étapes ?

La génération dynamique de PDF dans .NET se résume à trois éléments constitutifs : une chaîne HTML qui varie en fonction de vos données, ChromePdfRenderer pour convertir cette chaîne en PDF, et le mécanisme de distribution adapté à votre application. IronPDF gère tout le reste : les sauts de page, les en-têtes et pieds de page, l'exécution de JavaScript et la compatibilité multiplateforme.

Pour passer de la lecture à la construction, commencez par installer le package et exécutez l'un des exemples ci-dessus avec vos propres données :

dotnet add package IronPdf

dotnet add package IronPdf

À partir de là, consultez la documentation IronPDF pour la configuration spécifique à la plateforme (Azure, Docker, Linux), les options de rendu avancées et la référence API complète. Lorsque vous serez prêt à déployer votre solution, rendez-vous sur la page des licences pour choisir un forfait adapté à votre volume de production. L' essai gratuit vous donne un accès complet sans carte de crédit, vous permettant ainsi de valider votre implémentation avant de vous engager.

Guides complémentaires qui se marient bien avec la génération dynamique :

• Générer un PDF à partir d'un modèle HTML en C#
• Convertir une URL en PDF
• Fusionner et diviser des documents PDF
• Ajouter des signatures numériques aux PDF
• Conformité PDF/A pour les documents d'archives