Icône de message
Passer au contenu du pied de page
  1. IronPDF
  2. Blog IronPDF
  3. Utilisation de ironpdf
  4. Afficher les PDF dans le visionneur PDF ASP NET
UTILISATION DE IRONPDF

Comment afficher, sauvegarder et imprimer des fichiers PDF dans un visualiseur ASP.NET Core

Curtis Chau
Curtis Chau
Mis à jour:

Comment afficher, enregistrer et imprimer des PDF dans une visionneuse ASP.NET Core

IronPDF permet une visualisation transparente des PDF dans les applications ASP.NET Core en générant des PDF côté serveur et en tirant parti des visionneuses PDF intégrées aux navigateurs, éliminant ainsi le besoin de plugins tout en prenant en charge le déploiement multiplateforme dans les conteneurs Docker et les environnements cloud.

Afficher des documents PDF directement dans les navigateurs web est devenu une exigence essentielle pour les applications web modernes ASP.NET Core. Que vous génériez des factures , des rapports ou des contrats, les utilisateurs s'attendent à pouvoir visualiser les fichiers PDF sans avoir besoin de les télécharger ni d'installer Adobe Acrobat Reader. Ce tutoriel démontre comment IronPDF simplifie l'affichage, l'enregistrement et l'impression de fichiers PDF dans votre visionneuse ASP.NET Core grâce à son puissant moteur de rendu basé sur Chrome .

Comment les navigateurs gèrent-ils l'affichage des PDF dans ASP.NET Core ?

Les navigateurs modernes incluent des visualiseurs PDF intégrés qui s'activent lorsqu'ils reçoivent un fichier PDF avec le type MIME correct (application/pdf). Lorsque votre application ASP.NET Core renvoie un document PDF avec les en-têtes appropriés, le navigateur l'affiche automatiquement directement dans le code. Cela élimine le besoin de plugins externes, d'Adobe Acrobat Reader ou de bibliothèques JavaScript complexes. Selon MDN Web Docs, une configuration d'en-tête correcte est essentielle pour contrôler la manière dont les navigateurs gèrent les téléchargements et l'affichage des fichiers.

IronPDF tire parti de cette capacité du navigateur en générant des PDF de haute qualité côté serveur grâce à sa classe ChromePdfRenderer . Le moteur de rendu utilise un moteur Chrome complet en interne, garantissant que vos documents s'affichent exactement comme prévu grâce à une prise en charge complète des CSS modernes, de JavaScript , des signatures numériques et des polices Web . Contrairement aux simples visionneuses de documents, IronPDF offre un contrôle complet sur le traitement et le rendu des fichiers PDF .

De quels outils avez-vous besoin pour afficher/voir des fichiers PDF dans ASP.NET Core ?

Configurer IronPDF dans votre projet ASP.NET Core ne prend que quelques étapes. Tout d'abord, créez un nouveau projet dans Visual Studio ou via la ligne de commande. Ouvrez Visual Studio et sélectionnez le modèle de projet Application Web ASP.NET Core :

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

Comment installer IronPDF dans votre projet .NET ?

Installez IronPDF via le gestionnaire de packages NuGet dans votre projet :

Install-Package IronPdf

Ou, dans l'Explorateur de solutions, cliquez avec le bouton droit sur votre projet et sélectionnez "Gérer les packages NuGet". Choisissez la source de package appropriée et recherchez IronPDF.

C'est tout ce qui est nécessaire pour la configuration. IronPDF fonctionne parfaitement avec ASP.NET Core 3.1 et versions ultérieures (versions à support à long terme), y compris .NET 6, 7 et 8. La bibliothèque bénéficie de mises à jour fréquentes afin de garantir sa compatibilité avec les frameworks les plus récents. Pour des instructions d'installation détaillées, consultez le guide d'installation d'IronPDF . Le package inclut tous les composants nécessaires à la génération, à l'édition et au traitement des fichiers PDF . Pour les déploiements Docker , IronPDF fournit des images de conteneurs optimisées qui minimisent la complexité du déploiement, un élément essentiel pour les ingénieurs DevOps gérant des environnements conteneurisés.

