Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. Utilisation de IronPDF
  4. Asp .NET Core PDF Viewer
UTILISATION DE IRONPDF

Comment créer un visualiseur de PDF ASP.NET Core avec IronPDF

Curtis Chau
Curtis Chau
Mis à jour:

L'affichage direct des documents PDF dans un navigateur web est une exigence courante pour les applications ASP.NET Core modernes. Que vous génériez des factures, des rapports ou des contrats, les utilisateurs s'attendent à une expérience de visualisation PDF fluide, sans avoir à télécharger de fichiers ni à installer de plugins tiers comme Adobe Acrobat Reader. IronPDF simplifie cette tâche en fournissant une génération de PDF côté serveur et une diffusion en continu via un moteur de rendu basé sur Chrome – aucune dépendance à un visualiseur externe n'est requise.

Ce tutoriel vous explique comment afficher, enregistrer et imprimer des fichiers PDF dans ASP.NET Core avec IronPDF. Vous découvrirez également comment la bibliothèque gère les déploiements de conteneurs et de cloud, ce qui en fait un choix fiable pour les pipelines DevOps de production.

Bannière promotionnelle de la bibliothèque PDF IronPDF C# mettant en avant la conversion HTML vers PDF, les outils d'édition, la flexibilité de déploiement et l'offre d'essai gratuit

Comment les navigateurs affichent-ils les fichiers PDF directement dans le navigateur ?

Les navigateurs modernes incluent des visionneuses PDF intégrées qui s'activent lors de la réception d'une réponse avec le type MIME application/pdf. Lorsque votre contrôleur ASP.NET Core renvoie un PDF avec l'en-tête Content-Type correct, le navigateur l'affiche automatiquement en ligne ; aucune installation de plugin n'est nécessaire. Selon la documentation MDN , une configuration correcte du type MIME est essentielle pour contrôler la manière dont les navigateurs traitent les réponses des fichiers.

IronPDF génère des PDF côté serveur grâce à sa classe ChromePdfRenderer, qui intègre un moteur Chromium complet. Ainsi, les documents sont rendus avec une prise en charge complète des CSS, JavaScript, des polices web et des signatures numériques — le même pipeline de rendu que celui utilisé par Google Chrome. Le résultat est un rendu d'une précision pixel parfaite que les navigateurs affichent directement, sans aucune bibliothèque de visualisation côté client.

Cette architecture est particulièrement précieuse pour les environnements conteneurisés. Le moteur de rendu s'exécute entièrement en interne, sans générer de processus de navigateur externes sans interface graphique ni dépendre de services distants. Le nettoyage des ressources s'effectue automatiquement, évitant ainsi les fuites de mémoire dans les services ASP.NET Core de longue durée. Vous pouvez consulter l'ensemble des fonctionnalités d'IronPDF pour comprendre toutes les capacités de rendu disponibles.

Grille de fonctionnalités à quatre colonnes présentant les capacités du logiciel PDF : Créer des PDF, Convertir des PDF, Modifier des PDF, Signer et sécuriser des PDF, avec des listes de fonctionnalités détaillées sous chaque catégorie

Pourquoi le rendu côté serveur produit-il des résultats cohérents ?

Le rendu côté serveur élimine les variations liées au navigateur dans le processus de génération de PDF. Lorsque les fichiers PDF sont générés côté client, la qualité du résultat dépend de la version du navigateur, du système d'exploitation et des polices installées de l'utilisateur final. Avec IronPDF, le même moteur Chromium fonctionne sur chaque serveur – qu'il s'agisse de Windows, de Linux ou d'un conteneur Docker – garantissant un résultat identique pour les documents de conformité, les factures et les contrats signés.

Qu'apporte le moteur Chrome par rapport aux simples convertisseurs HTML vers PDF ?

Les convertisseurs HTML vers PDF simples omettent souvent l'exécution de JavaScript , ignorent les requêtes média CSS ou produisent une typographie de mauvaise qualité. Le moteur Chrome d'IronPDF attend que JavaScript soit terminé, respecte les styles @media print, gère les graphiques SVG et prend en charge l'encodage de caractères UTF-8 pour le contenu international. Cette fidélité est importante lors de l'affichage de documents que les utilisateurs vont également imprimer ou archiver.

