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 en C#
UTILISATION DE IRONPDF

Comment générer dynamiquement des PDF en C# à l'aide d'IronPDF

Curtis Chau
Curtis Chau
Mis à jour:

IronPDF permet la création dynamique de PDF en C# en convertissant le contenu HTML en PDF lors de l'exécution grâce au rendu basé sur Chrome. Cela permet la création de documents personnalisés avec des données variables provenant de bases de données, d'API ou de saisies utilisateur pour les factures, les rapports et les formulaires dans les applications .NET .

Les applications web modernes nécessitent plus que la simple création de documents statiques. Qu'il s'agisse de générer des factures personnalisées, de créer des rapports PDF basés sur des données ou de produire des champs de formulaire personnalisés, des outils fiables sont indispensables pour la génération dynamique de documents PDF. IronPDF est une solution de pointe offrant un rendu efficace sous Chrome pour la création de documents PDF, avec une intégration C# fluide pour la génération dynamique de PDF dans les environnements .NET .

La bannière promotionnelle de la bibliothèque PDF IronPDF C# présente ses principales fonctionnalités : conversion HTML vers PDF, API d'édition PDF, options de déploiement cloud et offre d'essai gratuit.

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

La génération dynamique de PDF en C# consiste à créer des documents PDF à l'exécution en utilisant des données variables provenant de bases de données, d'API ou de saisies utilisateur. Contrairement aux fichiers PDF statiques, la génération dynamique permet un contenu personnalisé, des sections conditionnelles et des mises en page basées sur les données. Ces fonctionnalités sont essentielles pour les factures, les rapports PDF , les certificats et les formulaires qui s'adaptent à l'évolution des besoins. Cette approche est devenue cruciale pour les applications modernes .NET et .NET Core . La documentation IronPDF fournit des guides complets pour implémenter ces fonctionnalités dans vos applications C#.

Tableau de compatibilité multiplateforme IronPDF montrant la prise en charge de plusieurs versions de .NET , langages de programmation, systèmes d'exploitation et environnements de déploiement, y compris les plateformes cloud

Quand faut-il utiliser la génération dynamique de PDF ?

La génération dynamique de PDF est essentielle lorsque votre application nécessite des documents personnalisés qui changent en fonction des données utilisateur ou de la logique métier. Les scénarios courants incluent la génération de rapports mensuels avec mises à jour automatiques des données, la création de factures avec des informations spécifiques au client, la production de certificats avec des noms de destinataires uniques et la création de formulaires préremplis en fonction des profils des utilisateurs. Si votre contenu varie à chaque requête ou nécessite une intégration de données en temps réel, la génération dynamique est plus efficace que les modèles statiques. Envisagez le traitement asynchrone pour les scénarios à volume élevé et explorez les techniques d'optimisation des performances pour les applications Enterprise .

Qu'est-ce qui différencie les PDF dynamiques des PDF statiques ?

Les fichiers PDF statiques restent inchangés après leur création, à l'instar des documents papier traditionnels enregistrés numériquement. Les PDF dynamiques génèrent un contenu actualisé à chaque requête, en puisant dans des sources de données en temps réel. Par exemple, un catalogue de produits statique nécessite des mises à jour et une redistribution manuelles, tandis qu'un catalogue dynamique inclut automatiquement les prix, les niveaux de stock et les descriptions de produits les plus récents. Les PDF dynamiques peuvent également inclure des éléments interactifs, du contenu conditionnel et des mises en page personnalisées en fonction des préférences de l'utilisateur ou de ses autorisations d'accès. Découvrez plus d'informations sur les fonctionnalités de sécurité des fichiers PDF pour améliorer vos documents dynamiques.

Quels secteurs tirent le plus grand profit de la génération de PDF dynamiques ?

Les services financiers utilisent des PDF dynamiques pour les relevés de compte, les documents de prêt et les rapports réglementaires qui exigent une précision en temps réel. Les prestataires de soins de santé génèrent les dossiers des patients, les résultats de laboratoire et les formulaires d'assurance en respectant les normes de sécurité HIPAA. Les plateformes de commerce électronique créent des confirmations de commande, des étiquettes d'expédition et des autorisations de retour. Les établissements d'enseignement produisent des relevés de notes, des certificats et du matériel pédagogique personnalisé. Les organismes gouvernementaux simplifient les demandes de permis, les formulaires fiscaux et les documents de conformité grâce à la génération automatisée. Les démonstrations IronPDF illustrent des applications concrètes dans ces secteurs d'activité.

Comment débuter avec une bibliothèque PDF en C# ?

Commencez par installer le package NuGet IronPDF via la console du gestionnaire de packages dans Visual Studio :

Install-Package IronPdf
Install-Package IronPdf
SHELL 
dotnet add package IronPdf
dotnet add package IronPdf
SHELL

Fenêtre de la console du gestionnaire de packages affichant le processus d'installation du package NuGet IronPDF , montrant plusieurs téléchargements de dépendances et leurs tailles de fichiers

Ou utilisez l'interface du gestionnaire de packages NuGet pour télécharger et installer. Initialisez le ChromePdfRenderer pour une génération de PDF au pixel près :

using IronPdf;

// Create Chrome renderer instance
var renderer = new ChromePdfRenderer();

// Configure rendering options for PDF format
renderer.RenderingOptions.MarginTop = 50;
renderer.RenderingOptions.MarginBottom = 50;
renderer.RenderingOptions.PrintHtmlBackgrounds = true;
using IronPdf;

// Create Chrome renderer instance
var renderer = new ChromePdfRenderer();

// Configure rendering options for PDF format
renderer.RenderingOptions.MarginTop = 50;
renderer.RenderingOptions.MarginBottom = 50;
renderer.RenderingOptions.PrintHtmlBackgrounds = true;
Imports IronPdf