Comment pouvez-vous afficher des fichiers PDF dans le navigateur en utilisant ASP.NET Core ?

La création et l'affichage de fichiers PDF dans le navigateur ne nécessitent que quelques lignes de code. Voici une action de contrôleur complète qui génère un PDF à partir de HTML et l'affiche directement dans le code :

using IronPdf;
using Microsoft.AspNetCore.Mvc;

public class PdfController : Controller
{
    public IActionResult ViewPdf()
    {
        var renderer = new ChromePdfRenderer();
        // Configure rendering options for the PDF viewer
        renderer.RenderingOptions.PrintHtmlBackgrounds = true;
        renderer.RenderingOptions.CreatePdfFormsFromHtml = true;
        renderer.RenderingOptions.EnableJavaScript = true;
        // Generate PDF from HTML string
        var html = @"
            <html>
            <head>
                <style>
                    body { font-family: Arial, sans-serif; padding: 20px; }
                    h1 { color: #2c3e50; }
                    .content { line-height: 1.6; width: 100%; }
                </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);
        // Return PDF for inline viewing in the browser
        return File(pdf.BinaryData, "application/pdf");
    }
}
using IronPdf;
using Microsoft.AspNetCore.Mvc;

public class PdfController : Controller
{
    public IActionResult ViewPdf()
    {
        var renderer = new ChromePdfRenderer();
        // Configure rendering options for the PDF viewer
        renderer.RenderingOptions.PrintHtmlBackgrounds = true;
        renderer.RenderingOptions.CreatePdfFormsFromHtml = true;
        renderer.RenderingOptions.EnableJavaScript = true;
        // Generate PDF from HTML string
        var html = @"
            <html>
            <head>
                <style>
                    body { font-family: Arial, sans-serif; padding: 20px; }
                    h1 { color: #2c3e50; }
                    .content { line-height: 1.6; width: 100%; }
                </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);
        // Return PDF for inline viewing in the browser
        return File(pdf.BinaryData, "application/pdf");
    }
}
Imports IronPdf
Imports Microsoft.AspNetCore.Mvc

Public Class PdfController
    Inherits Controller

    Public Function ViewPdf() As IActionResult
        Dim renderer = New ChromePdfRenderer()
        ' Configure rendering options for the PDF viewer
        renderer.RenderingOptions.PrintHtmlBackgrounds = True
        renderer.RenderingOptions.CreatePdfFormsFromHtml = True
        renderer.RenderingOptions.EnableJavaScript = True
        ' Generate PDF from HTML string
        Dim html = "
            <html>
            <head>
                <style>
                    body { font-family: Arial, sans-serif; padding: 20px; }
                    h1 { color: #2c3e50; }
                    .content { line-height: 1.6; width: 100%; }
                </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)
        ' Return PDF for inline viewing in the browser
        Return File(pdf.BinaryData, "application/pdf")
    End Function
End Class
$vbLabelText   $csharpLabel

Le code crée une instance ChromePdfRenderer et la configure pour inclure des couleurs d'arrière-plan et convertir les formulaires HTML en formulaires PDF . La méthode RenderHtmlAsPdf transforme la chaîne HTML en un PDF. Renvoyer le PDF avec le type MIME application/pdf indique au navigateur de l'afficher directement dans la page plutôt que de le télécharger. Cette approche côté serveur garantit un rendu cohérent sur tous les navigateurs et toutes les plateformes, ce qui est essentiel pour maintenir la fiabilité des déploiements Azure et des environnements AWS Lambda .

Sortie

! Interface de visualisation PDF affichant un document de facture simple portant le numéro 12345 et daté du 30/10/2025. La visionneuse PDF ASP.NET Core affiche correctement un document de facture rendu avec des commandes de navigation et des options de zoom dans la barre d'outils.

Pour les fichiers HTML ou les pages Razor existants, vous pouvez utiliser des méthodes de rendu alternatives :