Comment installer IronPDF dans un projet ASP.NET Core ?

La création d'un nouveau projet ASP.NET Core ne nécessite qu'une seule commande. Ouvrez un terminal et exécutez :

dotnet new mvc -n PdfViewerApp
cd PdfViewerApp
dotnet new mvc -n PdfViewerApp
cd PdfViewerApp
SHELL

Ensuite, installez le package NuGet IronPDF . Vous pouvez utiliser soit la console du gestionnaire de packages, soit l'interface de ligne de commande .NET :

Install-Package IronPdf
dotnet add package IronPdf
Install-Package IronPdf
dotnet add package IronPdf
SHELL

Cela installe tout ce qui est nécessaire : le moteur Chrome, les bibliothèques de traitement PDF et toutes les dépendances spécifiques à la plateforme. IronPDF prend en charge .NET 6, 7, 8, 9 et 10 sans configuration supplémentaire du framework. La documentation IronPDF couvre les options d'installation avancées, notamment les packages allégés pour les déploiements à taille limitée tels que AWS Lambda .

Console du gestionnaire de packages de Visual Studio affichant la progression de l'installation du package NuGet IronPDF , montrant le téléchargement de plusieurs dépendances, notamment les composants Iron Software , gRPC et System.Threading.Channels

Quel forfait choisir ?

Pour les déploiements standard, utilisez IronPdf. Pour les environnements avec des limites de taille strictes -- comme AWS Lambda ou les fonctions edge -- le package IronPdf.Slim réduit l'empreinte de téléchargement initiale. Les deux variantes exposent la même API, aucune modification de code n'est donc nécessaire lors du passage d'une variante à l'autre.

Quels sont les problèmes d'installation courants dans les environnements conteneurisés ?

Les conteneurs Linux nécessitent parfois des bibliothèques système supplémentaires pour les opérations graphiques. Une configuration Dockerfile minimale comprend :

apt-get update && apt-get install -y libgdiplus libc6-dev libx11-dev
apt-get update && apt-get install -y libgdiplus libc6-dev libx11-dev
SHELL

Les conteneurs Windows fonctionnent généralement sans dépendances supplémentaires. Pour le dépannage, activez la journalisation intégrée d'IronPDF afin de capturer les erreurs de rendu avant qu'elles n'apparaissent sous forme de réponses HTTP 500.

Comment afficher un PDF directement dans le navigateur ?

Le renvoi d'un PDF pour une visualisation en ligne dans le navigateur nécessite trois choses : générer le PDF, définir le type MIME application/pdf et omettre le paramètre de nom de fichier du résultat File(). Voici une action de contrôleur complète :

using IronPdf;
using Microsoft.AspNetCore.Mvc;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllersWithViews();
var app = builder.Build();
app.MapControllerRoute(name: "default", pattern: "{controller=Home}/{action=Index}/{id?}");
app.Run();

// PdfController.cs
public class PdfController : Controller
{
    public IActionResult ViewPdf()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PrintHtmlBackgrounds = true;
        renderer.RenderingOptions.CreatePdfFormsFromHtml = true;
        renderer.RenderingOptions.EnableJavaScript = true;
        renderer.RenderingOptions.RenderDelay = 100;

        var html = @"
            <html>
            <head>
                <style>
                    body { font-family: Arial, sans-serif; padding: 20px; }
                    h1 { color: #2c3e50; }
                    .content { line-height: 1.6; }
                </style>
            </head>
            <body>
                <h1>Invoice #12345</h1>
                <div class='content'>
                    <p>Date: " + DateTime.Now.ToString("yyyy-MM-dd") + @"</p>
                    <p>Thank you for your business!</p>
                </div>
            </body>
            </html>";

        var pdf = renderer.RenderHtmlAsPdf(html);

        // Omitting the filename tells the browser to display inline
        return File(pdf.BinaryData, "application/pdf");
    }
}
using IronPdf;
using Microsoft.AspNetCore.Mvc;

var builder = WebApplication.CreateBuilder(args);
builder.Services.AddControllersWithViews();
var app = builder.Build();
app.MapControllerRoute(name: "default", pattern: "{controller=Home}/{action=Index}/{id?}");
app.Run();

