Générez dynamiquement des documents PDF Professional dans ASP.NET Core en convertissant le contenu HTML en PDF soignés et en les diffusant directement dans le navigateur – aucun stockage disque requis, aucun fichier temporaire à gérer.
Lors de la création d'applications web modernes en ASP.NET Core, la capacité à produire des documents PDF à la demande est une exigence récurrente. Les factures doivent être téléchargées dès que le paiement est validé. Les rapports de conformité doivent apparaître instantanément lorsqu'un auditeur clique sur " Exporter ". Les certificats doivent être prêts avant même que l'utilisateur ait le temps de se demander si quelque chose a mal fonctionné. IronPDF gère tous ces scénarios grâce à sa bibliothèque PDF basée sur Chromium, qui convertit le HTML (y compris le CSS, le JavaScript et les polices Web) en une sortie PDF précise au pixel près sans rien écrire sur le disque.
Ce guide couvre tout ce que vous devez savoir : installation de la bibliothèque, génération de factures à partir de chaînes HTML, diffusion de rapports à partir de données Entity Framework, application des en-têtes de page et des paramètres de sécurité, et adoption des meilleures pratiques pour garantir le bon fonctionnement des applications ASP.NET à fort trafic.
" À la volée " signifie que le document est construit en mémoire au moment de la requête HTTP et envoyé directement à l'appelant. Aucun fichier PDF n'est écrit sur le système de fichiers, aucune tâche en arrière-plan ne met le travail en file d'attente et aucun cache ne stocke le résultat entre les requêtes.
Cette approche est importante pour plusieurs raisons. Premièrement, les cibles de déploiement dans le cloud (Azure App Service, AWS Lambda, conteneurs Docker) s'exécutent souvent dans des environnements où le système de fichiers local est éphémère ou en lecture seule. Générer un PDF dans un dossier temporaire puis le relire est une opération délicate dans ces environnements. Deuxièmement, éviter les écritures sur disque réduit la surface d'attaque : aucun fichier résiduel ne pourrait être accidentellement servi à un utilisateur erroné lors d'une requête ultérieure. Troisièmement, la génération en mémoire seule est généralement plus rapide car elle élimine deux opérations d'E/S (écriture et lecture) dans le chemin critique.
Le ChromePdfRenderer de IronPDF expose une propriété .BinaryData et une propriété .Stream sur chaque document généré. Chacune peut être passée directement à un FileResult ASP.NET Core, rendant le streaming une ligne unique en pratique.
Ajoutez le package NuGet via la console du gestionnaire de packages ou l'interface de ligne de commande .NET :
Une fois le paquet installé, définissez votre clé de licence au démarrage de l'application -- typiquement dans Program.cs avant que le premier rendu ne soit créé :
using IronPdf;
// Place license activation before any IronPDF call
License.LicenseKey = "YOUR-LICENSE-KEY";
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllersWithViews();
// Register ChromePdfRenderer as a singleton so the Chromium engine
// is initialised once and reused across all requests.
builder.Services.AddSingleton<ChromePdfRenderer>();
var app = builder.Build();
app.MapDefaultControllerRoute();
app.Run();Imports IronPdf
' Place license activation before any IronPDF call
License.LicenseKey = "YOUR-LICENSE-KEY"
Dim builder = WebApplication.CreateBuilder(args)
builder.Services.AddControllersWithViews()
' Register ChromePdfRenderer as a singleton so the Chromium engine
' is initialised once and reused across all requests.
builder.Services.AddSingleton(Of ChromePdfRenderer)()
Dim app = builder.Build()
app.MapDefaultControllerRoute()
app.Run()Il est important d'enregistrer ChromePdfRenderer en tant que singleton. Le moteur de rendu lance un sous-processus Chromium interne lors de sa première utilisation. Si vous créez une nouvelle instance pour chaque requête, vous payez ce coût de démarrage à chaque appel, ce qui ajoute des centaines de millisecondes de latence en cas de charge. Une instance singleton est thread-safe et gère les requêtes de rendu simultanées sans configuration supplémentaire.
Pour un aperçu plus complet des options d'installation, y compris les configurations NuGet.config pour les flux privés, consultez la présentation de l'installation .
Le cas d'utilisation à la volée le plus courant est la génération de documents transactionnels (factures, reçus, confirmations de commande) où le contenu change à chaque requête mais la mise en page reste constante.
Le modèle est : construire une chaîne HTML avec des données interpolées, la passer à RenderHtmlAsPdf, et retourner le résultat binaire en tant que téléchargement de fichier.
using IronPdf;
using Microsoft.AspNetCore.Mvc;
public class DocumentController : Controller
{
private readonly ChromePdfRenderer _renderer;
public DocumentController(ChromePdfRenderer renderer)
{
_renderer = renderer;
}
[HttpGet("invoice/{orderId:int}")]
public IActionResult GetInvoice(int orderId)
{
// In a real application, fetch this from your database or order service.
var order = GetOrderData(orderId);
string html = $"""
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<style>
body {{font-family: Arial, sans-serif; margin: 40px; color: #333;}}
h1 {{color: #1a56db;}}
table {{width: 100%; border-collapse: collapse; margin-top: 24px;}}
th, td {{padding: 10px 14px; border: 1px solid #d1d5db; text-align: left;}}
th {{background: #f3f4f6;}}
tfoot td {{font-weight: bold;}}
</style>
</head>
<body>
<h1>Invoice #{order.InvoiceNumber}</h1>
<p>Date: {DateTime.UtcNow:yyyy-MM-dd} | Customer: {order.CustomerName}</p>
<table>
<thead><tr><th>Item</th><th>Qty</th><th>Unit Price</th><th>Subtotal</th></tr></thead>
<tbody>
{string.Join("", order.Items.Select(i =>
$"<tr><td>{i.Name}</td><td>{i.Quantity}</td>" +
$"<td>${i.UnitPrice:F2}</td><td>${i.Quantity * i.UnitPrice:F2}</td></tr>"))}
</tbody>
<tfoot>
<tr><td colspan="3">Total</td><td>${order.Items.Sum(i => i.Quantity * i.UnitPrice):F2}</td></tr>
</tfoot>
</table>
</body>
</html>
""";
var pdf = _renderer.RenderHtmlAsPdf(html);
return File(pdf.BinaryData, "application/pdf", $"invoice-{orderId}.pdf");
}
}RenderHtmlAsPdf traite l'ensemble du document HTML -- CSS grid, Flexbox, polices web, même SVG en ligne -- en utilisant le même moteur Chromium qui alimente Google Chrome. Le PdfDocument renvoyé expose BinaryData (un byte[]) et Stream (un MemoryStream). Passer BinaryData à File() avec "application/pdf" et un nom de fichier déclenche un téléchargement par le navigateur.
Pour les mises en page nécessitant une fidélité au pixel près, consultez le guide de rendu HTML vers PDF qui couvre le CSS réactif, les polices personnalisées et le rendu JavaScript .
Servir un PDF en ligne -- l'ouvrir dans le visualiseur intégré du navigateur plutôt que de le télécharger -- nécessite deux petits changements : définir Content-Disposition à inline et omettre le nom de fichier de l'appel File().
[HttpPost("report/preview")]
public async Task<IActionResult> PreviewReport([FromBody] ReportRequest request)
{
string html = BuildReportHtml(request);
var pdfDocument = await _renderer.RenderHtmlAsPdfAsync(html);
// "inline" tells the browser to display rather than download.
Response.Headers["Content-Disposition"] = "inline; filename=report.pdf";
return new FileContentResult(pdfDocument.BinaryData, "application/pdf");
}Imports Microsoft.AspNetCore.Mvc
<HttpPost("report/preview")>
Public Async Function PreviewReport(<FromBody> request As ReportRequest) As Task(Of IActionResult)
Dim html As String = BuildReportHtml(request)
Dim pdfDocument = Await _renderer.RenderHtmlAsPdfAsync(html)
' "inline" tells the browser to display rather than download.
Response.Headers("Content-Disposition") = "inline; filename=report.pdf"
Return New FileContentResult(pdfDocument.BinaryData, "application/pdf")
End FunctionUtiliser la surcharge asynchrone RenderHtmlAsPdfAsync est recommandé pour les contrôleurs ASP.NET Core car elle libère le thread du pool pendant que Chromium rend, gardant le serveur réactif sous charge simultanée.
Le tableau de bytes pdfDocument.BinaryData vit entièrement en mémoire gérée. Aucun chemin de fichier intermédiaire n'est impliqué. L' Content-Disposition header contrôle si le PDF est affiché en ligne ou proposé en téléchargement -- un comportement du navigateur défini par la spécification HTTP. Pour une analyse plus approfondie de l'approche MemoryStream, y compris la diffusion vers Azure Blob Storage, consultez la documentation PDF sur les flux de mémoire .
La plupart des applications métier extraient les données de rapports d'une base de données plutôt que de les construire lors de l'appel. Le modèle ci-dessous interroge Entity Framework Core , construit un tableau HTML et renvoie un PDF, le tout au sein d'une seule action de contrôleur.
[HttpGet("report/monthly")]
public async Task<IActionResult> MonthlyReport(int year, int month)
{
// Pull aggregated transaction data from EF Core.
var rows = await _dbContext.Transactions
.Where(t => t.Date.Year == year && t.Date.Month == month)
.GroupBy(t => t.Category)
.Select(g => new { Category = g.Key, Count = g.Count(), Total = g.Sum(t => t.Amount) })
.OrderByDescending(g => g.Total)
.ToListAsync();
string tableRows = string.Join("", rows.Select(r =>
$"<tr><td>{r.Category}</td><td>{r.Count}</td><td>${r.Total:F2}</td></tr>"));
string html = $"""
<html><body style="font-family:Arial,sans-serif;padding:32px">
<h1>Monthly Report -- {month:D2}/{year}</h1>
<table style="width:100%;border-collapse:collapse">
<thead>
<tr style="background:#e5e7eb">
<th style="padding:8px;border:1px solid #d1d5db">Category</th>
<th style="padding:8px;border:1px solid #d1d5db">Transactions</th>
<th style="padding:8px;border:1px solid #d1d5db">Total</th>
</tr>
</thead>
<tbody>{tableRows}</tbody>
</table>
</body></html>
""";
var pdf = _renderer.RenderHtmlAsPdf(html);
pdf.MetaData.Title = $"Monthly Report {month:D2}/{year}";
pdf.MetaData.Author = "Reporting System";
return File(pdf.BinaryData, "application/pdf", $"report-{year}-{month:D2}.pdf");
}Imports Microsoft.AspNetCore.Mvc
Imports System.Threading.Tasks
Imports System.Linq
<HttpGet("report/monthly")>
Public Async Function MonthlyReport(year As Integer, month As Integer) As Task(Of IActionResult)
' Pull aggregated transaction data from EF Core.
Dim rows = Await _dbContext.Transactions _
.Where(Function(t) t.Date.Year = year AndAlso t.Date.Month = month) _
.GroupBy(Function(t) t.Category) _
.Select(Function(g) New With {Key .Category = g.Key, Key .Count = g.Count(), Key .Total = g.Sum(Function(t) t.Amount)}) _
.OrderByDescending(Function(g) g.Total) _
.ToListAsync()
Dim tableRows As String = String.Join("", rows.Select(Function(r) $"<tr><td>{r.Category}</td><td>{r.Count}</td><td>${r.Total:F2}</td></tr>"))
Dim html As String = $"
<html><body style='font-family:Arial,sans-serif;padding:32px'>
<h1>Monthly Report -- {month:D2}/{year}</h1>
<table style='width:100%;border-collapse:collapse'>
<thead>
<tr style='background:#e5e7eb'>
<th style='padding:8px;border:1px solid #d1d5db'>Category</th>
<th style='padding:8px;border:1px solid #d1d5db'>Transactions</th>
<th style='padding:8px;border:1px solid #d1d5db'>Total</th>
</tr>
</thead>
<tbody>{tableRows}</tbody>
</table>
</body></html>
"
Dim pdf = _renderer.RenderHtmlAsPdf(html)
pdf.MetaData.Title = $"Monthly Report {month:D2}/{year}"
pdf.MetaData.Author = "Reporting System"
Return File(pdf.BinaryData, "application/pdf", $"report-{year}-{month:D2}.pdf")
End FunctionDéfinir pdf.MetaData.Title et pdf.MetaData.Author intègre ces informations dans les propriétés du document PDF, ce qui est utile pour le suivi de conformité et les systèmes de gestion de documents. Pour des mises en page de rapports plus sophistiquées, envisagez les styles d'impression CSS , les sauts de page explicites et les images de graphiques intégrées .
Les documents de production nécessitent souvent des en-têtes comportant le titre du document, des pieds de page avec la numérotation des pages et des contrôles d'accès empêchant toute impression ou copie non autorisée. Le ChromePdfRenderOptions de IronPDF couvre toutes ces exigences.
[HttpPost("document/secured")]
public async Task<IActionResult> GenerateSecuredDocument([FromBody] SecuredDocRequest request)
{
var renderOptions = new ChromePdfRenderOptions
{
TaillePapier = PdfTaillePapier.A4,
MarginTop = 45,
MarginBottom = 45,
MarginLeft = 25,
MarginRight = 25,
ActiverJavaScript = true,
WaitFor = new WaitFor { RenderDelay = 500 }
};
renderOptions.TextHeader = new TextHeaderFooter
{
CenterText = request.DocumentTitle,
DrawDividerLine = true,
FontSize = 11
};
renderOptions.TextFooter = new TextHeaderFooter
{
LeftText = "{date} {time}",
RightText = "Page {page} of {total-pages}",
FontSize = 9
};
_renderer.RenderingOptions = renderOptions;
var pdf = await _renderer.RenderHtmlAsPdfAsync(request.HtmlContent);
if (request.RequirePassword)
{
pdf.SecuritySettings.OwnerPassword = request.OwnerPassword;
pdf.SecuritySettings.UserPassword = request.UserPassword;
pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.NoPrint;
pdf.SecuritySettings.AllowUserCopyPasteContent = false;
}
return File(pdf.BinaryData, "application/pdf", $"{request.FileName}.pdf");
}Le réglage WaitFor.RenderDelay est particulièrement utile lorsque votre HTML inclut des bibliothèques de graphiques telles que Chart.js ou ApexCharts qui terminent le dessin de manière asynchrone. Définir un délai de 300 à 500 ms permet à Chromium de capturer l'état final rendu. Pour les documents qui doivent répondre aux normes d'archivage, combinez l'approche ci-dessus avec la conformité PDF/A et les signatures numériques .
Les jetons {page} et {total-pages} dans le texte du pied de page sont résolus automatiquement par IronPDF au moment du rendu. Les options d'en-tête et de pied de page supplémentaires incluent des en-têtes basés sur HTML pour le placement de logo et les capacités de substitution par section.
Le tableau ci-dessous résume les propriétés ChromePdfRenderOptions les plus utiles pour la génération à la volée :
| Propriété | Type de texte | Objectif |
|---|---|---|
| TaillePapier | PdfTaillePapier | Définit les dimensions de la page (A4, Lettre, Légal, personnalisé) |
| Marge supérieure / Marge inférieure | int (mm) | Contrôle l'espacement de la zone imprimable |
| ActiverJavaScript | bool | Autorise l'exécution de JS avant la capture |
| WaitFor.RenderDelay | entier (ms) | Capture différée pour le rendu asynchrone |
| En-tête/Pied de page | TextHeaderFooter | En-têtes et pieds de page courants |
| En-tête HTML / Pied de page HTML | HtmlHeaderFooter | En-têtes/pieds de page au format HTML avec images |
| Niveaux de gris | bool | Sorties PDF monochromes |
| FitToPaperWidth | bool | Adapte le contenu large à la page |
Lorsqu'un seul serveur gère des centaines de requêtes PDF simultanées, quelques décisions architecturales ont un impact considérable sur le débit et la latence.
Enregistrement du rendu singleton. Comme montré dans la section d'installation, enregistrer ChromePdfRenderer en tant que singleton dans le conteneur DI évite le coût de démarrage d'un nouveau sous-processus Chromium par demande. Selon les lignes directrices de performance de ASP.NET Core de Microsoft, minimiser les allocations d'objets et réutiliser les ressources coûteuses sont les deux optimisations les plus impactantes disponibles.
Toujours utiliser async. RenderHtmlAsPdfAsync retourne un Task<PdfDocument> et suspend le thread du contrôleur pendant que Chromium travaille. Cela libère le pool de threads pour traiter d'autres requêtes entrantes en parallèle, raison pour laquelle la documentation asynchrone recommande cette surcharge pour les hébergeurs web. La surcharge synchrone convient uniquement aux outils de console ou aux services en arrière-plan où le blocage des threads est acceptable.
Streamez directement, sautez le tableau intermédiaire lorsque c'est possible. Pour les grands PDF, .Stream peut être écrit directement dans le corps de la réponse sans matérialiser le tableau de bytes complet :
[HttpGet("document/large")]
public IActionResult StreamLargeDocument(int documentId)
{
string html = BuildLargeDocumentHtml(documentId);
var pdf = _renderer.RenderHtmlAsPdf(html);
// Stream.Position is already at 0; no seek needed.
return File(pdf.Stream, "application/pdf", $"document-{documentId}.pdf");
}Imports Microsoft.AspNetCore.Mvc
<HttpGet("document/large")>
Public Function StreamLargeDocument(documentId As Integer) As IActionResult
Dim html As String = BuildLargeDocumentHtml(documentId)
Dim pdf = _renderer.RenderHtmlAsPdf(html)
' Stream.Position is already at 0; no seek needed.
Return File(pdf.Stream, "application/pdf", $"document-{documentId}.pdf")
End FunctionDisposez après utilisation. PdfDocument implémente IDisposable. L'envelopper dans une instruction using libère promptement le tampon de mémoire sous-jacent, ce qui est important lorsque vous générez de nombreux grands PDF consécutivement :
using var pdf = _renderer.RenderHtmlAsPdf(html);
byte[] data = pdf.BinaryData;
// pdf is disposed here; data is safely copied to the local array.
return File(data, "application/pdf", "output.pdf");Imports System.IO
Using pdf = _renderer.RenderHtmlAsPdf(html)
Dim data As Byte() = pdf.BinaryData
' pdf is disposed here; data is safely copied to the local array.
Return File(data, "application/pdf", "output.pdf")
End UsingPour obtenir des conseils sur le déploiement dans le cloud couvrant les environnements Azure , AWS, Docker et Linux, la documentation IronPDF fournit des notes de configuration spécifiques à chaque environnement. Si le premier rendu après le démarrage est lent, consultez le guide de préchauffage et de mise en cache pour des stratégies de pré-initialisation du moteur de rendu avant l'arrivée de la première requête utilisateur.
Un filigrane texte ou image peut être ajouté à chaque page du document généré avant la diffusion en continu :
[HttpGet("document/draft/{id:int}")]
public IActionResult GetDraftDocument(int id)
{
string html = BuildDocumentHtml(id);
var pdf = _renderer.RenderHtmlAsPdf(html);
// Stamp "DRAFT" diagonally across every page.
pdf.ApplyWatermark(
"<h1 style='color:rgba(200,0,0,0.25);transform:rotate(-45deg)'>DRAFT</h1>",
rotation: 45,
opacity: 30
);
return File(pdf.BinaryData, "application/pdf", $"draft-{id}.pdf");
}<AttributeUsage(AttributeTargets.Method, Inherited:=True, AllowMultiple:=False)>
Public Class HttpGetAttribute
Inherits Attribute
Public Sub New(route As String)
End Sub
End Class
<HttpGet("document/draft/{id:int}")>
Public Function GetDraftDocument(id As Integer) As IActionResult
Dim html As String = BuildDocumentHtml(id)
Dim pdf = _renderer.RenderHtmlAsPdf(html)
' Stamp "DRAFT" diagonally across every page.
pdf.ApplyWatermark(
"<h1 style='color:rgba(200,0,0,0.25);transform:rotate(-45deg)'>DRAFT</h1>",
rotation:=45,
opacity:=30
)
Return File(pdf.BinaryData, "application/pdf", $"draft-{id}.pdf")
End FunctionPour connaître toutes les options de configuration des filigranes, y compris les filigranes d'image et le contrôle par page, consultez la documentation sur les filigranes .
Installer avec NuGetLa génération dynamique de PDF dans ASP.NET Core suit un modèle cohérent : construisez votre HTML, appelez RenderHtmlAsPdf ou sa surcharge asynchrone, et retournez le résultat via un FileResult. IronPDF gère tout le reste (rendu Chromium, application CSS, exécution JavaScript ) sans nécessiter d'E/S disque à aucun stade.
À partir d'ici, vous pouvez explorer plusieurs pistes en fonction des exigences de votre application. Si vos fichiers PDF doivent combiner plusieurs documents sources, le guide de fusion et de division explique comment joindre des PDF existants à des pages nouvellement générées. Si vous avez besoin que les utilisateurs remplissent et soumettent des formulaires intégrés dans un PDF, la documentation sur les formulaires interactifs explique comment créer et lire les valeurs des champs. Pour les secteurs réglementés, la conformité PDF/A et l'accessibilité PDF/UA garantissent que les documents répondent aux normes d'archivage et d'accessibilité.
Si vous évaluez IronPDF par rapport à d'autres solutions, la comparaison iText vs IronPDF fournit une analyse technique détaillée. Lorsque vous serez prêt à passer en production, achetez une licence pour débloquer toutes les fonctionnalités et bénéficier d'une assistance technique prioritaire. La documentation complète de l'API répertorie chaque classe et méthode abordée dans ce guide.
Pour toute question ou problème lors de la mise en œuvre, l' équipe d'assistance technique est à votre disposition. Pour des informations spécifiques à chaque plateforme (Blazor Server ou MAUI), des guides dédiés détaillent les différences de configuration pour chaque modèle d'hôte.
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 et créer des manuels bien structurés et visuellement attrayants.
IronPDF fait partie de IRONSUITE
10 API .NET pour vos documents
Lorsque vous avez besoin que votre PDF ressemble à HTML, rapidement.