// Render from URL - useful for complex pages
var pdf = renderer.RenderUrlAsPdf("___PROTECTED_URL_58___");
// Render from HTML file in the same location
var pdf = renderer.RenderHtmlFileAsPdf("Views/Invoice.html");
// Render from wwwroot folder
var pdf = renderer.RenderHtmlFileAsPdf("wwwroot/templates/report.html");
// For containerized applications, use environment-specific paths
var basePath = Environment.GetEnvironmentVariable("APP_BASE_PATH") ?? "wwwroot";
var pdf = renderer.RenderHtmlFileAsPdf($"{basePath}/templates/report.html");
// Render from URL - useful for complex pages
var pdf = renderer.RenderUrlAsPdf("___PROTECTED_URL_58___");
// Render from HTML file in the same location
var pdf = renderer.RenderHtmlFileAsPdf("Views/Invoice.html");
// Render from wwwroot folder
var pdf = renderer.RenderHtmlFileAsPdf("wwwroot/templates/report.html");
// For containerized applications, use environment-specific paths
var basePath = Environment.GetEnvironmentVariable("APP_BASE_PATH") ?? "wwwroot";
var pdf = renderer.RenderHtmlFileAsPdf($"{basePath}/templates/report.html");
' Render from URL - useful for complex pages
Dim pdf = renderer.RenderUrlAsPdf("___PROTECTED_URL_58___")
' Render from HTML file in the same location
pdf = renderer.RenderHtmlFileAsPdf("Views/Invoice.html")
' Render from wwwroot folder
pdf = renderer.RenderHtmlFileAsPdf("wwwroot/templates/report.html")
' For containerized applications, use environment-specific paths
Dim basePath = If(Environment.GetEnvironmentVariable("APP_BASE_PATH"), "wwwroot")
pdf = renderer.RenderHtmlFileAsPdf($"{basePath}/templates/report.html")
$vbLabelText   $csharpLabel

Ces méthodes offrent une grande flexibilité quant à la manière dont vous utilisez votre contenu HTML, tout en conservant une sortie PDF de haute qualité. Vous pouvez également charger des documents PDF existants , modifier des PDF et travailler avec des formats Word (fichiers DOCX) et Excel grâce aux fonctionnalités complètes d'IronPDF. Pour en savoir plus sur les options de conversion HTML vers PDF, consultez la documentation. Pour des fonctionnalités avancées de traitement et d'édition , consultez la documentation de l'API .

Pour les ingénieurs DevOps gérant des architectures de microservices, l'architecture moteur native vs distante d'IronPDF offre une grande flexibilité de déploiement. L'option de moteur distant vous permet de séparer le rendu PDF en un service dédié, améliorant ainsi l'utilisation des ressources et permettant une mise à l'échelle horizontale.

Comment les utilisateurs peuvent-ils enregistrer des documents PDF depuis le navigateur ?

Pour permettre aux utilisateurs de télécharger les fichiers PDF au lieu de les visualiser directement, modifiez l'en-tête Content-Disposition . Cette fonctionnalité est essentielle pour les applications où les utilisateurs ont besoin d'un accès hors ligne :

public IActionResult DownloadPdf()
{
    var renderer = new ChromePdfRenderer();
    // Create PDF with CSS styling and images
    var html = @"<h1>Download Me</h1>
                 <img src='logo.png' width='100' />";
    var pdf = renderer.RenderHtmlAsPdf(html, @"wwwroot/images");
    // Force download with custom filename
    return File(pdf.BinaryData, "application/pdf", "invoice-2024.pdf");
}

// Health check endpoint for container orchestration
[HttpGet("/health/pdf-generator")]
public IActionResult HealthCheck()
{
    try
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<p>Health Check</p>");
        return Ok(new { status = "healthy", timestamp = DateTime.UtcNow });
    }
    catch (Exception ex)
    {
        return StatusCode(503, new { status = "unhealthy", error = ex.Message });
    }
}
public IActionResult DownloadPdf()
{
    var renderer = new ChromePdfRenderer();
    // Create PDF with CSS styling and images
    var html = @"<h1>Download Me</h1>
                 <img src='logo.png' width='100' />";
    var pdf = renderer.RenderHtmlAsPdf(html, @"wwwroot/images");
    // Force download with custom filename
    return File(pdf.BinaryData, "application/pdf", "invoice-2024.pdf");
}