' Create Chrome renderer instance
Dim renderer As New ChromePdfRenderer()

' Configure rendering options for PDF format
renderer.RenderingOptions.MarginTop = 50
renderer.RenderingOptions.MarginBottom = 50
renderer.RenderingOptions.PrintHtmlBackgrounds = True
$vbLabelText   $csharpLabel

La classe ChromePdfRenderer fournit les bases nécessaires à la génération de PDF à l'exécution. La définition des marges garantit l'espace pour les en-têtes et les pieds de page , tandis que PrintHtmlBackgrounds préserve les éléments de mise en page. Cette configuration aide à créer des documents PDF basés sur le contenu HTML exactement. Découvrez plus d' options de rendu pour personnaliser vos documents PDF.

Quelles sont les exigences système pour IronPDF?

IronPDF prend en charge les environnements Windows, Linux et macOS avec .NET Framework 4.6.2+ ou .NET Core 3.1+. Pour un déploiement sous Windows, assurez-vous que Visual C++ Runtime est installé. Les systèmes Linux nécessitent libgdiplus et des dépendances supplémentaires. Les conteneurs Docker nécessitent des images de base spécifiques avec des bibliothèques graphiques. Les plateformes cloud comme Azure nécessitent un niveau B1 ou supérieur, tandis que les fonctions AWS Lambda requièrent des environnements d'exécution personnalisés. Consultez le guide d'installation pour connaître les exigences spécifiques à la plateforme et obtenir des conseils de dépannage.

Comment configurer ChromePdfRenderer pour obtenir les meilleurs résultats ?

Améliorez votre moteur de rendu grâce à ces paramètres essentiels :

using IronPdf;

var renderer = new ChromePdfRenderer();

// Set paper size and orientation
renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter;
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait;

// Configure margins (in millimeters)
renderer.RenderingOptions.MarginTop = 25;
renderer.RenderingOptions.MarginBottom = 25;
renderer.RenderingOptions.MarginLeft = 20;
renderer.RenderingOptions.MarginRight = 20;

// Enable JavaScript execution
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.RenderDelay = 500; // milliseconds

// Set custom CSS media type
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;

// Configure image quality
renderer.RenderingOptions.ImageQuality = 90;
using IronPdf;

var renderer = new ChromePdfRenderer();

// Set paper size and orientation
renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter;
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait;

// Configure margins (in millimeters)
renderer.RenderingOptions.MarginTop = 25;
renderer.RenderingOptions.MarginBottom = 25;
renderer.RenderingOptions.MarginLeft = 20;
renderer.RenderingOptions.MarginRight = 20;

// Enable JavaScript execution
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.RenderDelay = 500; // milliseconds

// Set custom CSS media type
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;

// Configure image quality
renderer.RenderingOptions.ImageQuality = 90;
Imports IronPdf

Dim renderer As New ChromePdfRenderer()

' Set paper size and orientation
renderer.RenderingOptions.PaperSize = PdfPaperSize.Letter
renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait

' Configure margins (in millimeters)
renderer.RenderingOptions.MarginTop = 25
renderer.RenderingOptions.MarginBottom = 25
renderer.RenderingOptions.MarginLeft = 20
renderer.RenderingOptions.MarginRight = 20

' Enable JavaScript execution
renderer.RenderingOptions.EnableJavaScript = True
renderer.RenderingOptions.RenderDelay = 500 ' milliseconds

' Set custom CSS media type
renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print

' Configure image quality
renderer.RenderingOptions.ImageQuality = 90
$vbLabelText   $csharpLabel

Le RenderDelay permet à JavaScript de terminer son exécution avant le rendu. La sélection du type de média CSS garantit l'application des styles optimisés pour l'impression. Les paramètres de qualité d'image permettent d'équilibrer la taille du fichier et la fidélité visuelle. Explorez les options de rendu avancées pour répondre à des besoins spécifiques tels que les formats de papier personnalisés ou les paramètres de la fenêtre d'affichage. Découvrez le rendu JavaScript pour la génération de contenu dynamique.

Quels sont les problèmes d'installation courants à surveiller ?

La plupart des problèmes d'installation sont dus à des dépendances manquantes. Sous Windows, installez les composants redistribuables Visual C++. Les utilisateurs Linux doivent installer libgdiplus et les paquets de polices. Les déploiements Docker nécessitent des images de base spécifiques avec prise en charge graphique. Les plans de consommation doivent être désactivés pour Azure Functions. Vérifiez les paramètres du pare-feu pour la validation de la licence. Examinez les scénarios de dépannage courants et activez la journalisation pour obtenir des diagnostics détaillés.

Comment créer dynamiquement des documents PDF à partir de modèles ?

Créez des modèles HTML réutilisables avec des espaces réservés pour l'injection de données dynamiques :

using IronPdf;
using System.Text;

var renderer = new ChromePdfRenderer();