// PdfController.cs
public class PdfController : Controller
{
    public IActionResult ViewPdf()
    {
        var renderer = new ChromePdfRenderer();
        renderer.RenderingOptions.PrintHtmlBackgrounds = true;
        renderer.RenderingOptions.CreatePdfFormsFromHtml = true;
        renderer.RenderingOptions.EnableJavaScript = true;
        renderer.RenderingOptions.RenderDelay = 100;

        var html = @"
            <html>
            <head>
                <style>
                    body { font-family: Arial, sans-serif; padding: 20px; }
                    h1 { color: #2c3e50; }
                    .content { line-height: 1.6; }
                </style>
            </head>
            <body>
                <h1>Invoice #12345</h1>
                <div class='content'>
                    <p>Date: " + DateTime.Now.ToString("yyyy-MM-dd") + @"</p>
                    <p>Thank you for your business!</p>
                </div>
            </body>
            </html>";

        var pdf = renderer.RenderHtmlAsPdf(html);

        // Omitting the filename tells the browser to display inline
        return File(pdf.BinaryData, "application/pdf");
    }
}
Imports IronPdf
Imports Microsoft.AspNetCore.Mvc

Dim builder = WebApplication.CreateBuilder(args)
builder.Services.AddControllersWithViews()
Dim app = builder.Build()
app.MapControllerRoute(name:="default", pattern:="{controller=Home}/{action=Index}/{id?}")
app.Run()

' PdfController.vb
Public Class PdfController
    Inherits Controller

    Public Function ViewPdf() As IActionResult
        Dim renderer = New ChromePdfRenderer()
        renderer.RenderingOptions.PrintHtmlBackgrounds = True
        renderer.RenderingOptions.CreatePdfFormsFromHtml = True
        renderer.RenderingOptions.EnableJavaScript = True
        renderer.RenderingOptions.RenderDelay = 100

