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:

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 instantanée de fichiers PDF sans stockage côté serveur. La puissante bibliothèque PDF d'IronPDF simplifie la création de PDF à la volée directement dans vos projets .NET Core.

Dans cet article, nous vous guiderons à travers les étapes nécessaires pour commencer à créer facilement des documents PDF à la volée dans vos applications ASP.NET.

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.

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 puissante bibliothèque PDF à 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";
        }
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Cette configuration initialise ChromePdfRenderer , le puissant moteur de rendu d'IronPDF qui convertit les documents HTML en documents PDF à l'aide de Chromium. En créant une seule instance de rendu, vous optimisez 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.

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");
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$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 code JavaScript. Vous pouvez consulter le résultat dans un nouvel onglet.

Exemple de sortie

! Création de PDF à la volée avec ASP : Génération dynamique de PDF en .NET Core : Image 1 - Exemple de PDF généré à la volée avec notre programme ASP.NET

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");
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Exemple de document PDF de sortie

! Création de PDF à la volée avec ASP : Génération dynamique de PDF dans .NET Core : Image 2 - PDF créé à l'aide de tableaux d'octets et de flux

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 exécutera ce code pour poursuivre le processus.

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");
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$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 explorer la création de PDF à partir de documents existants pour des scénarios plus complexes , et trouver un lien vers un index d'informations supplémentaires. Nous espérons que cela constitue un bon exemple.

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;
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Gestion de la mémoire : Pour les fichiers PDF volumineux, libérez correctement les ressources et envisagez de diffuser directement vers 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");
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$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 peut gérer efficacement les opérations simultanées. Il est également vrai que la réutilisation du moteur de rendu permet de gagner du temps. Ne négligez pas cette optimisation.

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.

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.

Conclusion

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 puissant SDK 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. Nous intégrons constamment de nouvelles fonctionnalités et vous pouvez vous inspirer de tous nos exemples. Ceci est un document DOC officiel pour la bibliothèque.

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 mise en œuvre d'une génération de PDF robuste. Vous pouvez également rédiger un nouveau message pour obtenir de l'aide. Le texte est clair.

Prêt à transformer votre application ASP.NET Core avec des fonctionnalités PDF dynamiques ? Achetez une licence pour débloquer toutes les fonctionnalités et bénéficier d'une assistance professionnelle de notre équipe d'ingénieurs.

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