ASP.NET Core : créer des PDF à la volée avec IronPDF

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

" À 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 d'IronPDF expose une propriété .BinaryData et une propriété .Stream sur chaque document généré. L'un ou l'autre peut être transmis directement à un ASP.NET Core FileResult, ce qui fait du streaming une opération en une seule ligne en pratique.

Commencez avec IronPDF maintenant.

Accès gratuit

Comment installer IronPDF dans un projet ASP.NET Core ?

Ajoutez le package NuGet via la console du gestionnaire de packages ou l'interface de ligne de commande .NET :

Install-Package IronPdf
dotnet add package IronPdf

Install-Package IronPdf
dotnet add package IronPdf

Une fois le package installé, définissez votre clé de licence au démarrage de l'application -- généralement dans Program.cs avant la création du premier moteur de rendu :

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();

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 comme 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 .

Comment générer un PDF de facture à partir d'une chaîne HTML ?

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 le suivant : construire une chaîne HTML avec des données interpolées, la transmettre à RenderHtmlAsPdf, et renvoyer le résultat binaire sous forme de fichier à télécharger.

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} &nbsp;|&nbsp; 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");
    }
}

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} &nbsp;|&nbsp; 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");
    }
}

Imports IronPdf
Imports Microsoft.AspNetCore.Mvc

