Comment générer dynamiquement des PDF en C#

Comment fonctionne le rendu PDF côté serveur dans ASP.NET?

IronPDF déplace entièrement le rendu PDF vers le serveur en utilisant un moteur Chrome sans tête. Votre contrôleur génère ou récupère un document PDF, le convertit en un tableau d'octets et le diffuse vers le navigateur avec un en-tête inline Content-Disposition. Le visualiseur PDF intégré du navigateur affiche ensuite le document à l'intérieur d'un <iframe> intégré dans votre panneau.

Ce Shift fondamental élimine les points de friction traditionnels :

• Aucun lecteur Adobe Reader ni extension de navigateur n'est requis sur l'ordinateur client.
• Rendu uniforme quel que soit le système d'exploitation ou la version du navigateur de l'utilisateur
• Contrôle total par programmation du contenu, de la mise en page et du style des documents
• Fonctionne dans les environnements Enterprise où les politiques informatiques bloquent l'installation des plugins

Le moteur de rendu Chrome de la bibliothèque produit un rendu d'une précision pixel parfaite à partir de sources HTML, URL et de contenu brut. Vous contrôlez chaque aspect du rendu (format du papier, marges, en-têtes, pieds de page et type média CSS) avant même que le PDF n'atteigne le client.

IronPDF prend également en charge le déploiement multiplateforme sur les serveurs Windows, Linux et macOS, ce qui le rend adapté aux applications ASP.NET hébergées dans le cloud et exécutées sur Azure ou AWS , ainsi qu'aux environnements conteneurisés utilisant Docker .

Comment configurer le package NuGet ?

Ouvrez Visual Studio, cliquez avec le bouton droit sur votre projet dans l'Explorateur de solutions et sélectionnez Gérer les packages NuGet . Recherchez IronPdf et installez-le. Vous pouvez également exécuter cette commande dans la console du gestionnaire de packages :

Install-Package IronPdf

Vous pouvez également utiliser la CLI .NET avec dotnet add package IronPdf. Une fois installé, ajoutez using IronPdf; en haut de votre classe de contrôleur ou de service pour accéder au namespace de la bibliothèque.

Pour une livraison PDF optimale, configurez votre Program.cs pour servir des fichiers statiques et configurer le routage :

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllersWithViews();
builder.Services.AddRazorPages();

var app = builder.Build();

app.UseStaticFiles();
app.UseRouting();

app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}");

app.Run();

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllersWithViews();
builder.Services.AddRazorPages();

var app = builder.Build();

app.UseStaticFiles();
app.UseRouting();

app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}");

app.Run();

Imports Microsoft.AspNetCore.Builder
Imports Microsoft.Extensions.DependencyInjection

Dim builder = WebApplication.CreateBuilder(args)

builder.Services.AddControllersWithViews()
builder.Services.AddRazorPages()

Dim app = builder.Build()

app.UseStaticFiles()
app.UseRouting()

app.MapControllerRoute(
    name: "default",
    pattern: "{controller=Home}/{action=Index}/{id?}")

app.Run()

L'enregistrement AddControllersWithViews() permet à la fois les points d'extrémité API et le rendu de vue - les deux sont nécessaires lorsque vous souhaitez servir du contenu PDF via des actions de contrôleur dédiées et l'afficher à l'intérieur des panneaux de vue Razor. Pour plus de détails sur la configuration, consultez la documentation de l'API IronPDF .

Comment afficher un fichier PDF directement dans un panneau ?

Le schéma de base est simple : une action de contrôleur génère un PDF, le convertit en octets, définit l'en-tête Content-Disposition sur inline, et retourne un résultat File. Un <iframe> dans la vue Razor pointe vers ce point d'extrémité.

Voici une implémentation complète du contrôleur :

