Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. Utilisation de IronPDF
  4. Asp Créer un PDF à la volée
UTILISATION DE IRONPDF

Création de PDF à la volée avec ASP : génération dynamique de PDF dans .NET Core

Curtis Chau
Curtis Chau
Mis à jour:

Créez des PDF dynamiquement dans ASP.NET Core en utilisant IronPDF pour convertir instantanément du contenu HTML en documents PDF professionnels et les diffuser directement aux utilisateurs sans stockage côté serveur.

Lors de la création d'applications web modernes en ASP.NET Core , la capacité à générer dynamiquement des documents PDF est essentielle. Que vous créiez des factures , des rapports ou des certificats , les utilisateurs s'attendent à une génération immédiate de fichiers PDF sans stockage côté serveur. La bibliothèque PDF performante d'IronPDF simplifie la création de PDF directement dans vos projets .NET Core .

Dans cet article, nous vous guiderons à travers les étapes de création de documents PDF dans vos applications ASP.NET , en utilisant les capacités de conversion HTML vers PDF et les opérations sur les flux de mémoire .

Que signifie la création de PDF à la volée ?

La création de PDF à la volée consiste à générer des documents PDF dynamiquement en mémoire et à les diffuser directement vers le navigateur de l'utilisateur. Ce processus côté serveur élimine la nécessité d'enregistrer les fichiers PDF sur disque , améliorant ainsi les performances et la sécurité. Grâce au SDK d'IronPDF, vous pouvez transformer instantanément du contenu HTML en documents PDF professionnels, idéal pour les applications web qui ont besoin de créer des PDF sans stocker de fichiers sur le serveur. Le moteur de rendu de Chrome garantit un rendu au pixel près , correspondant exactement à votre design HTML.

Commencez avec IronPDF maintenant.
green arrow pointer

Comment configurer IronPDF pour la génération dynamique de fichiers PDF ?

Commencez par installer IronPDF via le gestionnaire de packages NuGet pour ajouter cette bibliothèque PDF performante à votre projet ASP.NET Core :

Install-Package IronPdf

Ensuite, configurez IronPDF dans votre application ASP.NET Core pour créer des fichiers PDF de manière dynamique :

using IronPdf;
using Microsoft.AspNetCore.Mvc;

namespace PdfGenerator.Controllers
{
    public class DocumentController : Controller
    {
        private readonly ChromePdfRenderer _renderer;

        public DocumentController()
        {
            // Initialize the renderer once for reuse
            _renderer = new ChromePdfRenderer();
            // Optional: Set your license key
            License.LicenseKey = "YOUR-LICENSE-KEY";
        }
    }
}
using IronPdf;
using Microsoft.AspNetCore.Mvc;

namespace PdfGenerator.Controllers
{
    public class DocumentController : Controller
    {
        private readonly ChromePdfRenderer _renderer;

        public DocumentController()
        {
            // Initialize the renderer once for reuse
            _renderer = new ChromePdfRenderer();
            // Optional: Set your license key
            License.LicenseKey = "YOUR-LICENSE-KEY";
        }
    }
}
$vbLabelText   $csharpLabel

Cette configuration initialise le ChromePdfRenderer , le moteur de rendu performant d'IronPDF qui convertit les documents HTML en documents PDF à l'aide de Chromium. En créant une seule instance de rendu, vous améliorez l'utilisation de la mémoire lors de la création répétée de fichiers PDF. Apprenez-en davantage sur la conversion HTML vers PDF pour découvrir des techniques avancées, notamment le rendu JavaScript , la prise en charge CSS et les polices personnalisées . Pour configurer votre clé de licence , consultez notre guide des licences .

Comment créer des documents PDF à partir de contenu HTML ?

La fonctionnalité principale permettant de créer des fichiers PDF consiste à convertir des chaînes HTML en documents PDF. Voici un exemple complet montrant comment générer une facture à la volée :