Public Class DocumentController
    Inherits Controller

    Private ReadOnly _renderer As ChromePdfRenderer

    Public Sub New(renderer As ChromePdfRenderer)
        _renderer = renderer
    End Sub

    <HttpGet("invoice/{orderId:int}")>
    Public Function GetInvoice(orderId As Integer) As IActionResult
        ' In a real application, fetch this from your database or order service.
        Dim order = GetOrderData(orderId)

        Dim html As String = $"
            <!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} &nbsp;|&nbsp; 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(Function(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(Function(i) i.Quantity * i.UnitPrice):F2}</td></tr>
                    </tfoot>
                </table>
            </body>
            </html>
            "

        Dim pdf = _renderer.RenderHtmlAsPdf(html)
        Return File(pdf.BinaryData, "application/pdf", $"invoice-{orderId}.pdf")
    End Function
End Class

RenderHtmlAsPdf traite l'intégralité du document HTML -- grille CSS, Flexbox, polices web, même SVG intégré -- en utilisant le même moteur Chromium qui alimente Google Chrome. Le PdfDocument renvoyé expose BinaryData (un byte[]) et Stream (un MemoryStream). Le passage de BinaryData à File() avec "application/pdf" et un nom de fichier déclenche un téléchargement dans 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 .

Comment diffuser un PDF directement dans le navigateur sans passer par une boîte de dialogue de téléchargement ?

Servir un PDF en ligne (l'ouvrir dans la visionneuse intégrée du navigateur plutôt que de le télécharger) nécessite deux petits changements : définir Content-Disposition sur 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");
}

[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 Function

L'utilisation de la surcharge asynchrone RenderHtmlAsPdfAsync est recommandée pour les contrôleurs ASP.NET Core car elle libère le thread du pool de threads pendant que Chromium effectue le rendu, maintenant ainsi le serveur réactif sous charge concurrente.

Comment générer des PDF à partir des résultats de requêtes Entity Framework Core ?

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

[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 Function

Les paramètres pdf.MetaData.Title et pdf.MetaData.Author intègrent ces informations dans les propriétés du document PDF, ce qui est utile pour le suivi de la 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 .

Comment appliquer des en-têtes, des pieds de page et des mesures de sécurité aux fichiers PDF générés ?

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 d'IronPDF couvre toutes ces exigences.

[HttpPost("document/secured")]
public async Task<IActionResult> GenerateSecuredDocument([FromBody] SecuredDocRequest request)
{
    var renderOptions = new ChromePdfRenderOptions
    {
        PaperSize       = PdfPaperSize.A4,
        MarginTop       = 45,
        MarginBottom    = 45,
        MarginLeft      = 25,
        MarginRight     = 25,
        EnableJavaScript = 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");
}

[HttpPost("document/secured")]
public async Task<IActionResult> GenerateSecuredDocument([FromBody] SecuredDocRequest request)
{
    var renderOptions = new ChromePdfRenderOptions
    {
        PaperSize       = PdfPaperSize.A4,
        MarginTop       = 45,
        MarginBottom    = 45,
        MarginLeft      = 25,
        MarginRight     = 25,
        EnableJavaScript = 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");
}

Imports System.Threading.Tasks
Imports Microsoft.AspNetCore.Mvc

<HttpPost("document/secured")>
Public Async Function GenerateSecuredDocument(<FromBody> request As SecuredDocRequest) As Task(Of IActionResult)
    Dim renderOptions As New ChromePdfRenderOptions With {
        .PaperSize = PdfPaperSize.A4,
        .MarginTop = 45,
        .MarginBottom = 45,
        .MarginLeft = 25,
        .MarginRight = 25,
        .EnableJavaScript = True,
        .WaitFor = New WaitFor With {.RenderDelay = 500}
    }

    renderOptions.TextHeader = New TextHeaderFooter With {
        .CenterText = request.DocumentTitle,
        .DrawDividerLine = True,
        .FontSize = 11
    }

    renderOptions.TextFooter = New TextHeaderFooter With {
        .LeftText = "{date} {time}",
        .RightText = "Page {page} of {total-pages}",
        .FontSize = 9
    }

    _renderer.RenderingOptions = renderOptions

    Dim pdf = Await _renderer.RenderHtmlAsPdfAsync(request.HtmlContent)

    If request.RequirePassword Then
        pdf.SecuritySettings.OwnerPassword = request.OwnerPassword
        pdf.SecuritySettings.UserPassword = request.UserPassword
        pdf.SecuritySettings.AllowUserPrinting = PdfPrintSecurity.NoPrint
        pdf.SecuritySettings.AllowUserCopyPasteContent = False
    End If

    Return File(pdf.BinaryData, "application/pdf", $"{request.FileName}.pdf")
End Function

Le paramètre WaitFor.RenderDelay est particulièrement utile lorsque votre HTML inclut des bibliothèques 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} présents dans le texte du pied de page sont automatiquement résolus par IronPDF lors du rendu. Parmi les options supplémentaires d'en-tête et de pied de page figurent les en-têtes HTML pour le placement du logo et la possibilité de personnaliser chaque section.

Quelles sont les meilleures pratiques en matière de performance pour la génération de PDF en grand volume ?

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 indiqué dans la section Installation, l'enregistrement de ChromePdfRenderer en tant que singleton dans le conteneur d'injection de dépendances évite le coût de lancement d'un nouveau sous-processus Chromium pour chaque requête. Selon les recommandations de Microsoft concernant les performances ASP.NET Core , la minimisation des allocations d'objets et la réutilisation des ressources coûteuses constituent les deux optimisations les plus efficaces.

Utilisez toujours async. RenderHtmlAsPdfAsync renvoie un Task<PdfDocument> et suspend le thread du contrôleur pendant que Chromium fonctionne. 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.

Transmettez directement les données, en ignorant le tableau intermédiaire lorsque cela est possible. Pour les fichiers PDF volumineux, .Stream peut être écrit directement dans le corps de la réponse sans matérialiser le tableau d'octets 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");
}

[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 Function

Éliminer après utilisation. PdfDocument implémente IDisposable. L'encapsuler dans une instruction using libère rapidement la mémoire tampon sous-jacente, ce qui est important lors de la génération successive de nombreux fichiers PDF volumineux :

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

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 Using

Pour 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 connaître les stratégies permettant de pré-initialiser le moteur de rendu avant l'arrivée de la première requête utilisateur.

Comment ajouter un filigrane à un PDF généré ?

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

[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 Function

$vbLabelText   $csharpLabel

Pour 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 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.

Quelles sont vos prochaines étapes ?

La 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 renvoyez 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.