// Health check endpoint for container orchestration
[HttpGet("/health/pdf-generator")]
public IActionResult HealthCheck()
{
    try
    {
        var renderer = new ChromePdfRenderer();
        var pdf = renderer.RenderHtmlAsPdf("<p>Health Check</p>");
        return Ok(new { status = "healthy", timestamp = DateTime.UtcNow });
    }
    catch (Exception ex)
    {
        return StatusCode(503, new { status = "unhealthy", error = ex.Message });
    }
}
Public Function DownloadPdf() As IActionResult
    Dim renderer = New ChromePdfRenderer()
    ' Create PDF with CSS styling and images
    Dim html = "<h1>Download Me</h1>
                <img src='logo.png' width='100' />"
    Dim pdf = renderer.RenderHtmlAsPdf(html, "wwwroot/images")
    ' Force download with custom filename
    Return File(pdf.BinaryData, "application/pdf", "invoice-2024.pdf")
End Function

' Health check endpoint for container orchestration
<HttpGet("/health/pdf-generator")>
Public Function HealthCheck() As IActionResult
    Try
        Dim renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf("<p>Health Check</p>")
        Return Ok(New With {Key .status = "healthy", Key .timestamp = DateTime.UtcNow})
    Catch ex As Exception
        Return StatusCode(503, New With {Key .status = "unhealthy", Key .error = ex.Message})
    End Try
End Function
$vbLabelText   $csharpLabel

L'ajout du paramètre filename définit automatiquement l'en-tête Content-Disposition sur " attachment ", ce qui invite le navigateur à télécharger le fichier. Les utilisateurs peuvent également enregistrer les PDF affichés directement dans le document à l'aide de la fonction d'enregistrement de leur navigateur (Ctrl+S ou la barre d'outils du visualiseur PDF). Le point de terminaison de vérification de l'état de santé présenté ci-dessus est crucial pour les déploiements Kubernetes et les plateformes d'orchestration de conteneurs, garantissant ainsi la réactivité de votre service PDF.

Sortie

Visionneuse PDF affichant un document avec le texte Téléchargez-moi et le logo IronPDF pour .NET, affiché dans un navigateur à un zoom de 100 %. La visionneuse PDF affiche correctement le document de facture généré, la fonctionnalité de téléchargement étant activée via IronPDF pour .NET.

Pourquoi utiliser les flux pour les fichiers PDF volumineux ?

Pour une meilleure efficacité de la mémoire avec les documents volumineux, utilisez les flux :

public IActionResult StreamPdf()
{
    var renderer = new ChromePdfRenderer();
    // Load and process HTML with images
    var html = "<h1>Streamed Content</h1>";
    var pdf = renderer.RenderHtmlAsPdf(html);
    // Stream the PDF file to the browser
    var stream = pdf.Stream;
    stream.Position = 0;
    return File(stream, "application/pdf", "document.pdf");
}

// Async streaming for better resource utilization
public async Task<IActionResult> StreamPdfAsync()
{
    var renderer = new ChromePdfRenderer();
    // Configure for optimal container performance
    renderer.RenderingOptions.Timeout = 60000; // 60 seconds for complex documents
    renderer.RenderingOptions.RenderDelay = 500; // Allow JS to execute

    var html = await LoadHtmlTemplateAsync();
    var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf(html));

    var stream = pdf.Stream;
    stream.Position = 0;
    return File(stream, "application/pdf", "async-document.pdf");
}
public IActionResult StreamPdf()
{
    var renderer = new ChromePdfRenderer();
    // Load and process HTML with images
    var html = "<h1>Streamed Content</h1>";
    var pdf = renderer.RenderHtmlAsPdf(html);
    // Stream the PDF file to the browser
    var stream = pdf.Stream;
    stream.Position = 0;
    return File(stream, "application/pdf", "document.pdf");
}