[HttpGet]
public IActionResult GenerateInvoice(int orderId)
{
    // Fetch data from your database or service
    var orderData = GetOrderData(orderId);
    // Build HTML content with dynamic data
    string htmlContent = $@"
        <!DOCTYPE html>
        <html>
        <head>
            <style>
                body {{ font-family: Arial, sans-serif; }}
                .header {{ background-color: #f0f0f0; padding: 20px; }}
                table {{ width: 100%; border-collapse: collapse; }}
                td, th {{ padding: 10px; border: 1px solid #ddd; }}
            </style>
        </head>
        <body>
            <div class='header'>
                <h1>Invoice #{orderData.InvoiceNumber}</h1>
                <p>Date: {DateTime.Now:yyyy-MM-dd}</p>
            </div>
            <table>
                <tr>
                    <th>Item</th>
                    <th>Quantity</th>
                    <th>Price</th>
                </tr>";
    foreach(var item in orderData.Items)
    {
        htmlContent += $@"
                <tr>
                    <td>{item.Name}</td>
                    <td>{item.Quantity}</td>
                    <td>${item.Price:F2}</td>
                </tr>";
    }
    htmlContent += @"
            </table>
        </body>
        </html>";
    // Create PDF from HTML
    var pdf = _renderer.RenderHtmlAsPdf(htmlContent);
    // Convert to byte array for streaming
    byte[] pdfBytes = pdf.BinaryData;
    // Return PDF to browser
    return File(pdfBytes, "application/pdf", $"invoice_{orderId}.pdf");
}
[HttpGet]
public IActionResult GenerateInvoice(int orderId)
{
    // Fetch data from your database or service
    var orderData = GetOrderData(orderId);
    // Build HTML content with dynamic data
    string htmlContent = $@"
        <!DOCTYPE html>
        <html>
        <head>
            <style>
                body {{ font-family: Arial, sans-serif; }}
                .header {{ background-color: #f0f0f0; padding: 20px; }}
                table {{ width: 100%; border-collapse: collapse; }}
                td, th {{ padding: 10px; border: 1px solid #ddd; }}
            </style>
        </head>
        <body>
            <div class='header'>
                <h1>Invoice #{orderData.InvoiceNumber}</h1>
                <p>Date: {DateTime.Now:yyyy-MM-dd}</p>
            </div>
            <table>
                <tr>
                    <th>Item</th>
                    <th>Quantity</th>
                    <th>Price</th>
                </tr>";
    foreach(var item in orderData.Items)
    {
        htmlContent += $@"
                <tr>
                    <td>{item.Name}</td>
                    <td>{item.Quantity}</td>
                    <td>${item.Price:F2}</td>
                </tr>";
    }
    htmlContent += @"
            </table>
        </body>
        </html>";
    // Create PDF from HTML
    var pdf = _renderer.RenderHtmlAsPdf(htmlContent);
    // Convert to byte array for streaming
    byte[] pdfBytes = pdf.BinaryData;
    // Return PDF to browser
    return File(pdfBytes, "application/pdf", $"invoice_{orderId}.pdf");
}
$vbLabelText   $csharpLabel

Ce code montre comment générer des fichiers PDF dynamiques en combinant des modèles de pages HTML avec des données en temps réel. La méthode RenderHtmlAsPdf traite le contenu HTML, y compris les styles CSS , et produit un document professionnel prêt à être téléchargé. Cette méthode prend en charge les mises en page complexes, les images et même l'exécution de JavaScript . Vous pouvez consulter le résultat dans un nouvel onglet. Pour des fonctionnalités plus avancées, explorez les formats de page personnalisés , les en-têtes et pieds de page , et les filigranes .

À quoi ressemble la facture PDF générée ?

Facture PDF professionnelle (n° 123, datée du 13/11/2025) avec un en-tête stylisé et un tableau organisé présentant le produit A (10,99 $) et le produit B (5,49 $). Cette facture illustre les capacités de génération de PDF dynamiques avec style CSS personnalisé.

Comment diffuser des fichiers PDF directement aux utilisateurs sans les enregistrer sur le disque ?

La diffusion en continu de fichiers PDF à la volée nécessite de travailler avec des flux de mémoire et des tableaux d'octets. Cette approche garantit que les documents PDF n'accèdent jamais au système de fichiers du serveur, ce qui est crucial pour les déploiements dans le cloud et les applications conteneurisées :

[HttpPost]
public async Task<IActionResult> CreateReport([FromBody] ReportRequest request)
{
    // Generate HTML from request data
    string html = BuildReportHtml(request);
    // Create PDF in memory
    var pdfDocument = _renderer.RenderHtmlAsPdf(html);
    // Use MemoryStream for efficient streaming
    using (var memoryStream = new MemoryStream())
    {
        // Write PDF binary data to the memory stream
        memoryStream.Write(pdfDocument.BinaryData, 0, pdfDocument.BinaryData.Length);
        // Set response headers for inline display
        Response.Headers.Add("Content-Disposition", "inline; filename=report.pdf");
        // Return FileContentResult with proper content type
        return new FileContentResult(memoryStream.ToArray(), "application/pdf");
    }
}
[HttpPost]
public async Task<IActionResult> CreateReport([FromBody] ReportRequest request)
{
    // Generate HTML from request data
    string html = BuildReportHtml(request);
    // Create PDF in memory
    var pdfDocument = _renderer.RenderHtmlAsPdf(html);
    // Use MemoryStream for efficient streaming
    using (var memoryStream = new MemoryStream())
    {
        // Write PDF binary data to the memory stream
        memoryStream.Write(pdfDocument.BinaryData, 0, pdfDocument.BinaryData.Length);
        // Set response headers for inline display
        Response.Headers.Add("Content-Disposition", "inline; filename=report.pdf");
        // Return FileContentResult with proper content type
        return new FileContentResult(memoryStream.ToArray(), "application/pdf");
    }
}
$vbLabelText   $csharpLabel

Comment fonctionne la génération de PDF basée sur la mémoire ?

! Rapport PDF généré affichant le titre " Bilan de performance mensuel " avec un contenu formaté illustrant la génération de documents commerciaux concrets, incluant des graphiques, des indicateurs et des sections d'analyse détaillée, rendus à partir d'un modèle HTML

L'approche par tableau d'octets permet de créer des fichiers PDF entièrement en mémoire. Le type de contenu " application/pdf " indique au navigateur comment traiter le fichier, tandis que l' en-tête Content-Disposition détermine si le fichier PDF s'ouvre dans le navigateur ou déclenche un téléchargement. Pour plus de détails sur la conversion de PDF en MemoryStream , consultez notre documentation. Lorsque l'utilisateur appuie sur le bouton pour envoyer la requête, le serveur traite ce code pour générer le PDF de manière dynamique. Cette technique est particulièrement utile pour les déploiements Azure Functions et AWS Lambda où l'accès au système de fichiers peut être restreint.

Démarrez votre essai gratuit et mettez en œuvre la génération de PDF dynamique dès aujourd'hui !

Comment générer des PDF à partir du contenu d'une base de données dynamique ?

Dans le monde réel, les applications ASP.NET Core ont souvent besoin de générer des rapports PDF à partir de requêtes de base de données. Voici comment générer des fichiers PDF à l'aide des données Entity Framework Core avec une gestion des erreurs appropriée :

[HttpGet("report/monthly")]
public async Task<IActionResult> MonthlyReport(int year, int month)
{
    // Query database for report data
    var reportData = await _context.Transactions
        .Where(t => t.Date.Year == year && t.Date.Month == month)
        .GroupBy(t => t.Category)
        .Select(g => new {
            Category = g.Key,
            Total = g.Sum(t => t.Amount),
            Count = g.Count()
        })
        .ToListAsync();
    // Build HTML template with style
    var htmlTemplate = @"<h2>Monthly Report</h2>
                         <table style='width:100%'>";
    foreach(var item in reportData)
    {
        htmlTemplate += $"<tr><td>{item.Category}</td>" +
                       $"<td>{item.Count} items</td>" +
                       $"<td>${item.Total:F2}</td></tr>";
    }
    htmlTemplate += "</table>";
    // Generate PDF document with settings
    var pdf = _renderer.RenderHtmlAsPdf(htmlTemplate);
    // Add metadata to PDF
    pdf.MetaData.Title = $"Report {month}/{year}";
    pdf.MetaData.Author = "Reporting System";
    // Stream PDF to user
    return File(pdf.BinaryData, "application/pdf");
}
[HttpGet("report/monthly")]
public async Task<IActionResult> MonthlyReport(int year, int month)
{
    // Query database for report data
    var reportData = await _context.Transactions
        .Where(t => t.Date.Year == year && t.Date.Month == month)
        .GroupBy(t => t.Category)
        .Select(g => new {
            Category = g.Key,
            Total = g.Sum(t => t.Amount),
            Count = g.Count()
        })
        .ToListAsync();
    // Build HTML template with style
    var htmlTemplate = @"<h2>Monthly Report</h2>
                         <table style='width:100%'>";
    foreach(var item in reportData)
    {
        htmlTemplate += $"<tr><td>{item.Category}</td>" +
                       $"<td>{item.Count} items</td>" +
                       $"<td>${item.Total:F2}</td></tr>";
    }
    htmlTemplate += "</table>";
    // Generate PDF document with settings
    var pdf = _renderer.RenderHtmlAsPdf(htmlTemplate);
    // Add metadata to PDF
    pdf.MetaData.Title = $"Report {month}/{year}";
    pdf.MetaData.Author = "Reporting System";
    // Stream PDF to user
    return File(pdf.BinaryData, "application/pdf");
}
$vbLabelText   $csharpLabel

Ce modèle vous permet de créer des PDF à partir de n'importe quelle source de données, transformant instantanément les enregistrements de la base de données en documents formatés. L'utilisation de modèles HTML facilite la maintenance et la modification des mises en page des rapports. Vous pouvez également envisager de créer des PDF à partir de documents existants pour des scénarios plus complexes . Pour une mise en forme améliorée, envisagez d'utiliser les styles d'impression CSS , les marges personnalisées et les sauts de page . Vous pouvez également ajouter des graphiques ou des images provenant d'Azure Blob Storage .

Comment gérez-vous les scénarios avancés de génération de PDF ?

Pour des exigences plus complexes, IronPDF offre des fonctionnalités avancées pour améliorer la génération de PDF à la volée :

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

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

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

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

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

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

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

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

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

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

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

Cet exemple illustre les options de rendu , la numérotation des pages , les paramètres de sécurité et les opérations asynchrones . Vous pouvez également implémenter des signatures numériques , la conformité PDF/A , la compression et des filigranes . Pour les scénarios multithread , IronPDF propose des opérations sécurisées pour les threads.

Quelles sont les meilleures pratiques pour la génération de PDF à la volée ?

Lorsque vous créez des fichiers PDF de manière dynamique dans ASP.NET Core , tenez compte des stratégies d'optimisation suivantes :

Opérations asynchrones : utilisez des méthodes asynchrones pour éviter de bloquer le pool de threads du serveur lors de la génération de plusieurs fichiers PDF :

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

Gestion de la mémoire : pour les fichiers PDF volumineux, libérez correctement les ressources et envisagez de diffuser directement la réponse afin de minimiser l'utilisation de la mémoire :

using (var pdf = _renderer.RenderHtmlAsPdf(html))
{
    return File(pdf.Stream, "application/pdf");
}
using (var pdf = _renderer.RenderHtmlAsPdf(html))
{
    return File(pdf.Stream, "application/pdf");
}
$vbLabelText   $csharpLabel

Réutilisation du moteur de rendu : partagez les instances de ChromePdfRenderer entre les requêtes pour améliorer les performances lors de la génération de plusieurs fichiers PDF. Le moteur de rendu est compatible avec le multithreading et gère efficacement les opérations simultanées. Réutiliser le moteur de rendu permet de gagner du temps d'initialisation pour chaque requête. Envisagez d'implémenter une journalisation personnalisée pour surveiller les performances et résoudre les problèmes.

Selon les bonnes pratiques de Microsoft pour ASP.NET Core , la minimisation des allocations d'objets et la réutilisation des ressources sont essentielles pour des applications web performantes. Pour le déploiement, consultez nos guides pour les environnements Azure , AWS , Docker et Linux . Vous pouvez également mettre en œuvre des stratégies de mise en cache pour améliorer les temps de rendu .

NuGet Installer avec NuGet

PM >  Install-Package IronPdf

Consultez IronPDF sur NuGet pour une installation rapide. Avec plus de 10 millions de téléchargements, il transforme le développement PDF avec C#. Vous pouvez également télécharger le DLL ou l'installateur Windows.

Qu'avez-vous appris sur la création de PDF à la volée ?

La création de documents PDF à la volée avec IronPDF transforme la génération complexe de documents en code simple. Des factures simples aux rapports complexes, le kit de développement logiciel (SDK) performant d'IronPDF prend en charge les tâches les plus ardues pendant que vous vous concentrez sur la logique de votre application. La possibilité de générer et de diffuser des fichiers PDF sans les enregistrer sur disque rend vos applications ASP.NET Core plus efficaces et plus sécurisées.

Avec IronPDF, vous pouvez créer des PDF à partir de contenu HTML , les diffuser sous forme de tableaux d'octets et fournir instantanément des documents professionnels aux utilisateurs. Que vous développiez un système de reporting , un générateur de factures ou une solution de gestion de documents , IronPDF vous offre toutes les fonctionnalités nécessaires à la génération fiable de PDF. Vous pouvez également demander de l'aide si nécessaire. Explorez des fonctionnalités supplémentaires telles que les formulaires PDF , les annotations , les signets , les métadonnées et la conformité PDF/UA pour l'accessibilité.

Prêt à transformer votre application ASP.NET Core avec des fonctionnalités PDF dynamiques ? Achetez une licence pour accéder à toutes les fonctionnalités et bénéficier d'une assistance professionnelle de notre équipe d'ingénieurs. Pour les développeurs VB.NET , les développeurs F# et ceux qui travaillent avec MAUI ou Blazor , nous offrons une prise en charge complète de la plateforme. Consultez notre documentation API pour obtenir des informations détaillées et comparez nos concurrents pour découvrir pourquoi les développeurs choisissent IronPDF.

Questions Fréquemment Posées

Comment générer des PDF de manière dynamique avec ASP.NET Core ?

IronPDF permet de générer des PDF dynamiquement dans ASP.NET Core sans les enregistrer sur le disque. Il permet également de diffuser les PDF directement dans les navigateurs.

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

IronPDF fournit un puissant moteur de rendu qui permet la création dynamique de PDF directement dans vos projets .NET Core, garantissant une génération instantanée de PDF sans nécessiter de stockage côté serveur.

Peut-on utiliser IronPDF pour créer des factures et des rapports ?

Oui, IronPDF convient à la création de différents types de documents tels que des factures, des rapports et des certificats, tous générés à la volée dans des applications ASP.NET Core.

Le stockage côté serveur est-il nécessaire lors de l'utilisation d'IronPDF ?

Non, IronPDF vous permet de générer et de diffuser des PDF directement dans les navigateurs sans avoir besoin de stockage côté serveur, ce qui le rend efficace et rapide.

Quels types d'applications peuvent tirer profit de la génération de PDF à la volée ?

Les applications web modernes, notamment celles qui nécessitent la création de documents en temps réel comme les systèmes de facturation et les outils de reporting, peuvent grandement bénéficier de la génération de PDF à la volée proposée par IronPDF.

IronPDF prend-il en charge les projets .NET Core ?

Oui, IronPDF est entièrement compatible avec les projets .NET Core, permettant aux développeurs d'intégrer facilement des fonctionnalités de génération de PDF dans leurs applications.

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