        Dim html = "
            <html>
            <head>
                <style>
                    body { font-family: Arial, sans-serif; padding: 20px; }
                    h1 { color: #2c3e50; }
                    .content { line-height: 1.6; }
                </style>
            </head>
            <body>
                <h1>Invoice #12345</h1>
                <div class='content'>
                    <p>Date: " & DateTime.Now.ToString("yyyy-MM-dd") & "</p>
                    <p>Thank you for your business!</p>
                </div>
            </body>
            </html>"

        Dim pdf = renderer.RenderHtmlAsPdf(html)

        ' Omitting the filename tells the browser to display inline
        Return File(pdf.BinaryData, "application/pdf")
    End Function
End Class
$vbLabelText   $csharpLabel

La clé est l'appel File() : renvoyer application/pdf sans nom de fichier définit Content-Disposition: inline, ce qui déclenche la visionneuse PDF intégrée du navigateur. L'ajout d'un nom de fichier passe à Content-Disposition: attachment, ce qui déclenche un téléchargement. Pour plus de modèles de conversion HTML, consultez le guide de conversion de chaînes HTML en PDF .

Pour les applications à fort trafic, utilisez la méthode de rendu asynchrone afin d'éviter le blocage des threads :

public async Task<IActionResult> ViewPdfAsync()
{
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.Timeout = 60;

    var html = await GetHtmlContentAsync();
    var pdf = await renderer.RenderHtmlAsPdfAsync(html);

    return File(pdf.BinaryData, "application/pdf");
}
public async Task<IActionResult> ViewPdfAsync()
{
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.Timeout = 60;

    var html = await GetHtmlContentAsync();
    var pdf = await renderer.RenderHtmlAsPdfAsync(html);

    return File(pdf.BinaryData, "application/pdf");
}
Imports System.Threading.Tasks

Public Async Function ViewPdfAsync() As Task(Of IActionResult)
    Dim renderer = New ChromePdfRenderer()
    renderer.RenderingOptions.Timeout = 60

    Dim html = Await GetHtmlContentAsync()
    Dim pdf = Await renderer.RenderHtmlAsPdfAsync(html)

    Return File(pdf.BinaryData, "application/pdf")
End Function
$vbLabelText   $csharpLabel

Exemple d'une facture PDF basique visualisée dans une visionneuse PDF en ligne avec commandes de navigation standard

Quand faut-il utiliser la génération de PDF asynchrone ?

La génération asynchrone est importante pour tout point de terminaison recevant des requêtes simultanées. La génération synchrone bloque les threads du pool de threads ASP.NET Core , réduisant ainsi le nombre de requêtes simultanées que votre application peut gérer. Passez rapidement aux méthodes asynchrones : l'interface de l'API est identique, la migration est donc simple.

Quelles autres sources HTML pouvez-vous interpréter ?

Outre les chaînes HTML, IronPDF effectue des rendus à partir d'URL, de fichiers HTML sur disque et de vues Razor . L'appel à renderer.RenderUrlAsPdf("https://example.com/report") capture une URL en direct, tandis que renderer.RenderHtmlFileAsPdf("wwwroot/templates/invoice.html") lit à partir du système de fichiers local. Cette flexibilité vous permet de réutiliser des modèles Razor existants comme modèles PDF sans avoir à gérer des fichiers HTML séparés. La page de la galerie NuGet pour IronPDF affiche la version actuelle du package et les notes de version.

Comment activer le téléchargement de fichiers PDF dans ASP.NET Core?

Le déclenchement du téléchargement d'un fichier au lieu de l'affichage en ligne ne nécessite qu'un seul paramètre. L'ajout d'un nom de fichier au résultat File() définit l'en-tête Content-Disposition sur attachment :

public IActionResult DownloadPdf()
{
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.ImageQuality = 85;

    var html = @"<h1>Quarterly Report</h1>
                 <p>Revenue this quarter exceeded projections by 12%.</p>";
    var pdf = renderer.RenderHtmlAsPdf(html, @"wwwroot/images");

    // Compress images to reduce download size
    pdf.CompressImages(30);

    // The filename parameter triggers download instead of inline view
    return File(pdf.BinaryData, "application/pdf", "quarterly-report-2026.pdf");
}
public IActionResult DownloadPdf()
{
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.ImageQuality = 85;

    var html = @"<h1>Quarterly Report</h1>
                 <p>Revenue this quarter exceeded projections by 12%.</p>";
    var pdf = renderer.RenderHtmlAsPdf(html, @"wwwroot/images");

    // Compress images to reduce download size
    pdf.CompressImages(30);

    // The filename parameter triggers download instead of inline view
    return File(pdf.BinaryData, "application/pdf", "quarterly-report-2026.pdf");
}
Public Function DownloadPdf() As IActionResult
    Dim renderer = New ChromePdfRenderer()
    renderer.RenderingOptions.ImageQuality = 85

    Dim html As String = "<h1>Quarterly Report</h1>
                          <p>Revenue this quarter exceeded projections by 12%.</p>"
    Dim pdf = renderer.RenderHtmlAsPdf(html, "wwwroot/images")

    ' Compress images to reduce download size
    pdf.CompressImages(30)

    ' The filename parameter triggers download instead of inline view
    Return File(pdf.BinaryData, "application/pdf", "quarterly-report-2026.pdf")
End Function
$vbLabelText   $csharpLabel

Pour les documents volumineux diffusés à de nombreux utilisateurs, le streaming réduit la consommation de mémoire maximale :

public IActionResult StreamPdf()
{
    var renderer = new ChromePdfRenderer();
    var html = "<h1>Large Report</h1><p>Content spanning many pages.</p>";
    var pdf = renderer.RenderHtmlAsPdf(html);

    var stream = pdf.Stream;
    stream.Position = 0;

    // Stream directly without buffering the full byte array
    return File(stream, "application/pdf", "report.pdf");
}
public IActionResult StreamPdf()
{
    var renderer = new ChromePdfRenderer();
    var html = "<h1>Large Report</h1><p>Content spanning many pages.</p>";
    var pdf = renderer.RenderHtmlAsPdf(html);

    var stream = pdf.Stream;
    stream.Position = 0;

    // Stream directly without buffering the full byte array
    return File(stream, "application/pdf", "report.pdf");
}
Imports IronPdf

Public Function StreamPdf() As IActionResult
    Dim renderer As New ChromePdfRenderer()
    Dim html As String = "<h1>Large Report</h1><p>Content spanning many pages.</p>"
    Dim pdf = renderer.RenderHtmlAsPdf(html)

    Dim stream = pdf.Stream
    stream.Position = 0

    ' Stream directly without buffering the full byte array
    Return File(stream, "application/pdf", "report.pdf")
End Function
$vbLabelText   $csharpLabel

Le streaming envoie les données PDF progressivement, ce qui réduit considérablement la consommation de mémoire maximale lors de la diffusion de fichiers volumineux à des utilisateurs simultanés. Pour plus de modèles d'exportation, consultez le guide sur la fusion et la division des PDF et l'extraction de texte à partir des PDF .

Exemple de document PDF généré avec IronPDF for .NET, affiché dans une interface de visionneuse PDF standard

Quels paramètres de compression sont les plus adaptés aux différents types de documents ?

Les fichiers PDF riches en texte se compressent bien à 70-80 % de la qualité d'image avec un impact visuel minimal. Les documents riches en images, tels que les brochures marketing, nécessitent une qualité de 85 à 95 % pour préserver leur netteté. Les rapports financiers comportant des graphiques doivent conserver un taux d'occupation des yeux de 85 % ou plus afin de maintenir la lisibilité des graphiques. Tester les niveaux de compression sur des documents représentatifs avant le déploiement en production.

Comment générer des PDF prêts à imprimer avec ASP.NET Core?

Les PDF prêts à imprimer nécessitent une configuration de page spécifique : type de média CSS d'impression, marges définies et format de papier explicite. IronPDF expose tous ces éléments via RenderingOptions :

public IActionResult PrintablePdf()
{
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
    renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait;
    renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
    renderer.RenderingOptions.MarginTop = 25;
    renderer.RenderingOptions.MarginBottom = 25;
    renderer.RenderingOptions.MarginLeft = 25;
    renderer.RenderingOptions.MarginRight = 25;

    // Add headers and footers for professional print output
    renderer.RenderingOptions.TextHeader = new TextHeaderFooter
    {
        CenterText = "Confidential Document",
        DrawDividerLine = true
    };
    renderer.RenderingOptions.TextFooter = new TextHeaderFooter
    {
        CenterText = "Page {page} of {total-pages}",
        FontSize = 10
    };

    var html = @"
        <style>
            @media print {
                .no-print { display: none; }
                .page-break { page-break-after: always; }
            }
        </style>
        <h1>Print-Ready Document</h1>
        <p>This document is formatted for A4 printing with standard margins.</p>
        <div class='page-break'></div>
        <h2>Page 2</h2>
        <p>Content continues on the second page.</p>";

    var pdf = renderer.RenderHtmlAsPdf(html);
    return File(pdf.BinaryData, "application/pdf");
}
public IActionResult PrintablePdf()
{
    var renderer = new ChromePdfRenderer();
    renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
    renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait;
    renderer.RenderingOptions.PaperSize = PdfPaperSize.A4;
    renderer.RenderingOptions.MarginTop = 25;
    renderer.RenderingOptions.MarginBottom = 25;
    renderer.RenderingOptions.MarginLeft = 25;
    renderer.RenderingOptions.MarginRight = 25;

    // Add headers and footers for professional print output
    renderer.RenderingOptions.TextHeader = new TextHeaderFooter
    {
        CenterText = "Confidential Document",
        DrawDividerLine = true
    };
    renderer.RenderingOptions.TextFooter = new TextHeaderFooter
    {
        CenterText = "Page {page} of {total-pages}",
        FontSize = 10
    };

    var html = @"
        <style>
            @media print {
                .no-print { display: none; }
                .page-break { page-break-after: always; }
            }
        </style>
        <h1>Print-Ready Document</h1>
        <p>This document is formatted for A4 printing with standard margins.</p>
        <div class='page-break'></div>
        <h2>Page 2</h2>
        <p>Content continues on the second page.</p>";

    var pdf = renderer.RenderHtmlAsPdf(html);
    return File(pdf.BinaryData, "application/pdf");
}
Imports System.Web.Mvc

Public Function PrintablePdf() As ActionResult
    Dim renderer = New ChromePdfRenderer()
    renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print
    renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait
    renderer.RenderingOptions.PaperSize = PdfPaperSize.A4
    renderer.RenderingOptions.MarginTop = 25
    renderer.RenderingOptions.MarginBottom = 25
    renderer.RenderingOptions.MarginLeft = 25
    renderer.RenderingOptions.MarginRight = 25

    ' Add headers and footers for professional print output
    renderer.RenderingOptions.TextHeader = New TextHeaderFooter With {
        .CenterText = "Confidential Document",
        .DrawDividerLine = True
    }
    renderer.RenderingOptions.TextFooter = New TextHeaderFooter With {
        .CenterText = "Page {page} of {total-pages}",
        .FontSize = 10
    }

    Dim html = "
        <style>
            @media print {
                .no-print { display: none; }
                .page-break { page-break-after: always; }
            }
        </style>
        <h1>Print-Ready Document</h1>
        <p>This document is formatted for A4 printing with standard margins.</p>
        <div class='page-break'></div>
        <h2>Page 2</h2>
        <p>Content continues on the second page.</p>"

    Dim pdf = renderer.RenderHtmlAsPdf(html)
    Return File(pdf.BinaryData, "application/pdf")
End Function
$vbLabelText   $csharpLabel

Le paramétrage de CssMediaType.Print active les règles CSS @media print avant le rendu. Cela masque les barres de navigation, les barres latérales et autres éléments affichés uniquement à l'écran. Les utilisateurs peuvent ensuite imprimer le PDF à partir de la visionneuse intégrée du navigateur en utilisant les raccourcis clavier standard, avec un contrôle total sur la sélection de l'imprimante et le nombre de copies. Pour des exemples de modèles d'en-tête et de pied de page avancés, consultez le guide des en-têtes et pieds de page .

Vous pouvez également ajouter des filigranes aux documents imprimés, les signer numériquement avant livraison ou les protéger par un mot de passe et des paramètres d'autorisation . Ces fonctionnalités s'intègrent directement via l'API PdfDocument sans nécessiter d'étape de traitement séparée.

Exemple de document PDF prêt à imprimer tel qu'il apparaît dans une visionneuse PDF standard, montrant la mise en forme caractéristique pour l'impression

Quelle configuration de page garantit la compatibilité entre imprimantes ?

Les formats standard A4 ou Lettre avec des marges de 20 à 25 mm fonctionnent de manière fiable sur tous les modèles d'imprimantes. Évitez les formats de papier personnalisés, sauf si le déploiement cible un parc d'imprimantes connu. Utilisez les propriétés CSS page-break-before et page-break-after au lieu des méthodes de saut de page propriétaires. La spécification CSS Paged Media du W3C définit ces propriétés en détail. Ces propriétés CSS standard fonctionnent de manière cohérente entre le moteur de rendu Chrome et les imprimantes physiques.

Comment déployer une visionneuse PDF ASP.NET Core sur Docker ?

IronPDF fonctionne sur les conteneurs Linux et Windows sans modification du code. Les images de base utilisées dans le Dockerfile ci-dessous proviennent des images de conteneurs .NET officielles de Microsoft , qui sont mises à jour régulièrement avec des correctifs de sécurité. La configuration Docker ci-dessous installe les bibliothèques système requises et produit une image en plusieurs étapes pour une taille minimale :

FROM mcr.microsoft.com/dotnet/aspnet:10.0 AS base
WORKDIR /app

RUN apt-get update && apt-get install -y \
    libgdiplus \
    libc6-dev \
    libx11-dev \
    && rm -rf /var/lib/apt/lists/*

FROM mcr.microsoft.com/dotnet/sdk:10.0 AS build
WORKDIR /src
COPY ["PdfViewerApp.csproj", "./"]
RUN dotnet restore "PdfViewerApp.csproj"
COPY . .
RUN dotnet build "PdfViewerApp.csproj" -c Release -o /app/build

FROM build AS publish
RUN dotnet publish "PdfViewerApp.csproj" -c Release -o /app/publish

FROM base AS final
WORKDIR /app
COPY --from=publish /app/publish .
ENTRYPOINT ["dotnet", "PdfViewerApp.dll"]

Pour les déploiements Kubernetes, ajoutez un point de terminaison de vérification de l'état qui valide la génération de PDF de bout en bout :

builder.Services.AddHealthChecks()
    .AddCheck("pdf_generation", () =>
    {
        try
        {
            var renderer = new ChromePdfRenderer();
            var pdf = renderer.RenderHtmlAsPdf("<p>Health check</p>");
            return pdf.PageCount > 0
                ? HealthCheckResult.Healthy()
                : HealthCheckResult.Unhealthy("PDF generation returned empty document");
        }
        catch (Exception ex)
        {
            return HealthCheckResult.Unhealthy(ex.Message);
        }
    });
builder.Services.AddHealthChecks()
    .AddCheck("pdf_generation", () =>
    {
        try
        {
            var renderer = new ChromePdfRenderer();
            var pdf = renderer.RenderHtmlAsPdf("<p>Health check</p>");
            return pdf.PageCount > 0
                ? HealthCheckResult.Healthy()
                : HealthCheckResult.Unhealthy("PDF generation returned empty document");
        }
        catch (Exception ex)
        {
            return HealthCheckResult.Unhealthy(ex.Message);
        }
    });
Imports System
Imports Microsoft.Extensions.DependencyInjection
Imports Microsoft.Extensions.Diagnostics.HealthChecks

builder.Services.AddHealthChecks().AddCheck("pdf_generation", Function()
    Try
        Dim renderer As New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf("<p>Health check</p>")
        Return If(pdf.PageCount > 0, HealthCheckResult.Healthy(), HealthCheckResult.Unhealthy("PDF generation returned empty document"))
    Catch ex As Exception
        Return HealthCheckResult.Unhealthy(ex.Message)
    End Try
End Function)
$vbLabelText   $csharpLabel

Ce contrôle d'intégrité permet à Kubernetes de détecter et de remplacer les pods défaillants avant que les utilisateurs ne rencontrent des erreurs. Il s'intègre également aux intergiciels de surveillance de l'état de santé standard ASP.NET Core . La licence d'essai IronPDF inclut toutes les fonctionnalités pour les tests Docker sans aucune restriction.

Quels sont les avantages du déploiement d'un moteur de rendu intégré ?

Le tableau ci-dessous compare l'approche intégrée d'IronPDF aux configurations de serveur de navigateur sans interface graphique couramment utilisées pour la génération de PDF côté serveur :

Comparaison des approches de génération de PDF pour ASP.NET Core
Facteur IronPDF (En cours de traitement) Serveur de navigateur sans interface graphique
Complexité du déploiement package NuGet uniquement Processus ou service distinct
latence du réseau Aucun (en cours de traitement) Aller-retour HTTP par requête
Empreinte du conteneur Conteneur unique Deux contenants minimum
Surveillance de la santé Middleware standard ASP.NET Core Contrôle de santé du service séparé
Cohérence du rendu Moteur Chrome, version verrouillée Cela varie selon la version du navigateur.

Comment ajouter des fonctionnalités PDF avancées à la visionneuse ?

IronPDF va bien au-delà de la simple visualisation et du téléchargement. La même bibliothèque qui convertit le HTML en PDF offre également la gestion des formulaires PDF , les filigranes personnalisés , les signatures numériques et la conversion PDF-image , le tout sans modules supplémentaires.

Pour les flux de travail de gestion documentaire, vous pouvez convertir les fichiers téléchargés au format PDF, extraire le texte pour l'indexation, annoter les documents et les renvoyer aux utilisateurs, le tout au sein d'un seul contrôleur ASP.NET Core . La page des fonctionnalités IronPDF offre un aperçu complet des capacités, avec des exemples de code pour chaque domaine fonctionnel.

Principales fonctionnalités à prendre en compte pour les applications de visualisation :

  • Extraction de texte -- indexation du contenu PDF pour la recherche ou l'archivage de conformité
  • Fusionner et scinder : combiner plusieurs documents ou extraire des pages spécifiques
  • Filigrane : apposer une mention de confidentialité ou un logo sur les documents avant leur affichage.
  • Signatures numériques : signer les PDF générés avant leur diffusion dans le navigateur
  • En-têtes et pieds de page : ajoutez les numéros de page, les titres des documents et les lignes de séparation.

Comment gérez-vous la sécurité et le contrôle d'accès des fichiers PDF ?

Pour les applications affichant des documents sensibles, combinez les fonctionnalités de mot de passe et d'autorisation d'IronPDF avec le middleware d'autorisation d' ASP.NET Core. Configurez l'action du contrôleur pour exiger une authentification, puis diffusez le PDF en continu ; le document ne touche jamais au système de fichiers ni à un point de terminaison non authentifié.

Pour répondre aux exigences de traçabilité, signez numériquement les fichiers PDF avant la diffusion en continu. La signature enregistre l'horodatage de la signature et valide l'intégrité du document, ce qui est important pour les documents financiers et juridiques affichés via une visionneuse de navigateur.

Quelles sont les options de licence disponibles ?

La licence IronPDF commence par un essai gratuit incluant toutes les fonctionnalités, adapté au développement, à la mise en production et aux travaux de validation de concept dans les environnements Docker et Kubernetes. Les licences de production couvrent un large éventail de scénarios de déploiement, allant d'un seul développeur à un nombre illimité de serveurs.

La documentation IronPDF fournit des références API détaillées, des guides de migration pour la mise à niveau entre les versions .NET et des instructions d'installation spécifiques à la plateforme pour Windows, Linux, macOS, AWS et Azure.

IronPDF offers flexible licensing options starting at $749 for single developers up to $3,999 for unlimited usage, with significant discounts currently available

Intégrer une visionneuse PDF dans ASP.NET Core ne prend que quelques minutes avec IronPDF. Le moteur de rendu basé sur Chrome gère la complexité de la conversion HTML vers PDF, le résultat ASP.NET Core File() gère le comportement en ligne par rapport au téléchargement, et le même package couvre l'impression, le filigrane, les signatures numériques et les déploiements de conteneurs. Commencez par la version d'essai gratuite et ajoutez des fonctionnalités documentaires avancées au fur et à mesure que vos besoins évoluent.

Questions Fréquemment Posées

Comment IronPDF peut-il contribuer à l'affichage des PDF dans les applications ASP.NET Core ?

IronPDF simplifie le processus en utilisant un puissant moteur de rendu basé sur Chrome pour afficher les fichiers PDF directement dans les navigateurs web sans nécessiter de téléchargements ou de plugins supplémentaires.

Quels sont les avantages de l'utilisation d'une visionneuse PDF dans ASP.NET Core ?

L'utilisation d'une visionneuse de PDF comme IronPDF dans ASP.NET Core améliore l'expérience de l'utilisateur en permettant l'affichage, l'enregistrement et l'impression transparents des PDF dans le navigateur, ce qui élimine le besoin d'applications externes comme Adobe Acrobat Reader.

Est-il nécessaire d'installer Adobe Acrobat Reader pour visualiser les PDF avec IronPDF ?

Non, IronPDF permet de visualiser les PDF directement dans le navigateur, sans qu'il soit nécessaire d'utiliser Adobe Acrobat Reader ou d'autres plugins.

Quels types de documents peuvent être affichés à l'aide d'IronPDF dans une application ASP.NET Core ?

IronPDF peut être utilisé pour afficher divers types de documents tels que des factures, des rapports et des contrats de manière transparente dans les applications ASP.NET Core.

IronPDF prend-il en charge l'impression de documents PDF dans ASP.NET Core ?

Oui, IronPDF prend en charge l'impression de documents PDF directement à partir de l'application web, offrant ainsi une solution complète de gestion des PDF.

IronPDF peut-il rendre des mises en page PDF complexes avec précision en ASP.NET Core ?

IronPDF utilise un moteur de rendu basé sur Chrome pour rendre avec précision les mises en page PDF complexes, garantissant un affichage de haute qualité sans perte de fidélité.

Dois-je télécharger des fichiers PDF pour les visualiser à l'aide d'IronPDF for .NET Core ?

Non, IronPDF permet aux utilisateurs de visualiser des fichiers PDF directement dans le navigateur web sans avoir à les télécharger.

Comment IronPDF améliore-t-il l'expérience de visualisation des PDF dans les applications web ?

IronPDF améliore l'expérience de visualisation des PDF en offrant une intégration transparente avec ASP.NET Core, permettant aux utilisateurs de visualiser, d'enregistrer et d'imprimer des PDF directement dans le navigateur.

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

Équipe de soutien Iron

Nous sommes en ligne 24 heures sur 24, 5 jours sur 7.
Chat
Email
Appelez-moi