// Async streaming for better resource utilization
public async Task<IActionResult> StreamPdfAsync()
{
    var renderer = new ChromePdfRenderer();
    // Configure for optimal container performance
    renderer.RenderingOptions.Timeout = 60000; // 60 seconds for complex documents
    renderer.RenderingOptions.RenderDelay = 500; // Allow JS to execute

    var html = await LoadHtmlTemplateAsync();
    var pdf = await Task.Run(() => renderer.RenderHtmlAsPdf(html));

    var stream = pdf.Stream;
    stream.Position = 0;
    return File(stream, "application/pdf", "async-document.pdf");
}
Imports System.Threading.Tasks

Public Function StreamPdf() As IActionResult
    Dim renderer = New ChromePdfRenderer()
    ' Load and process HTML with images
    Dim html = "<h1>Streamed Content</h1>"
    Dim pdf = renderer.RenderHtmlAsPdf(html)
    ' Stream the PDF file to the browser
    Dim stream = pdf.Stream
    stream.Position = 0
    Return File(stream, "application/pdf", "document.pdf")
End Function

' Async streaming for better resource utilization
Public Async Function StreamPdfAsync() As Task(Of IActionResult)
    Dim renderer = New ChromePdfRenderer()
    ' Configure for optimal container performance
    renderer.RenderingOptions.Timeout = 60000 ' 60 seconds for complex documents
    renderer.RenderingOptions.RenderDelay = 500 ' Allow JS to execute

    Dim html = Await LoadHtmlTemplateAsync()
    Dim pdf = Await Task.Run(Function() renderer.RenderHtmlAsPdf(html))

    Dim stream = pdf.Stream
    stream.Position = 0
    Return File(stream, "application/pdf", "async-document.pdf")
End Function
$vbLabelText   $csharpLabel

Cette approche réduit la consommation de mémoire en transmettant directement les fichiers PDF à la réponse sans créer de tableaux d'octets intermédiaires. Vous pouvez également charger des fichiers PDF existants depuis le dossier wwwroot, les modifier et diffuser les versions modifiées. Pour la manipulation avancée de documents PDF et le traitement d'images , consultez la documentation de l'API PdfDocument . Ce composant prend en charge diverses opérations d'édition, notamment la sélection de texte , le remplissage de formulaires et l'ajout de signatures numériques .

Pour les déploiements de conteneurs, l'approche de génération PDF asynchrone évite le blocage des threads et améliore le débit des applications, ce qui est essentiel pour maintenir des services réactifs dans des environnements orchestrés.

Les utilisateurs peuvent-ils imprimer des documents PDF directement depuis les applications web ASP.NET Core ?

IronPDF optimise les fichiers PDF pour l'impression en configurant le type de média CSS et les paramètres de page appropriés. Cela garantit un rendu professionnel, que les utilisateurs impriment sur des imprimantes physiques ou enregistrent au format PDF :

public IActionResult PrintablePdf()
{
    var renderer = new ChromePdfRenderer();
    // Configure printing options for the PDF viewer
    renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
    renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait;
    renderer.RenderingOptions.MarginTop = 25;
    renderer.RenderingOptions.MarginBottom = 25;
    renderer.RenderingOptions.MarginLeft = 25;
    renderer.RenderingOptions.MarginRight = 25;
    // Load HTML with print-specific CSS
    var html = @"<h1>Print-Optimized Document</h1>
                 <p>This document is optimized for printing.</p>";
    var pdf = renderer.RenderHtmlAsPdf(html);
    // Return the PDF file for viewing and printing
    return File(pdf.BinaryData, "application/pdf");
}