[ApiController]
[Route("api/[controller]")]
public class PdfPanelController : ControllerBase
{
    [HttpGet("display/{documentId}")]
    public IActionResult DisplayPdfInPanel(string documentId)
    {
        var renderer = new ChromePdfRenderer();

        string filename = $"document_{documentId}.pdf";

        var htmlContent = $@"
            <html>
            <head>
                <style>
                    body {{font-family: Arial, sans-serif; margin: 40px;}}
                    h1 {{color: #333;}}
                    .content {{line-height: 1.6;}}
                </style>
            </head>
            <body>
                <h1>Document #{documentId}</h1>
                <div class='content'>
                    <p>This PDF is generated dynamically and displayed inline in your panel.</p>
                    <p>Generated at: {DateTime.Now:yyyy-MM-dd HH:mm:ss}</p>
                </div>
            </body>
            </html>";

        using var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);

        byte[] pdfBytes = pdfDocument.BinaryData;

        Response.Headers.Append("Content-Disposition", $"inline; filename={filename}");

        return File(pdfBytes, "application/pdf");
    }
}

[ApiController]
[Route("api/[controller]")]
public class PdfPanelController : ControllerBase
{
    [HttpGet("display/{documentId}")]
    public IActionResult DisplayPdfInPanel(string documentId)
    {
        var renderer = new ChromePdfRenderer();

        string filename = $"document_{documentId}.pdf";

        var htmlContent = $@"
            <html>
            <head>
                <style>
                    body {{font-family: Arial, sans-serif; margin: 40px;}}
                    h1 {{color: #333;}}
                    .content {{line-height: 1.6;}}
                </style>
            </head>
            <body>
                <h1>Document #{documentId}</h1>
                <div class='content'>
                    <p>This PDF is generated dynamically and displayed inline in your panel.</p>
                    <p>Generated at: {DateTime.Now:yyyy-MM-dd HH:mm:ss}</p>
                </div>
            </body>
            </html>";

        using var pdfDocument = renderer.RenderHtmlAsPdf(htmlContent);

        byte[] pdfBytes = pdfDocument.BinaryData;

        Response.Headers.Append("Content-Disposition", $"inline; filename={filename}");

        return File(pdfBytes, "application/pdf");
    }
}

Imports Microsoft.AspNetCore.Mvc
Imports System

<ApiController>
<Route("api/[controller]")>
Public Class PdfPanelController
    Inherits ControllerBase

    <HttpGet("display/{documentId}")>
    Public Function DisplayPdfInPanel(documentId As String) As IActionResult
        Dim renderer = New ChromePdfRenderer()

        Dim filename As String = $"document_{documentId}.pdf"

        Dim htmlContent As String = $"
            <html>
            <head>
                <style>
                    body {{font-family: Arial, sans-serif; margin: 40px;}}
                    h1 {{color: #333;}}
                    .content {{line-height: 1.6;}}
                </style>
            </head>
            <body>
                <h1>Document #{documentId}</h1>
                <div class='content'>
                    <p>This PDF is generated dynamically and displayed inline in your panel.</p>
                    <p>Generated at: {DateTime.Now:yyyy-MM-dd HH:mm:ss}</p>
                </div>
            </body>
            </html>"

        Using pdfDocument = renderer.RenderHtmlAsPdf(htmlContent)
            Dim pdfBytes As Byte() = pdfDocument.BinaryData

            Response.Headers.Append("Content-Disposition", $"inline; filename={filename}")

            Return File(pdfBytes, "application/pdf")
        End Using
    End Function
End Class

La classe ChromePdfRenderer est le point d'entrée principal pour le rendu côté serveur. Elle accepte du contenu HTML, le convertit en utilisant un navigateur Chrome sans tête, et renvoie un objet PdfDocument. La propriété BinaryData expose les octets bruts pour le streaming.

Définir Content-Disposition sur inline est l'étape critique pour l'affichage du panneau. Sans cela, le navigateur propose un téléchargement au lieu de rendre à l'intérieur de <iframe>. Vous pouvez également ajouter des en-têtes et des pieds de page à chaque page, ou contrôler l'orientation de la page et les marges personnalisées via RenderingOptions.

Pour intégrer ce point d'extrémité dans un panneau Razor, créez un <iframe> pointant vers la route du contrôleur :

@page
@model IndexModel

<div class="container mt-4">
    <div class="card">
        <div class="card-header">
            <h3>PDF Display Panel</h3>
        </div>
        <div class="card-body">
            <div class="pdf-panel" style="height: 600px;">
                <iframe src="/api/PdfPanel/display/12345"
                        width="100%"
                        height="100%"
                        frameborder="0">
                </iframe>
            </div>
        </div>
    </div>
</div>

@page
@model IndexModel

<div class="container mt-4">
    <div class="card">
        <div class="card-header">
            <h3>PDF Display Panel</h3>
        </div>
        <div class="card-body">
            <div class="pdf-panel" style="height: 600px;">
                <iframe src="/api/PdfPanel/display/12345"
                        width="100%"
                        height="100%"
                        frameborder="0">
                </iframe>
            </div>
        </div>
    </div>
</div>

The provided code is a Razor page markup, which is not directly translatable to VB.NET as it is not C# code. Razor pages are used in ASP.NET Core for creating dynamic web pages and are written in a combination of HTML and C#.

If you need to convert the C# logic within a Razor page to VB.NET, you would typically focus on the code-behind file or any C# code embedded within the Razor markup. However, the provided snippet contains only HTML and Razor directives without any C# logic to convert.

If you have a specific C# code-behind logic or embedded C# code within a Razor page that you need to convert to VB.NET, please provide that portion, and I can assist with the conversion.

Le <iframe> demande le PDF depuis votre point d'extrémité de contrôleur. Le visualiseur PDF intégré au navigateur prend ensuite le relais, affichant le document en pleine largeur et en pleine hauteur sans aucune bibliothèque ni aucun plugin côté client.

Comment charger des fichiers PDF dynamiquement avec AJAX ?

Les sources <iframe> statiques fonctionnent bien pour le contenu fixe, mais de nombreuses applications doivent charger des PDFs en fonction des actions de l'utilisateur - cliquer sur un enregistrement dans une grille de données, soumettre un formulaire ou sélectionner un type de rapport. Une approche basée sur AJAX permet de gérer ces scénarios sans rechargement complet de la page.

L'action du contrôleur accepte un corps de requête et renvoie le PDF sous forme de chaîne base64 :

[HttpPost("generate")]
public async Task<IActionResult> GenerateDynamicPdf([FromBody] PdfRequestModel request)
{
    try
    {
        var renderer = new ChromePdfRenderer();

        renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;
        renderer.RenderingOptions.MarginTop = 20;
        renderer.RenderingOptions.MarginBottom = 20;
        renderer.RenderingOptions.MarginLeft = 20;
        renderer.RenderingOptions.MarginRight = 20;

        var htmlBuilder = new StringBuilder();
        htmlBuilder.Append("<html><body>");
        htmlBuilder.Append($"<h2>{request.Title}</h2>");
        htmlBuilder.Append($"<div>{request.Content}</div>");

        if (request.IncludeData)
        {
            htmlBuilder.Append("<table border='1' style='width:100%;'>");
            foreach (var item in request.DataItems)
            {
                htmlBuilder.Append($"<tr><td>{item.Key}</td><td>{item.Value}</td></tr>");
            }
            htmlBuilder.Append("</table>");
        }

        htmlBuilder.Append("</body></html>");

        var pdfDocument = await Task.Run(() =>
            renderer.RenderHtmlAsPdf(htmlBuilder.ToString()));

        var base64Pdf = Convert.ToBase64String(pdfDocument.BinaryData);

        return Ok(new { success = true, pdfData = base64Pdf });
    }
    catch (Exception ex)
    {
        return BadRequest(new { success = false, error = ex.Message });
    }
}

[HttpPost("generate")]
public async Task<IActionResult> GenerateDynamicPdf([FromBody] PdfRequestModel request)
{
    try
    {
        var renderer = new ChromePdfRenderer();

        renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;
        renderer.RenderingOptions.MarginTop = 20;
        renderer.RenderingOptions.MarginBottom = 20;
        renderer.RenderingOptions.MarginLeft = 20;
        renderer.RenderingOptions.MarginRight = 20;

        var htmlBuilder = new StringBuilder();
        htmlBuilder.Append("<html><body>");
        htmlBuilder.Append($"<h2>{request.Title}</h2>");
        htmlBuilder.Append($"<div>{request.Content}</div>");

        if (request.IncludeData)
        {
            htmlBuilder.Append("<table border='1' style='width:100%;'>");
            foreach (var item in request.DataItems)
            {
                htmlBuilder.Append($"<tr><td>{item.Key}</td><td>{item.Value}</td></tr>");
            }
            htmlBuilder.Append("</table>");
        }

        htmlBuilder.Append("</body></html>");

        var pdfDocument = await Task.Run(() =>
            renderer.RenderHtmlAsPdf(htmlBuilder.ToString()));

        var base64Pdf = Convert.ToBase64String(pdfDocument.BinaryData);

        return Ok(new { success = true, pdfData = base64Pdf });
    }
    catch (Exception ex)
    {
        return BadRequest(new { success = false, error = ex.Message });
    }
}

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

<HttpPost("generate")>
Public Async Function GenerateDynamicPdf(<FromBody> request As PdfRequestModel) As Task(Of IActionResult)
    Try
        Dim renderer = New ChromePdfRenderer()

        renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4
        renderer.RenderingOptions.MarginTop = 20
        renderer.RenderingOptions.MarginBottom = 20
        renderer.RenderingOptions.MarginLeft = 20
        renderer.RenderingOptions.MarginRight = 20

        Dim htmlBuilder = New StringBuilder()
        htmlBuilder.Append("<html><body>")
        htmlBuilder.Append($"<h2>{request.Title}</h2>")
        htmlBuilder.Append($"<div>{request.Content}</div>")

        If request.IncludeData Then
            htmlBuilder.Append("<table border='1' style='width:100%;'>")
            For Each item In request.DataItems
                htmlBuilder.Append($"<tr><td>{item.Key}</td><td>{item.Value}</td></tr>")
            Next
            htmlBuilder.Append("</table>")
        End If

        htmlBuilder.Append("</body></html>")

        Dim pdfDocument = Await Task.Run(Function() renderer.RenderHtmlAsPdf(htmlBuilder.ToString()))

        Dim base64Pdf = Convert.ToBase64String(pdfDocument.BinaryData)

        Return Ok(New With {Key .success = True, Key .pdfData = base64Pdf})
    Catch ex As Exception
        Return BadRequest(New With {Key .success = False, Key .error = ex.Message})
    End Try
End Function

Le bloc RenderingOptions vous permet de configurer la taille du papier, les marges, et le type de média CSS avant de rendre. Selon la documentation ASP.NET Core de Microsoft , les modèles asynchrones sont essentiels pour maintenir des interfaces réactives sous charge. Enveloppant l'appel de rendu synchrone dans Task.Run maintient le thread de demande libre tandis que le moteur Chrome traite le HTML.

La réponse base64 permet au client JavaScript de mettre à jour directement la source <iframe> sans rechargement de page :

fetch('/api/PdfPanel/generate', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(requestData)
})
.then(response => response.json())
.then(result => {
    if (result.success) {
        const iframe = document.getElementById('pdf-frame');
        iframe.src = 'data:application/pdf;base64,' + result.pdfData;
    }
});

fetch('/api/PdfPanel/generate', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(requestData)
})
.then(response => response.json())
.then(result => {
    if (result.success) {
        const iframe = document.getElementById('pdf-frame');
        iframe.src = 'data:application/pdf;base64,' + result.pdfData;
    }
});

Ce schéma fonctionne bien pour les Pages Razor et les vues MVC. Pour les cas d'utilisation avancés, IronPDF prend également en charge le rendu asynchrone nativement, vous pouvez donc utiliser RenderHtmlAsPdfAsync directement au lieu de Task.Run.

Comment gérez-vous les différents types de sources PDF ?

IronPDF peut générer des PDF à partir de trois sources principales : chaînes HTML, fichiers HTML locaux et URL externes. Chacun convient à des scénarios différents.

[HttpGet("from-html")]
public IActionResult GenerateFromHtmlString(string reportType)
{
    var renderer = new ChromePdfRenderer();

    var htmlTemplate = GetHtmlTemplate(reportType);

    var userName = User?.Identity?.Name ?? "Unknown";

    var processedHtml = htmlTemplate
        .Replace("{{DATE}}", DateTime.Now.ToString("yyyy-MM-dd"))
        .Replace("{{USER}}", userName)
        .Replace("{{REPORT_TYPE}}", reportType);

    renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;

    using var pdf = renderer.RenderHtmlAsPdf(processedHtml);

    pdf.SaveAs(Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", $"{reportType}.pdf"));

    return File(pdf.BinaryData, "application/pdf");
}

private string GetHtmlTemplate(string reportType)
{
    return @"
        <html>
        <head><title>{{REPORT_TYPE}} Report</title></head>
        <body>
            <h1>{{REPORT_TYPE}} Report</h1>
            <p>Date: {{DATE}}</p>
            <p>User: {{USER}}</p>
            <div>Report content goes here.</div>
        </body>
        </html>";
}

[HttpGet("from-html")]
public IActionResult GenerateFromHtmlString(string reportType)
{
    var renderer = new ChromePdfRenderer();

    var htmlTemplate = GetHtmlTemplate(reportType);

    var userName = User?.Identity?.Name ?? "Unknown";

    var processedHtml = htmlTemplate
        .Replace("{{DATE}}", DateTime.Now.ToString("yyyy-MM-dd"))
        .Replace("{{USER}}", userName)
        .Replace("{{REPORT_TYPE}}", reportType);

    renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;

    using var pdf = renderer.RenderHtmlAsPdf(processedHtml);

    pdf.SaveAs(Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", $"{reportType}.pdf"));

    return File(pdf.BinaryData, "application/pdf");
}

private string GetHtmlTemplate(string reportType)
{
    return @"
        <html>
        <head><title>{{REPORT_TYPE}} Report</title></head>
        <body>
            <h1>{{REPORT_TYPE}} Report</h1>
            <p>Date: {{DATE}}</p>
            <p>User: {{USER}}</p>
            <div>Report content goes here.</div>
        </body>
        </html>";
}

Imports System
Imports Microsoft.AspNetCore.Mvc
Imports IronPdf
Imports System.IO

<HttpGet("from-html")>
Public Function GenerateFromHtmlString(reportType As String) As IActionResult
    Dim renderer As New ChromePdfRenderer()

    Dim htmlTemplate As String = GetHtmlTemplate(reportType)

    Dim userName As String = If(User?.Identity?.Name, "Unknown")

    Dim processedHtml As String = htmlTemplate _
        .Replace("{{DATE}}", DateTime.Now.ToString("yyyy-MM-dd")) _
        .Replace("{{USER}}", userName) _
        .Replace("{{REPORT_TYPE}}", reportType)

    renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print

    Using pdf = renderer.RenderHtmlAsPdf(processedHtml)
        pdf.SaveAs(Path.Combine(Directory.GetCurrentDirectory(), "wwwroot", $"{reportType}.pdf"))
        Return File(pdf.BinaryData, "application/pdf")
    End Using
End Function

Private Function GetHtmlTemplate(reportType As String) As String
    Return "
        <html>
        <head><title>{{REPORT_TYPE}} Report</title></head>
        <body>
            <h1>{{REPORT_TYPE}} Report</h1>
            <p>Date: {{DATE}}</p>
            <p>User: {{USER}}</p>
            <div>Report content goes here.</div>
        </body>
        </html>"
End Function

[HttpGet("from-url")]
public async Task<IActionResult> GenerateFromUrl(string encodedUrl)
{
    var url = HttpUtility.UrlDecode(encodedUrl);

    var renderer = new ChromePdfRenderer();

    renderer.RenderingOptions.ViewPortWidth = 1920;
    renderer.RenderingOptions.EnableJavaScript = true;
    renderer.RenderingOptions.WaitFor.RenderDelay(2000);

    using var pdf = await renderer.RenderUrlAsPdfAsync(url);

    Response.Headers.Append("Content-Disposition", "inline; filename=webpage.pdf");

    return File(pdf.BinaryData, "application/pdf");
}

[HttpGet("from-url")]
public async Task<IActionResult> GenerateFromUrl(string encodedUrl)
{
    var url = HttpUtility.UrlDecode(encodedUrl);

    var renderer = new ChromePdfRenderer();

    renderer.RenderingOptions.ViewPortWidth = 1920;
    renderer.RenderingOptions.EnableJavaScript = true;
    renderer.RenderingOptions.WaitFor.RenderDelay(2000);

    using var pdf = await renderer.RenderUrlAsPdfAsync(url);

    Response.Headers.Append("Content-Disposition", "inline; filename=webpage.pdf");

    return File(pdf.BinaryData, "application/pdf");
}

Imports System.Web
Imports Microsoft.AspNetCore.Mvc

<HttpGet("from-url")>
Public Async Function GenerateFromUrl(encodedUrl As String) As Task(Of IActionResult)
    Dim url = HttpUtility.UrlDecode(encodedUrl)

    Dim renderer = New ChromePdfRenderer()

    renderer.RenderingOptions.ViewPortWidth = 1920
    renderer.RenderingOptions.EnableJavaScript = True
    renderer.RenderingOptions.WaitFor.RenderDelay(2000)

    Using pdf = Await renderer.RenderUrlAsPdfAsync(url)
        Response.Headers.Append("Content-Disposition", "inline; filename=webpage.pdf")
        Return File(pdf.BinaryData, "application/pdf")
    End Using
End Function

Comment gérez-vous la mémoire et les performances ?

La génération de PDF est gourmande en ressources. Chaque appel à ChromePdfRenderer crée un processus Chrome sans tête, et chaque objet PdfDocument maintient les octets rendus en mémoire. Une élimination appropriée évite les fuites de ressources et maintient la consommation de mémoire prévisible en cas de charge.

Utilisez toujours des déclarations using avec PdfDocument :

public IActionResult OptimizedPdfGeneration()
{
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.CreatePdfFormsFromHtml = false;

    var processedHtml = GetHtmlTemplate("report")
        .Replace("{{DATE}}", DateTime.Now.ToString("yyyy-MM-dd"))
        .Replace("{{USER}}", "Test")
        .Replace("{{REPORT_TYPE}}", "Report");

    using var pdf = renderer.RenderHtmlAsPdf(processedHtml);

    byte[] pdfBytes = pdf.BinaryData;
    pdf.SaveAs("output.pdf");

    return File(pdfBytes, "application/pdf");
}

public IActionResult OptimizedPdfGeneration()
{
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.CreatePdfFormsFromHtml = false;

    var processedHtml = GetHtmlTemplate("report")
        .Replace("{{DATE}}", DateTime.Now.ToString("yyyy-MM-dd"))
        .Replace("{{USER}}", "Test")
        .Replace("{{REPORT_TYPE}}", "Report");

    using var pdf = renderer.RenderHtmlAsPdf(processedHtml);

    byte[] pdfBytes = pdf.BinaryData;
    pdf.SaveAs("output.pdf");

    return File(pdfBytes, "application/pdf");
}

Imports System
Imports Microsoft.AspNetCore.Mvc

Public Class PdfController
    Inherits Controller

    Public Function OptimizedPdfGeneration() As IActionResult
        Dim renderer = New ChromePdfRenderer()
        renderer.RenderingOptions.CreatePdfFormsFromHtml = False

        Dim processedHtml = GetHtmlTemplate("report") _
            .Replace("{{DATE}}", DateTime.Now.ToString("yyyy-MM-dd")) _
            .Replace("{{USER}}", "Test") _
            .Replace("{{REPORT_TYPE}}", "Report")

        Using pdf = renderer.RenderHtmlAsPdf(processedHtml)
            Dim pdfBytes As Byte() = pdf.BinaryData
            pdf.SaveAs("output.pdf")

            Return File(pdfBytes, "application/pdf")
        End Using
    End Function

    Private Function GetHtmlTemplate(templateName As String) As String
        ' Placeholder for the actual implementation
        Return String.Empty
    End Function
End Class

La déclaration using garantit que l'objet PdfDocument est éliminé immédiatement après que vous ayez extrait le tableau d'octets, même si une exception se produit en aval. Pour les applications qui génèrent fréquemment des fichiers PDF, envisagez les stratégies supplémentaires suivantes :

• Mise en cache : Stocker les PDF fréquemment demandés dans le cache mémoire ou sur disque. Utilisez IMemoryCache pour mettre en cache le tableau d'octets indexé par un identifiant de document et un horodatage.
• Streaming : Pour les documents très volumineux, utilisez des flux de mémoire PDF au lieu de tableaux d'octets afin d'éviter l'allocation de grands blocs de mémoire contigus.
• Linéarisation : Activer la sortie linéarisée (affichage Web rapide) afin que les navigateurs puissent commencer le rendu avant que le fichier complet ne soit téléchargé.
• Compression : Appliquer la compression PDF pour réduire la taille des fichiers lors de la diffusion de documents via des connexions réseau limitées.

Le guide de performance IronPDF aborde des stratégies d'optimisation supplémentaires pour les scénarios à haut débit.

Comment garantir la sécurité et la compatibilité entre navigateurs ?

La sécurité et la fiabilité méritent toutes deux une attention particulière avant de déployer un affichage sur panneau PDF en production.

Validation des entrées : Nettoyez toujours le contenu dynamique avant de l'injecter dans les modèles HTML. Les données saisies par l'utilisateur sans traitement et interprétées par le moteur Chrome peuvent exposer votre serveur aux attaques SSRF et XSS. Utilisez des bibliothèques d'encodage HTML établies ou limitez les caractères autorisés à une liste blanche.

Contrôle d'accès : Protégez vos points de terminaison PDF derrière un intergiciel d'authentification et d'autorisation . Une URL comme /api/PdfPanel/display/12345 qui renvoie un document sans vérifier l'identité de l'appelant est un risque d'exposition de données. Appliquez des attributs [Authorize] et validez que l'utilisateur authentifié a l'autorisation d'accéder à l'ID du document demandé.

Configuration du type MIME: Retournez toujours application/pdf comme type de contenu. Les navigateurs qui reçoivent un type MIME incorrect peuvent déclencher une boîte de dialogue de téléchargement ou refuser de rendre en ligne. Vérifiez que les mappages de types MIME de votre application incluent PDF si vous servez également des fichiers PDF statiques depuis wwwroot.

Affichage en ligne inter-navigateurs: Les navigateurs modernes - Chrome, Firefox, Edge et Safari - supportent tous l'affichage en ligne de PDF via l'en-tête Content-Disposition: inline. La spécification W3C Content Security Policy fournit des indications sur les directives frame-ancestors si vos panneaux intègrent des PDF provenant de différentes origines. Le rendu côté serveur d'IronPDF élimine la plupart des incohérences de rendu des navigateurs, car la génération du PDF s'effectue indépendamment du client.

Gestion des erreurs : Encapsuler la génération du PDF dans des blocs try-catch et renvoyer des codes d'état HTTP significatifs. Une réponse de 500 sans corps est difficile à diagnostiquer. Retournez un objet d'erreur structuré afin que le code côté client puisse afficher un message convivial plutôt qu'un <iframe> cassé.

Pour la sécurité des documents, IronPDF prend en charge la protection par mot de passe et les autorisations , les signatures numériques et la conformité PDF/A pour les exigences d'archivage.

Quelles sont vos prochaines étapes ?

Vous avez maintenant un schéma fonctionnel pour afficher des PDFs dans des panneaux ASP.NET : installez IronPDF, créez une action de contrôleur qui génère un PDF et le renvoie avec Content-Disposition: inline, et intégrez le point d'extrémité dans un <iframe> à l'intérieur de votre panneau Razor. À partir de là, le modèle AJAX permet de charger des documents dynamiquement en réponse aux actions de l'utilisateur, sans rechargement de page.

Essayez gratuitement IronPDF pour tester ces modèles dans votre propre projet – aucune carte de crédit n'est requise. La version d'essai comprend un accès complet à toutes les fonctionnalités, y compris le rendu HTML vers PDF, la capture d'URL et la manipulation avancée des PDF.

Une fois votre affichage de base fonctionnel, considérez ces extensions naturelles :

• Fusionner ou diviser les fichiers PDF pour les flux de travail d'assemblage de documents
• Créer des formulaires PDF remplissables à partir de formulaires HTML
• Ajouter des signatures numériques pour l'authentification des documents
• Modifier des fichiers PDF existants pour y apposer un tampon, des annotations ou des suppressions de contenu.
• Convertir du HTML en PDF avec prise en charge complète du CSS et du JavaScript pour les mises en page de rapports complexes

La documentation IronPDF couvre chacune de ces fonctionnalités en détail, avec des exemples de code complets et une référence de configuration.