// Define HTML string template with placeholders
string invoiceTemplate = @"
<html>
<head>
    <style>
        body { font-family: Arial, sans-serif; margin: 40px; }
        .header { background-color: #f0f0f0; padding: 20px; }
        table { width: 100%; border-collapse: collapse; }
        th, td { padding: 10px; text-align: left; border-bottom: 1px solid #ddd; }
    </style>
</head>
<body>
    <div class='header'>
        <h1>Invoice #[[INVOICE_NUMBER]]</h1>
        <p>Date: [[DATE]]</p>
        <p>Customer: [[CUSTOMER_NAME]]</p>
    </div>
    <table>
        <tr><th>Item</th><th>Quantity</th><th>Price</th></tr>
        [[ITEMS]]
    </table>
    <p><strong>Total: $[[TOTAL]]</strong></p>
</body>
</html>";

// Replace placeholders with dynamic data
var invoiceData = new {
    InvoiceNumber = "INV-2025-001",
    Date = DateTime.Nonw.ToString("yyyy-MM-dd"),
    CustomerName = "John Doe",
    Total = 1250.00m
};

// Build items dynamically
var itemsHtml = new StringBuilder();
itemsHtml.Append("<tr><td>Web Development</td><td>40 hours</td><td>$1000.00</td></tr>");
itemsHtml.Append("<tr><td>Design Services</td><td>10 hours</td><td>$250.00</td></tr>");

string finalHtml = invoiceTemplate
    .Replace("[[INVOICE_NUMBER]]", invoiceData.InvoiceNumber)
    .Replace("[[DATE]]", invoiceData.Date)
    .Replace("[[CUSTOMER_NAME]]", invoiceData.CustomerName)
    .Replace("[[ITEMS]]", itemsHtml.ToString())
    .Replace("[[TOTAL]]", invoiceData.Total.ToString());

// Generate PDF from populated HTML content
var pdf = renderer.RenderHtmlAsPdf(finalHtml);
pdf.SaveAs("invoice.pdf");
using IronPdf;
using System.Text;

var renderer = new ChromePdfRenderer();

// Define HTML string template with placeholders
string invoiceTemplate = @"
<html>
<head>
    <style>
        body { font-family: Arial, sans-serif; margin: 40px; }
        .header { background-color: #f0f0f0; padding: 20px; }
        table { width: 100%; border-collapse: collapse; }
        th, td { padding: 10px; text-align: left; border-bottom: 1px solid #ddd; }
    </style>
</head>
<body>
    <div class='header'>
        <h1>Invoice #[[INVOICE_NUMBER]]</h1>
        <p>Date: [[DATE]]</p>
        <p>Customer: [[CUSTOMER_NAME]]</p>
    </div>
    <table>
        <tr><th>Item</th><th>Quantity</th><th>Price</th></tr>
        [[ITEMS]]
    </table>
    <p><strong>Total: $[[TOTAL]]</strong></p>
</body>
</html>";

// Replace placeholders with dynamic data
var invoiceData = new {
    InvoiceNumber = "INV-2025-001",
    Date = DateTime.Nonw.ToString("yyyy-MM-dd"),
    CustomerName = "John Doe",
    Total = 1250.00m
};

// Build items dynamically
var itemsHtml = new StringBuilder();
itemsHtml.Append("<tr><td>Web Development</td><td>40 hours</td><td>$1000.00</td></tr>");
itemsHtml.Append("<tr><td>Design Services</td><td>10 hours</td><td>$250.00</td></tr>");

string finalHtml = invoiceTemplate
    .Replace("[[INVOICE_NUMBER]]", invoiceData.InvoiceNumber)
    .Replace("[[DATE]]", invoiceData.Date)
    .Replace("[[CUSTOMER_NAME]]", invoiceData.CustomerName)
    .Replace("[[ITEMS]]", itemsHtml.ToString())
    .Replace("[[TOTAL]]", invoiceData.Total.ToString());

// Generate PDF from populated HTML content
var pdf = renderer.RenderHtmlAsPdf(finalHtml);
pdf.SaveAs("invoice.pdf");
Imports IronPdf
Imports System.Text

Dim renderer As New ChromePdfRenderer()

' Define HTML string template with placeholders
Dim invoiceTemplate As String = "
<html>
<head>
    <style>
        body { font-family: Arial, sans-serif; margin: 40px; }
        .header { background-color: #f0f0f0; padding: 20px; }
        table { width: 100%; border-collapse: collapse; }
        th, td { padding: 10px; text-align: left; border-bottom: 1px solid #ddd; }
    </style>
</head>
<body>
    <div class='header'>
        <h1>Invoice #[[INVOICE_NUMBER]]</h1>
        <p>Date: [[DATE]]</p>
        <p>Customer: [[CUSTOMER_NAME]]</p>
    </div>
    <table>
        <tr><th>Item</th><th>Quantity</th><th>Price</th></tr>
        [[ITEMS]]
    </table>
    <p><strong>Total: $[[TOTAL]]</strong></p>
</body>
</html>"

' Replace placeholders with dynamic data
Dim invoiceData = New With {
    .InvoiceNumber = "INV-2025-001",
    .Date = DateTime.Now.ToString("yyyy-MM-dd"),
    .CustomerName = "John Doe",
    .Total = 1250.0D
}

' Build items dynamically
Dim itemsHtml As New StringBuilder()
itemsHtml.Append("<tr><td>Web Development</td><td>40 hours</td><td>$1000.00</td></tr>")
itemsHtml.Append("<tr><td>Design Services</td><td>10 hours</td><td>$250.00</td></tr>")

Dim finalHtml As String = invoiceTemplate _
    .Replace("[[INVOICE_NUMBER]]", invoiceData.InvoiceNumber) _
    .Replace("[[DATE]]", invoiceData.Date) _
    .Replace("[[CUSTOMER_NAME]]", invoiceData.CustomerName) _
    .Replace("[[ITEMS]]", itemsHtml.ToString()) _
    .Replace("[[TOTAL]]", invoiceData.Total.ToString())

' Generate PDF from populated HTML content
Dim pdf = renderer.RenderHtmlAsPdf(finalHtml)
pdf.SaveAs("invoice.pdf")
$vbLabelText   $csharpLabel

Cette approche de modèle sépare la présentation des données, permettant aux designers de modifier des mises en page complexes tandis que les développeurs se concentrent sur l'intégration des données. La méthode Replace remplace les espaces réservés par des valeurs d'exécution, créant ainsi des documents PDF personnalisés. Pour convertir du contenu HTML avec des sections répétitives, construisez le HTML dynamiquement en utilisant des boucles avant la conversion en PDF. Explorez davantage d'exemples de conversion HTML vers PDF pour découvrir des techniques de modélisation avancées, notamment le style CSS et l'intégration JavaScript .

Sortie

PDF viewer showing a generated invoice with number INV-2025-001, displaying customer details and a total of $1250.00, with Iron Software watermarks visible

Pourquoi utiliser la génération de PDF à partir de modèles ?

La génération basée sur des modèles sépare la logique métier de la présentation, permettant ainsi des flux de travail de développement parallèles. Les concepteurs peuvent perfectionner les mises en page HTML à l'aide d'outils familiers tandis que les développeurs mettent en œuvre la liaison de données. Les modèles prennent en charge le contrôle de version, les tests A/B et la localisation sans modification du code. Les composants réutilisables permettent de réduire les doublons et les coûts de maintenance. Les requêtes média CSS garantissent que les designs responsifs se traduisent parfaitement en sortie PDF. Cette approche s'adapte aussi bien aux simples lettres qu'aux rapports complexes de plusieurs pages, tout en conservant une image de marque cohérente. Explorez les techniques de filigrane pour répondre aux exigences en matière de branding.

Comment gérer des structures de données complexes dans les modèles ?

Traiter les données hiérarchiques en construisant des sections HTML par programmation avant l'injection du modèle. Utilisez les requêtes LINQ pour transformer les collections en tableaux ou listes HTML. Implémentez le rendu conditionnel avec des instructions if qui incluent ou excluent des sections de modèle. Pour les données imbriquées, créez des sous-modèles qui construisent le contenu de manière récursive. Envisagez d'utiliser la syntaxe Razor pour la logique complexe au sein des modèles. La sérialisation JSON permet de transmettre des données structurées à des modèles enrichis en JavaScript. Créez des méthodes d'assistance qui convertissent les objets de domaine en fragments HTML pour une organisation du code plus propre.

Quelles sont les meilleures pratiques pour la conception d'espaces réservés aux modèles ?

Choisissez une syntaxe d'espace réservé distinctive qui ne sera pas en conflit avec HTML ou CSS, comme [[FIELD_NAME]] ou {{field}}. Utilisez des noms descriptifs indiquant les types de données et les attentes en matière de formatage. Espaces réservés liés au groupe avec des préfixes (CUSTOMER_NAME, CUSTOMER_EMAIL). Documentez les espaces réservés disponibles et leurs sources de données à titre de référence pour l'équipe. Mettez en place des valeurs de repli pour les champs optionnels afin d'éviter les erreurs d'affichage. Envisagez l'encodage HTML pour le contenu généré par les utilisateurs afin de prévenir les attaques par injection. Créez des méthodes de validation de modèles qui vérifient que tous les espaces réservés possèdent des valeurs de données correspondantes.

Comment optimiser la génération de PDF grâce au traitement asynchrone ?

Augmentez la capacité de génération de PDF grâce aux méthodes asynchrones pour le traitement de volumes importants :

using IronPdf;

// Async batch generation for multiple PDF documents
async Task GenerateMonthlyReportsAsync(List<Customer> customers)
{
    var renderer = new ChromePdfRenderer();

    // Configure for batch processing
    renderer.RenderingOptions.EnableJavaScript = false; // Faster without JS
    renderer.RenderingOptions.RenderDelay = 0;

    var semaphore = new SemaphoreSlim(5); // Limit concurrent operations
    var tasks = new List<Task>();

    foreach (var customer in customers)
    {
        tasks.Add(Task.Run(async () =>
        {
            await semaphore.WaitAsync();
            try
            {
                string html = $@"
                    <html>
                    <head>
                        <style>
                            body {{ font-family: Arial; margin: 40px; }}
                            .header {{ color: #333; border-bottom: 2px solid #4CAF50; }}
                            .metric-box {{
                                display: inline-block;
                                padding: 20px;
                                margin: 10px;
                                background: #f5f5f5;
                                border-radius: 5px;
                            }}
                        </style>
                    </head>
                    <body>
                        <div class='header'>
                            <h2>Monthly Report - {customer.Name}</h2>
                            <p>Report Period: {DateTime.Nonw:MMMM yyyy}</p>
                        </div>
                        <div class='metrics'>
                            <div class='metric-box'>
                                <h3>Account Balance</h3>
                                <p style='font-size: 24px; color: #4CAF50;'>${customer.Balance:F2}</p>
                            </div>
                            <div class='metric-box'>
                                <h3>Total Transactions</h3>
                                <p style='font-size: 24px; color: #2196F3;'>{customer.TransactionCount}</p>
                            </div>
                        </div>
                        <div style='page-break-after: always;'></div>
                    </body>
                    </html>";

                var document = await renderer.RenderHtmlAsPdfAsync(html);

                // Add metadata
                document.MetaData.Author = "Reporting System";
                document.MetaData.Title = $"Monthly Report - {customer.Name}";
                document.MetaData.CreationDate = DateTime.Nonw;

                await document.SaveAs($"reports/{customer.Id}_report_{DateTime.Nonw:yyyyMM}.pdf");
            }
            finally
            {
                semaphore.Release();
            }
        }));
    }

    await Task.WhenAll(tasks);
}
using IronPdf;

// Async batch generation for multiple PDF documents
async Task GenerateMonthlyReportsAsync(List<Customer> customers)
{
    var renderer = new ChromePdfRenderer();

    // Configure for batch processing
    renderer.RenderingOptions.EnableJavaScript = false; // Faster without JS
    renderer.RenderingOptions.RenderDelay = 0;

    var semaphore = new SemaphoreSlim(5); // Limit concurrent operations
    var tasks = new List<Task>();

    foreach (var customer in customers)
    {
        tasks.Add(Task.Run(async () =>
        {
            await semaphore.WaitAsync();
            try
            {
                string html = $@"
                    <html>
                    <head>
                        <style>
                            body {{ font-family: Arial; margin: 40px; }}
                            .header {{ color: #333; border-bottom: 2px solid #4CAF50; }}
                            .metric-box {{
                                display: inline-block;
                                padding: 20px;
                                margin: 10px;
                                background: #f5f5f5;
                                border-radius: 5px;
                            }}
                        </style>
                    </head>
                    <body>
                        <div class='header'>
                            <h2>Monthly Report - {customer.Name}</h2>
                            <p>Report Period: {DateTime.Nonw:MMMM yyyy}</p>
                        </div>
                        <div class='metrics'>
                            <div class='metric-box'>
                                <h3>Account Balance</h3>
                                <p style='font-size: 24px; color: #4CAF50;'>${customer.Balance:F2}</p>
                            </div>
                            <div class='metric-box'>
                                <h3>Total Transactions</h3>
                                <p style='font-size: 24px; color: #2196F3;'>{customer.TransactionCount}</p>
                            </div>
                        </div>
                        <div style='page-break-after: always;'></div>
                    </body>
                    </html>";

                var document = await renderer.RenderHtmlAsPdfAsync(html);

                // Add metadata
                document.MetaData.Author = "Reporting System";
                document.MetaData.Title = $"Monthly Report - {customer.Name}";
                document.MetaData.CreationDate = DateTime.Nonw;

                await document.SaveAs($"reports/{customer.Id}_report_{DateTime.Nonw:yyyyMM}.pdf");
            }
            finally
            {
                semaphore.Release();
            }
        }));
    }

    await Task.WhenAll(tasks);
}
Imports IronPdf

' Async batch generation for multiple PDF documents
Async Function GenerateMonthlyReportsAsync(customers As List(Of Customer)) As Task
    Dim renderer As New ChromePdfRenderer()

    ' Configure for batch processing
    renderer.RenderingOptions.EnableJavaScript = False ' Faster without JS
    renderer.RenderingOptions.RenderDelay = 0

    Dim semaphore As New SemaphoreSlim(5) ' Limit concurrent operations
    Dim tasks As New List(Of Task)()

    For Each customer In customers
        tasks.Add(Task.Run(Async Function()
                               Await semaphore.WaitAsync()
                               Try
                                   Dim html As String = $"
                    <html>
                    <head>
                        <style>
                            body {{ font-family: Arial; margin: 40px; }}
                            .header {{ color: #333; border-bottom: 2px solid #4CAF50; }}
                            .metric-box {{
                                display: inline-block;
                                padding: 20px;
                                margin: 10px;
                                background: #f5f5f5;
                                border-radius: 5px;
                            }}
                        </style>
                    </head>
                    <body>
                        <div class='header'>
                            <h2>Monthly Report - {customer.Name}</h2>
                            <p>Report Period: {DateTime.Now:MMMM yyyy}</p>
                        </div>
                        <div class='metrics'>
                            <div class='metric-box'>
                                <h3>Account Balance</h3>
                                <p style='font-size: 24px; color: #4CAF50;'>${customer.Balance:F2}</p>
                            </div>
                            <div class='metric-box'>
                                <h3>Total Transactions</h3>
                                <p style='font-size: 24px; color: #2196F3;'>{customer.TransactionCount}</p>
                            </div>
                        </div>
                        <div style='page-break-after: always;'></div>
                    </body>
                    </html>"

                                   Dim document = Await renderer.RenderHtmlAsPdfAsync(html)

                                   ' Add metadata
                                   document.MetaData.Author = "Reporting System"
                                   document.MetaData.Title = $"Monthly Report - {customer.Name}"
                                   document.MetaData.CreationDate = DateTime.Now

                                   Await document.SaveAs($"reports/{customer.Id}_report_{DateTime.Now:yyyyMM}.pdf")
                               Finally
                                   semaphore.Release()
                               End Try
                           End Function))
    Next

    Await Task.WhenAll(tasks)
End Function
$vbLabelText   $csharpLabel

Le modèle asynchrone permet la génération simultanée de PDF, améliorant considérablement le débit lors de la génération de documents PDF par lots. Task.WhenAll garantit que tous les fichiers PDF sont complets avant de continuer. Le code utilise les propriétés de saut de page CSS pour contrôler la pagination, garantissant ainsi que le rapport de chaque client commence sur une nouvelle page. Le SemaphoreSlim empêche l'épuisement de la mémoire en limitant les opérations simultanées. Consultez la documentation relative à la génération asynchrone de PDF pour les applications Web Enterprise .

Quand faut-il utiliser la génération de PDF asynchrone ?

Le traitement asynchrone est idéal pour les applications web où les opérations bloquantes ont un impact sur l'expérience utilisateur. Utilisez des méthodes asynchrones pour générer plusieurs documents simultanément, traiter des fichiers HTML volumineux ou intégrer des API externes lentes. Les services en arrière-plan tirent parti des modèles asynchrones pour la génération planifiée de rapports. Les gestionnaires de webhook peuvent traiter les requêtes sans délai d'expiration. Les opérations par lots, comme la facturation mensuelle, sont réalisées plus rapidement grâce au traitement parallèle. Cependant, la génération simple de documents uniques pourrait ne pas bénéficier de cette complexité supplémentaire.

Comment gérez-vous l'utilisation de la mémoire lors du traitement par lots ?

Mettre en œuvre des procédures d'élimination des ressources afin de les libérer rapidement. Utilisez les flux de mémoire plutôt que les opérations sur les fichiers pour le stockage temporaire. Configurer le nettoyage de la mémoire pour les charges de travail du serveur. Limitez les opérations simultanées avec SemaphoreSlim ou des mécanismes de limitation similaires. Surveillez l'utilisation de la mémoire à l'aide de compteurs de performance. Envisagez de diviser les grands ensembles de données en lots plus petits. Compressez les fichiers PDF de sortie afin de réduire les besoins de stockage. Consultez les guides d'optimisation des performances pour découvrir d'autres stratégies.

Quels indicateurs de performance devez-vous surveiller ?

Suivre le temps de génération des PDF par document afin d'identifier les goulots d'étranglement. Surveiller la consommation de mémoire pendant les pics de charge. Mesurer l'utilisation du processeur lors des opérations de rendu. Consignez les générations ayant échoué avec les détails des erreurs pour faciliter le dépannage. Calculer le débit en documents par minute. Surveillez le débit de stockage pour détecter les contraintes de capacité. Surveillez la latence du réseau lors du rendu d'URL externes. Configurez des alertes pour les délais d'attente de rendu ou la saturation de la mémoire. Utilisez la journalisation personnalisée pour capturer des indicateurs détaillés.

Comment créer des formulaires PDF interactifs de manière dynamique ?

Transformez les pages web avec formulaires HTML en PDFs remplissables de manière programmatique :

using IronPdf;

// Enable form fields creation in rendering options
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CreatePdfFormsFromHtml = true;

// Define HTML string with form elements
string formHtml = @"
<html>
<head>
    <style>
        body { font-family: Arial, sans-serif; margin: 40px; }
        form { background: #f9f9f9; padding: 30px; border-radius: 8px; }
        h2 { color: #333; margin-bottom: 20px; }
        label { display: block; margin: 15px 0 5px; font-weight: bold; }
        input[type='text'], input[type='email'], textarea, select {
            width: 100%;
            padding: 10px;
            border: 1px solid #ddd;
            border-radius: 4px;
            box-sizing: border-box;
        }
        textarea { height: 100px; resize: vertical; }
        input[type='checkbox'] { margin-right: 8px; }
        .checkbox-group { margin: 15px 0; }
        button {
            background: #4CAF50;
            color: white;
            padding: 12px 24px;
            border: none;
            border-radius: 4px;
            cursor: pointer;
            margin-top: 20px;
        }
    </style>
</head>
<body>
    <form>
        <h2>Customer Survey Form</h2>

        <label for='name'>Full Name:</label>
        <input type='text' id='name' name='name' required>

        <label for='email'>Email Address:</label>
        <input type='email' id='email' name='email' required>

        <label for='satisfaction'>Overall Satisfaction:</label>
        <select id='satisfaction' name='satisfaction'>
            <option value=''>Please select...</option>
            <option value='excellent'>Excellent</option>
            <option value='good'>Good</option>
            <option value='fair'>Fair</option>
            <option value='poor'>Poor</option>
        </select>

        <div class='checkbox-group'>
            <label>Services Used:</label>
            <label><input type='checkbox' name='services' value='support'> Technical Support</label>
            <label><input type='checkbox' name='services' value='training'> Training</label>
            <label><input type='checkbox' name='services' value='consulting'> Consulting</label>
        </div>

        <label for='comments'>Additional Comments:</label>
        <textarea id='comments' name='comments' placeholder='Share your feedback...'></textarea>

        <button type='submit'>Submit Survey</button>
    </form>
</body>
</html>";

// Create a PDF with interactive form fields
var pdfDocument = renderer.RenderHtmlAsPdf(formHtml);

// Set form field properties programmatically
var formManager = pdfDocument.Form;
formManager.FindField("name").Value = "";
formManager.FindField("email").Required = true;

// Save the interactive PDF
pdfDocument.SaveAs("customer_survey_form.pdf");
using IronPdf;

// Enable form fields creation in rendering options
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CreatePdfFormsFromHtml = true;

// Define HTML string with form elements
string formHtml = @"
<html>
<head>
    <style>
        body { font-family: Arial, sans-serif; margin: 40px; }
        form { background: #f9f9f9; padding: 30px; border-radius: 8px; }
        h2 { color: #333; margin-bottom: 20px; }
        label { display: block; margin: 15px 0 5px; font-weight: bold; }
        input[type='text'], input[type='email'], textarea, select {
            width: 100%;
            padding: 10px;
            border: 1px solid #ddd;
            border-radius: 4px;
            box-sizing: border-box;
        }
        textarea { height: 100px; resize: vertical; }
        input[type='checkbox'] { margin-right: 8px; }
        .checkbox-group { margin: 15px 0; }
        button {
            background: #4CAF50;
            color: white;
            padding: 12px 24px;
            border: none;
            border-radius: 4px;
            cursor: pointer;
            margin-top: 20px;
        }
    </style>
</head>
<body>
    <form>
        <h2>Customer Survey Form</h2>

        <label for='name'>Full Name:</label>
        <input type='text' id='name' name='name' required>

        <label for='email'>Email Address:</label>
        <input type='email' id='email' name='email' required>

        <label for='satisfaction'>Overall Satisfaction:</label>
        <select id='satisfaction' name='satisfaction'>
            <option value=''>Please select...</option>
            <option value='excellent'>Excellent</option>
            <option value='good'>Good</option>
            <option value='fair'>Fair</option>
            <option value='poor'>Poor</option>
        </select>

        <div class='checkbox-group'>
            <label>Services Used:</label>
            <label><input type='checkbox' name='services' value='support'> Technical Support</label>
            <label><input type='checkbox' name='services' value='training'> Training</label>
            <label><input type='checkbox' name='services' value='consulting'> Consulting</label>
        </div>

        <label for='comments'>Additional Comments:</label>
        <textarea id='comments' name='comments' placeholder='Share your feedback...'></textarea>

        <button type='submit'>Submit Survey</button>
    </form>
</body>
</html>";

// Create a PDF with interactive form fields
var pdfDocument = renderer.RenderHtmlAsPdf(formHtml);

// Set form field properties programmatically
var formManager = pdfDocument.Form;
formManager.FindField("name").Value = "";
formManager.FindField("email").Required = true;

// Save the interactive PDF
pdfDocument.SaveAs("customer_survey_form.pdf");
Imports IronPdf

' Enable form fields creation in rendering options
Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.CreatePdfFormsFromHtml = True

' Define HTML string with form elements
Dim formHtml As String = "
<html>
<head>
    <style>
        body { font-family: Arial, sans-serif; margin: 40px; }
        form { background: #f9f9f9; padding: 30px; border-radius: 8px; }
        h2 { color: #333; margin-bottom: 20px; }
        label { display: block; margin: 15px 0 5px; font-weight: bold; }
        input[type='text'], input[type='email'], textarea, select {
            width: 100%;
            padding: 10px;
            border: 1px solid #ddd;
            border-radius: 4px;
            box-sizing: border-box;
        }
        textarea { height: 100px; resize: vertical; }
        input[type='checkbox'] { margin-right: 8px; }
        .checkbox-group { margin: 15px 0; }
        button {
            background: #4CAF50;
            color: white;
            padding: 12px 24px;
            border: none;
            border-radius: 4px;
            cursor: pointer;
            margin-top: 20px;
        }
    </style>
</head>
<body>
    <form>
        <h2>Customer Survey Form</h2>

        <label for='name'>Full Name:</label>
        <input type='text' id='name' name='name' required>

        <label for='email'>Email Address:</label>
        <input type='email' id='email' name='email' required>

        <label for='satisfaction'>Overall Satisfaction:</label>
        <select id='satisfaction' name='satisfaction'>
            <option value=''>Please select...</option>
            <option value='excellent'>Excellent</option>
            <option value='good'>Good</option>
            <option value='fair'>Fair</option>
            <option value='poor'>Poor</option>
        </select>

        <div class='checkbox-group'>
            <label>Services Used:</label>
            <label><input type='checkbox' name='services' value='support'> Technical Support</label>
            <label><input type='checkbox' name='services' value='training'> Training</label>
            <label><input type='checkbox' name='services' value='consulting'> Consulting</label>
        </div>

        <label for='comments'>Additional Comments:</label>
        <textarea id='comments' name='comments' placeholder='Share your feedback...'></textarea>

        <button type='submit'>Submit Survey</button>
    </form>
</body>
</html>"

' Create a PDF with interactive form fields
Dim pdfDocument = renderer.RenderHtmlAsPdf(formHtml)

' Set form field properties programmatically
Dim formManager = pdfDocument.Form
formManager.FindField("name").Value = ""
formManager.FindField("email").Required = True

' Save the interactive PDF
pdfDocument.SaveAs("customer_survey_form.pdf")
$vbLabelText   $csharpLabel

Le paramètre CreatePdfFormsFromHtml convertit les éléments de formulaire HTML en champs de formulaire PDF interactifs . Les utilisateurs peuvent remplir, enregistrer, et soumettre ces documents PDF électroniquement. Cette fonctionnalité simplifie les flux de travail en éliminant les formulaires papier tout en conservant les modèles de développement HTML familiers. L'objet PdfDocument permet de manipuler les champs de formulaire par programmation. Découvrez comment manipuler les formulaires PDF pour des implémentations avancées.

Sortie

Visionneuse PDF affichant un formulaire d'enquête client avec des champs pour le nom, l'adresse e-mail, une liste déroulante de satisfaction réglée sur

Quels éléments de formulaire HTML sont pris en charge ?

IronPDF prend en charge tous les éléments de formulaire HTML standard, y compris les champs de texte, les zones de texte, les cases à cocher, les boutons radio, les listes déroulantes et les boutons. Les champs de mot de passe sont convertis en champs de saisie de texte sécurisés. Les champs de téléchargement de fichiers deviennent des espaces réservés aux pièces jointes. Les champs cachés préservent les données du formulaire sans les afficher. Les types d'entrée HTML5 comme email, tel et number conservent des règles de validation. Le style personnalisé s'applique à l'apparence du formulaire. Consultez la documentation des formulaires pour connaître les comportements et les limitations spécifiques à chaque élément.

Comment valider les données d'un formulaire PDF ?

Mettez en œuvre une validation côté client à l'aide de JavaScript avant la génération du PDF. Définissez les attributs obligatoires des champs de formulaire pour la validation intégrée. Utilisez des expressions régulières pour la correspondance de modèles sur les entrées de texte. Configurer les plages numériques pour les champs numériques. Ajoutez des scripts de validation personnalisés aux formulaires PDF à l'aide d'Acrobat JavaScript. Mettez en œuvre une validation côté serveur lors du traitement des formulaires soumis. Envisagez l'utilisation de signatures numériques pour garantir l'intégrité des documents soumis.

Est-il possible de préremplir dynamiquement les champs de formulaire ?

Accédez aux champs du formulaire via la propriété Form après le rendu. Définissez les valeurs des champs à l'aide de FindField("fieldName").Value. Alimenter à partir de bases de données ou de réponses d'API. Créez des modèles avec des valeurs par défaut. Prise en charge de la génération de formulaires en masse avec des données uniques par PDF. Activer les calculs des champs de formulaire pour les valeurs calculées. Prenez en compte les implications en matière de sécurité des données sensibles préremplies. Découvrez la gestion des champs de formulaire pour les scénarios complexes.

Comment se comparent les bibliothèques PDF .NET pour la génération dynamique ?

Lors du choix d'une bibliothèque PDF for .NET, les facteurs clés sont la précision du rendu, la conception de l'API, la prise en charge de la plateforme et la licence. Le tableau ci-dessous compare IronPDF à deux alternatives largement utilisées.

IronPDF comparé aux autres bibliothèques PDF .NET
Caractéristique IronPDF iTextSharp wkhtmltopdf
Moteur de rendu Chrome (dernière version) Moteur de mise en page personnalisé WebKit (non maintenu)
Prise en charge HTML/CSS CSS3/JS entièrement moderne CSS partiel CSS3 limité
API asynchrone Oui Non Non
Formulaires interactifs Oui (à partir du HTML) API manuelle uniquement Non
Signatures numériques Oui Oui Non
Conformité PDF/A Oui Oui Non
Multiplateforme Windows, Linux, macOS Windows, Linux, macOS Windows, Linux, macOS
soutien commercial Assistance dédiée 24h/24 et 5j/7 Forums communautaires Aucune
Type de licence Commercial AGPL / Commercial LGPL (gratuit)

Le moteur de rendu Chrome d'IronPDF garantit une précision au pixel près lors de la création de PDF, éliminant ainsi les compromis des anciennes solutions de rendu WebKit. Contrairement aux alternatives open source qui nécessitent des exécutables externes ou des configurations de navigateur sans interface graphique, IronPDF s'intègre directement à votre projet .NET sans aucune dépendance supplémentaire. Comparez IronPDF et iText pour comprendre en détail les différences.

Aperçu des fonctionnalités IronPDF présentant quatre catégories principales : Créer des PDF, Convertir des PDF, Modifier des PDF et Signer et sécuriser des PDF, avec des listes de fonctionnalités détaillées sous chaque catégorie sur fond violet foncé.

Quels sont les principaux avantages d' IronPDF pour la génération dynamique de PDF ?

Les fonctionnalités avancées incluent le filigrane, les signatures numériques, la création de formulaires, la conformité PDF/A et le chiffrement. L'intégration .NET prend en charge tous les types de projets, des applications console aux fonctions Azure. La compatibilité multiplateforme garantit des résultats cohérents sous Windows, Linux et macOS.

Présentation des fonctionnalités IronPDF mettant en évidence trois avantages principaux : rendu d'une précision pixel parfaite grâce à la prise en charge HTML/CSS/JS de qualité Chromium, installation en 5 minutes via le Package Manager et compatibilité multiplateforme avec Windows, Linux, macOS et les services cloud.

Comment fonctionne le système de licences IronPDF ?

Les licences commencent à $799 pour les licences de développeur unique, avec des options d'équipe et Enterprise disponibles. Chaque formule offre des avantages uniques, et l'investissement est rentabilisé grâce aux gains de temps de développement. Accédez instantanément à votre clé API après l'achat. Consultez les options de licence pour trouver le forfait adapté à votre projet.

Les bibliothèques libres manquent souvent de soutien commercial, ce qui est pourtant essentiel pour les applications de production. Les alternatives open source peuvent être soumises à des restrictions de licence AGPL incompatibles avec une utilisation commerciale. IronPDF propose des licences flexibles pour tous les scénarios de déploiement, des projets de démarrage aux déploiements en Enterprise .

IronPDF licensing page displaying four pricing tiers (Lite $749, Plus $999, Professional $1,999, and Unlimited $3,999) with developer, location, and project limits for each tier

Quelles sont les prochaines étapes pour la génération dynamique de PDF en C# ?

La génération dynamique de PDF en C# révolutionne la façon dont les applications distribuent des documents personnalisés à l'exécution. IronPDF fournit les outils essentiels pour créer des fichiers PDF à partir de contenu HTML , de pages web et de sources de données. Son rendu basé sur Chrome garantit que vos PDF correspondent exactement aux spécifications de conception, tandis que la prise en charge asynchrone permet un traitement à grande échelle. Consultez les tutoriels pour obtenir des instructions étape par étape sur la mise en œuvre de ces fonctionnalités.

Avec IronPDF, vous pouvez convertir des chaînes HTML, créer des PDF complexes avec des images et des tableaux, ajouter des numéros de page, contrôler la taille des polices et générer des rapports PDF à partir de n'importe quelle source de données. Chaque nouveau document bénéficie d'un rendu au pixel près, qu'il s'agisse de créer une page simple ou des mises en page complexes avec plusieurs instances de documents.

Commencez par un essai gratuit de 30 jours d'IronPDF pour découvrir ces fonctionnalités. Explorez la documentation complète, consultez les références aux espaces de noms dans la documentation de l'API et étudiez les exemples de code pour accélérer vos projets de génération de fichiers PDF. Pour des besoins supplémentaires en matière de traitement de documents, notamment la manipulation de fichiers Excel et la reconnaissance optique de caractères (OCR) , envisagez la suite IronSuite .

Questions Fréquemment Posées

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

La génération dynamique de PDF en C# consiste à créer des documents PDF de manière programmatique au moment de l'exécution, ce qui permet de créer des contenus personnalisés tels que des factures, des rapports et des formulaires.

Comment IronPDF aide-t-il à générer des PDF de manière dynamique ?

IronPDF offre de puissantes fonctionnalités de rendu basées sur Chrome qui permettent une intégration transparente avec C# pour créer efficacement des documents PDF dynamiques.

IronPDF peut-il être utilisé avec le .NET Framework ?

Oui, IronPDF est entièrement compatible avec le .NET Framework, ce qui en fait un outil robuste pour la génération dynamique de PDF dans cet environnement.

Quels sont les cas d'utilisation de la génération dynamique de PDF ?

La génération dynamique de PDF est utile pour créer des factures personnalisées, des rapports axés sur les données et des champs de formulaire personnalisés dans les applications web modernes.

Pourquoi le rendu basé sur Chrome est-il important pour la génération de PDF ?

Le rendu basé sur Chrome garantit une apparence de document de haute qualité et cohérente, et prend en charge les normes et styles web modernes dans la génération de PDF.

IronPDF est-il adapté à la création de rapports PDF axés sur les données ?

Oui, IronPDF est bien adapté à la création de rapports PDF axés sur les données, permettant aux développeurs d'intégrer dynamiquement des données dans leurs documents PDF.

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

Équipe de soutien Iron

Nous sommes en ligne 24 heures sur 24, 5 jours sur 7.
Chat
Email
Appelez-moi