// Container-optimized configuration
public IActionResult ConfigureForContainer()
{
    var renderer = new ChromePdfRenderer();
    // Disable GPU for container compatibility
    renderer.RenderingOptions.EnableJavaScript = true;
    renderer.RenderingOptions.RenderDelay = 0; // No artificial delays
    renderer.RenderingOptions.Timeout = 30000; // 30 second timeout

    // Use environment variables for configuration
    var printDpi = int.Parse(Environment.GetEnvironmentVariable("PDF_PRINT_DPI") ?? "300");
    renderer.RenderingOptions.PrintHtmlBackgrounds = true;

    return Ok("Configured for container environment");
}
public IActionResult PrintablePdf()
{
    var renderer = new ChromePdfRenderer();
    // Configure printing options for the PDF viewer
    renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print;
    renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait;
    renderer.RenderingOptions.MarginTop = 25;
    renderer.RenderingOptions.MarginBottom = 25;
    renderer.RenderingOptions.MarginLeft = 25;
    renderer.RenderingOptions.MarginRight = 25;
    // Load HTML with print-specific CSS
    var html = @"<h1>Print-Optimized Document</h1>
                 <p>This document is optimized for printing.</p>";
    var pdf = renderer.RenderHtmlAsPdf(html);
    // Return the PDF file for viewing and printing
    return File(pdf.BinaryData, "application/pdf");
}

// Container-optimized configuration
public IActionResult ConfigureForContainer()
{
    var renderer = new ChromePdfRenderer();
    // Disable GPU for container compatibility
    renderer.RenderingOptions.EnableJavaScript = true;
    renderer.RenderingOptions.RenderDelay = 0; // No artificial delays
    renderer.RenderingOptions.Timeout = 30000; // 30 second timeout

    // Use environment variables for configuration
    var printDpi = int.Parse(Environment.GetEnvironmentVariable("PDF_PRINT_DPI") ?? "300");
    renderer.RenderingOptions.PrintHtmlBackgrounds = true;

    return Ok("Configured for container environment");
}
Imports System

Public Class PdfController
    Public Function PrintablePdf() As IActionResult
        Dim renderer As New ChromePdfRenderer()
        ' Configure printing options for the PDF viewer
        renderer.RenderingOptions.CssMediaType = PdfCssMediaType.Print
        renderer.RenderingOptions.PaperOrientation = PdfPaperOrientation.Portrait
        renderer.RenderingOptions.MarginTop = 25
        renderer.RenderingOptions.MarginBottom = 25
        renderer.RenderingOptions.MarginLeft = 25
        renderer.RenderingOptions.MarginRight = 25
        ' Load HTML with print-specific CSS
        Dim html As String = "<h1>Print-Optimized Document</h1>
                              <p>This document is optimized for printing.</p>"
        Dim pdf = renderer.RenderHtmlAsPdf(html)
        ' Return the PDF file for viewing and printing
        Return File(pdf.BinaryData, "application/pdf")
    End Function

    ' Container-optimized configuration
    Public Function ConfigureForContainer() As IActionResult
        Dim renderer As New ChromePdfRenderer()
        ' Disable GPU for container compatibility
        renderer.RenderingOptions.EnableJavaScript = True
        renderer.RenderingOptions.RenderDelay = 0 ' No artificial delays
        renderer.RenderingOptions.Timeout = 30000 ' 30 second timeout

        ' Use environment variables for configuration
        Dim printDpi As Integer = Integer.Parse(Environment.GetEnvironmentVariable("PDF_PRINT_DPI") Or "300")
        renderer.RenderingOptions.PrintHtmlBackgrounds = True

        Return Ok("Configured for container environment")
    End Function
End Class
$vbLabelText   $csharpLabel

Définir CssMediaType sur Print applique des styles CSS spécifiques à l'impression, garantissant ainsi que le document s'affiche correctement une fois imprimé. Les paramètres de marge assurent un espacement approprié pour le papier physique. Les utilisateurs peuvent imprimer des fichiers PDF directement depuis la visionneuse PDF de leur navigateur en utilisant la boîte de dialogue d'impression standard, tout en conservant un contrôle total sur la sélection et les paramètres de l'imprimante. Découvrez plus d'options de rendu PDF pour optimiser votre sortie.

![Interface de visionneuse PDF affichant un document optimisé pour l'impression avec le message " Ce document est optimisé pour l'impression " affiché au centre d'une page blanche. Le visualiseur PDF affiche un message de confirmation lorsqu'un document a été optimisé pour l'impression, garantissant ainsi aux utilisateurs que leur fichier est prêt pour une sortie de haute qualité.

Comment IronPDF prend-il en charge les déploiements multiplateformes et conteneurisés ?

IronPDF fonctionne parfaitement sur Windows, Linux, macOS, conteneurs Docker, et plateformes cloud comme Azure et AWS. Cette compatibilité multiplateforme garantit que votre solution de visualiseur de PDF ASP.NET Core fonctionne de manière cohérente, quel que soit l'environnement de déploiement. La bibliothèque gère en interne les détails de rendu spécifiques à chaque plateforme, votre code fonctionne donc partout sans modification.

![Diagramme de prise en charge multiplateforme montrant la compatibilité .NET sur plusieurs versions, systèmes d'exploitation, plateformes cloud et environnements de développement. IronPDF offre une prise en charge multiplateforme complète, incluant la compatibilité avec .NET 9 à Framework 4.6.2+, fonctionne sous Windows, Linux et Mac, et s'intègre aux principaux fournisseurs de cloud et outils de développement.

Le traitement côté serveur garantit une génération PDF cohérente sur toutes les plateformes. Qu'il soit déployé sur des serveurs Windows ou des conteneurs Linux , le composant conserve la même qualité de rendu. La bibliothèque gère automatiquement les différences de chemin d'accès entre les systèmes d'exploitation, en traitant correctement les fichiers du dossier wwwroot ou d'autres emplacements. Pour les déploiements conteneurisés, consultez le guide de déploiement Docker . Le package inclut toutes les dépendances nécessaires pour chaque plateforme, ne nécessitant aucune configuration supplémentaire au-delà des exigences standard d'ASP.NET Core.

Pour les déploiements de conteneurs en production, considérez cet exemple de Dockerfile :

FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base
WORKDIR /app
EXPOSE 80

# Install IronPDF dependencies for Linux
RUN apt-get update && apt-get install -y \
    libgdiplus \
    libc6-dev \
    libx11-6 \
    && rm -rf /var/lib/apt/lists/*

FROM mcr.microsoft.com/dotnet/sdk:8.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"]

Démarrez dès aujourd'hui avec un essai gratuit et transformez les capacités de votre visionneuse de documents.

Quels sont les principaux avantages de l'utilisation d'IronPDF pour la visualisation de PDF avec ASP.NET Core ?

IronPDF transforme la gestion des fichiers PDF dans les applications ASP.NET Core en combinant la génération côté serveur et l'affichage natif du navigateur. En quelques lignes de code seulement, vous pouvez créer des PDF professionnels à partir de HTML, les afficher directement dans le texte, activer les téléchargements et les optimiser pour l'impression. Le moteur de rendu basé sur Chrome garantit une précision au pixel près sur toutes les plateformes, éliminant ainsi le besoin d'Adobe Acrobat Reader ou de visionneuses tierces.

Cette solution de visualisation PDF ASP.NET Core offre des fonctionnalités complètes, notamment le remplissage de formulaires , la sélection de texte , les signatures numériques et la possibilité de modifier les PDF . Ce composant prend également en charge la conversion de documents Word (fichiers DOCX) , de feuilles de calcul Excel et d'images en PDF . Que vous développiez une simple visionneuse de documents ou un système complexe de gestion de documents, IronPDF vous fournit les outils dont vous avez besoin.

L'intégration de l'assistant de balises de la bibliothèque et sa documentation exhaustive simplifient la mise en œuvre. Votre projet peut afficher directement les PDF tandis que le traitement en arrière-plan gère les tâches complexes de génération de PDF . Le comportement du visualiseur reste constant, qu'il soit chargé depuis le dossier wwwroot, généré dynamiquement ou récupéré à partir de sources externes. Avec un support de thème intégré et des paramètres de largeur personnalisables, vous pouvez parfaitement adapter le design de votre application. Pour les équipes DevOps , le package IronPDF Slim offre une taille de déploiement réduite, répondant aux contraintes de taille des conteneurs dans les environnements orchestrés.

Prêt à mettre en œuvre la visualisation de PDF dans votre application Web .NET Core ?

Pour une utilisation en production, les licences commencent à $799 et comprennent une assistance et des mises à jour complètes. Visitez la documentation pour des références API détaillées et des fonctionnalités avancées. Consultez nos exemples de code étendus pour mettre en œuvre rapidement la fonctionnalité de PDF dans vos projets ASP.NET Core.

![Page de licence IronPDF présentant quatre niveaux de licence perpétuelle (Lite, Plus, Professionnel et Illimité) avec les prix, les limites pour les développeurs et une option permettant de basculer entre les options IronPDF et Iron Suite. IronPDF propose différentes options de licence allant de 749 $ pour un développeur unique à 3 999 $ pour une utilisation illimitée, toutes les licences incluant un an de support et de mises à jour.

Questions Fréquemment Posées

Comment puis-je afficher des PDF dans une application ASP.NET Core ?

Vous pouvez afficher des PDF dans une application ASP.NET Core en utilisant IronPDF, qui fournit des fonctionnalités pour rendre des fichiers PDF directement au sein de votre application.

Quelles sont les étapes pour enregistrer un PDF dans ASP.NET Core en utilisant IronPDF ?

Pour enregistrer un PDF dans ASP.NET Core, vous pouvez utiliser les méthodes intégrées d'IronPDF pour convertir votre document en format PDF puis l'écrire sur un système de fichiers ou un flux.

Est-il possible d'imprimer des PDF dans des applications ASP.NET Core ?

Oui, IronPDF vous permet d'imprimer des PDF directement depuis votre application ASP.NET Core en utilisant ses fonctionnalités de rendu et d'impression.

Quels sont les avantages d'utiliser IronPDF dans ASP.NET Core ?

IronPDF offre une intégration fluide avec ASP.NET Core, permettant une manipulation PDF facile comme la visualisation, l'enregistrement et l'impression, avec un minimum de configuration.

IronPDF peut-il gérer de grands documents PDF dans ASP.NET Core ?

L'article 'Dotnet Core Generate PDF (Guide du Développeur)' fournit un guide pour générer des PDF avec .NET Core, en soulignant le besoin de créer des fichiers comme des factures et des rapports. L'accent est mis sur IronPDF, qui simplifie le processus avec son moteur de rendu Chrome, garantissant des PDF d'une précision parfaite. Ce guide est une ressource précieuse pour une génération efficace et de haute qualité dans les projets web.

IronPDF prend-il en charge les annotations PDF dans ASP.NET Core?

IronPDF prend en charge l'ajout et la lecture d'annotations et de commentaires dans les PDF, améliorant l'interactivité et l'utilisabilité des documents PDF dans votre application ASP.NET Core.

Comment intégrer IronPDF dans un projet ASP.NET Core existant ?

Vous pouvez intégrer IronPDF dans votre projet ASP.NET Core en installant le package NuGet IronPDF et en utilisant son API pour gérer les PDF.

Y a-t-il des exigences spécifiques pour utiliser IronPDF avec ASP.NET Core ?

IronPDF nécessite .NET Core ou .NET 5+ et prend en charge tous les systèmes d'exploitation majeurs, ce qui en fait un choix flexible pour les projets ASP.NET Core.

IronPDF peut-il convertir d'autres formats de fichiers en PDF dans ASP.NET Core ?

Oui, IronPDF peut convertir divers formats de fichiers tels que HTML, images et documents en PDF dans un environnement ASP.NET Core.

Quel type de support IronPDF offre-t-il pour les développeurs ASP.NET Core ?

IronPDF fournit une documentation complète, des exemples de code et un support réactif pour assister les développeurs ASP.NET Core dans l'implémentation des fonctionnalités PDF.

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