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

Comment créer une visionneuse de PDF dans une application Web ASP.NET avec IronPDF for .NET

Curtis Chau
Curtis Chau
Mis à jour:

IronPDF permet une visualisation transparente des PDF dans les applications ASP.NET Core en générant des PDF côté serveur qui s'affichent directement dans les visionneuses intégrées des navigateurs, sans nécessiter de plugins ni de dépendances externes : il suffit de configurer les en-têtes de réponse et de laisser le moteur de rendu d'IronPDF basé sur Chrome gérer la conversion HTML vers PDF .

Créer des applications web qui affichent des documents PDF est simple. Que vous présentiez des factures, des rapports ou des formulaires interactifs, les utilisateurs s'attendent à une expérience de visualisation de documents fluide et intégrée au navigateur ; inutile d'avoir recours à Adobe Acrobat Reader ou à des outils tiers supplémentaires.

IronPDF rend cela remarquablement simple. Cette bibliothèque .NET, régulièrement mise à jour, vous permet de créer, de générer et d'afficher des fichiers PDF au sein de votre projet ASP.NET Core en quelques lignes de code seulement. Voyons maintenant comment implémenter un contrôle de visionneuse PDF professionnel qui gère tout, de la simple conversion HTML aux vues Razor complexes.

Comment fonctionne l'affichage des PDF par navigateur ?

Bonne nouvelle : les navigateurs modernes intègrent déjà une visionneuse PDF. Lorsque votre serveur envoie un fichier PDF avec le type MIME correct ( application/pdf ), le navigateur l'affiche automatiquement directement dans la page. Cela signifie que vous n'avez besoin d'aucun plugin externe ni de bibliothèque JavaScript complexe côté client pour visualiser des documents PDF .

La clé réside dans la génération de documents PDF de haute qualité et la configuration correcte des en-têtes de réponse . IronPDF prend en charge les tâches les plus complexes côté serveur, en utilisant son moteur de rendu Chrome pour créer des pages PDF d' une précision pixel parfaite à partir de HTML, CSS et JavaScript . Le résultat ? Vos utilisateurs bénéficient d'une expérience de visualisation de documents native avec des fonctionnalités telles que la sélection de texte , la recherche, l'impression et le téléchargement, le tout sans aucune configuration d'interface utilisateur supplémentaire. Vous pouvez facilement intégrer et afficher le contenu.

Cette approche fonctionne parfaitement avec toutes les applications .NET , que vous développiez avec ASP.NET Core MVC , des vues Razor ou même des projets Web hérités. Pour les déploiements conteneurisés, IronPDF offre une excellente prise en charge de Docker avec des dépendances minimales, ce qui le rend idéal pour les architectures de microservices.

Comment installer et configurer le contrôle PDF Viewer?

Quelques étapes suffisent pour commencer à utiliser IronPDF dans Visual Studio. Ouvrez votre projet ASP.NET Core et installez le package NuGet :

Install-Package IronPdf

Pour les environnements conteneurisés, IronPDF fournit des images Docker officielles et prend en charge les conteneurs Linux et Windows . La bibliothèque gère automatiquement les dépendances Chrome et l'installation des polices, minimisant ainsi la complexité du déploiement.

Ensuite, ajoutez votre configuration de clé de licence dans Program.cs :

IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"
$vbLabelText   $csharpLabel

Pour les déploiements Azure , vous pouvez stocker la clé de licence dans Azure Key Vault ou dans des variables d'environnement. IronPDF prend également en charge AWS Lambda et d'autres plateformes cloud avec des paramètres de performance optimisés.

Voilà toute la configuration nécessaire pour qu'IronPDF s'intègre parfaitement à vos applications .NET . Consultez la documentation d'IronPDF pour connaître les options de configuration supplémentaires pour les scénarios avancés tels que le déploiement Azure ou les conteneurs Docker . Vous pouvez commencer par un essai gratuit pour découvrir toutes les fonctionnalités avant de vous engager.

Comment générer et afficher des documents PDF à partir de HTML ?

La méthode la plus simple pour créer une visionneuse PDF dans votre application web ASP.NET Core consiste à convertir directement les chaînes HTML . Voici un exemple complet de contrôleur avec un point de terminaison de vérification de l'état pour l'orchestration de conteneurs :

using IronPdf;
using Microsoft.AspNetCore.Mvc;

public class PdfController : Controller
{
    private readonly ChromePdfRenderer _renderer;

    public PdfController()
    {
        _renderer = new ChromePdfRenderer();
        // Configure for container environments
        _renderer.RenderingOptions.WaitFor.RenderDelay = 100; // ms
        _renderer.RenderingOptions.Timeout = 30000; // 30 seconds
    }

    public IActionResult DisplayFromHtml()
    {
        // Create PDF from HTML with CSS styling
        var html = @"
            <html>
            <head>
                <style>
                    body { font-family: Arial; padding: 20px; }
                    h1 { color: #2c3e50; }
                    .content { line-height: 1.6; }
                </style>
            </head>
            <body>
                <h1>Sample PDF Document</h1>
                <p class='content'>This PDF was generated using IronPDF in ASP.NET Core.</p>
            </body>
            </html>";
        var pdf = _renderer.RenderHtmlAsPdf(html);
        // Display PDF inline in browser
        Response.Headers.Add("Content-Disposition", "inline; filename=document.pdf");
        return File(pdf.BinaryData, "application/pdf");
    }

    // Health check endpoint for Kubernetes readiness probe
    [HttpGet("health")]
    public IActionResult Health()
    {
        try
        {
            var test = _renderer.RenderHtmlAsPdf("<p>Health check</p>");
            return Ok(new { status = "healthy", engine = "ready" });
        }
        catch
        {
            return StatusCode(503, new { status = "unhealthy" });
        }
    }
}
using IronPdf;
using Microsoft.AspNetCore.Mvc;

public class PdfController : Controller
{
    private readonly ChromePdfRenderer _renderer;

    public PdfController()
    {
        _renderer = new ChromePdfRenderer();
        // Configure for container environments
        _renderer.RenderingOptions.WaitFor.RenderDelay = 100; // ms
        _renderer.RenderingOptions.Timeout = 30000; // 30 seconds
    }

    public IActionResult DisplayFromHtml()
    {
        // Create PDF from HTML with CSS styling
        var html = @"
            <html>
            <head>
                <style>
                    body { font-family: Arial; padding: 20px; }
                    h1 { color: #2c3e50; }
                    .content { line-height: 1.6; }
                </style>
            </head>
            <body>
                <h1>Sample PDF Document</h1>
                <p class='content'>This PDF was generated using IronPDF in ASP.NET Core.</p>
            </body>
            </html>";
        var pdf = _renderer.RenderHtmlAsPdf(html);
        // Display PDF inline in browser
        Response.Headers.Add("Content-Disposition", "inline; filename=document.pdf");
        return File(pdf.BinaryData, "application/pdf");
    }

    // Health check endpoint for Kubernetes readiness probe
    [HttpGet("health")]
    public IActionResult Health()
    {
        try
        {
            var test = _renderer.RenderHtmlAsPdf("<p>Health check</p>");
            return Ok(new { status = "healthy", engine = "ready" });
        }
        catch
        {
            return StatusCode(503, new { status = "unhealthy" });
        }
    }
}
Imports IronPdf
Imports Microsoft.AspNetCore.Mvc

Public Class PdfController
    Inherits Controller

    Private ReadOnly _renderer As ChromePdfRenderer

    Public Sub New()
        _renderer = New ChromePdfRenderer()
        ' Configure for container environments
        _renderer.RenderingOptions.WaitFor.RenderDelay = 100 ' ms
        _renderer.RenderingOptions.Timeout = 30000 ' 30 seconds
    End Sub

    Public Function DisplayFromHtml() As IActionResult
        ' Create PDF from HTML with CSS styling
        Dim html As String = "
            <html>
            <head>
                <style>
                    body { font-family: Arial; padding: 20px; }
                    h1 { color: #2c3e50; }
                    .content { line-height: 1.6; }
                </style>
            </head>
            <body>
                <h1>Sample PDF Document</h1>
                <p class='content'>This PDF was generated using IronPDF in ASP.NET Core.</p>
            </body>
            </html>"
        Dim pdf = _renderer.RenderHtmlAsPdf(html)
        ' Display PDF inline in browser
        Response.Headers.Add("Content-Disposition", "inline; filename=document.pdf")
        Return File(pdf.BinaryData, "application/pdf")
    End Function

    ' Health check endpoint for Kubernetes readiness probe
    <HttpGet("health")>
    Public Function Health() As IActionResult
        Try
            Dim test = _renderer.RenderHtmlAsPdf("<p>Health check</p>")
            Return Ok(New With {Key .status = "healthy", Key .engine = "ready"})
        Catch
            Return StatusCode(503, New With {Key .status = "unhealthy"})
        End Try
    End Function
End Class
$vbLabelText   $csharpLabel

À quoi ressemble le PDF généré dans le navigateur ?

! Navigateur affichant un document PDF intitulé " Exemple de document PDF " et contenant le texte " Ce PDF a été généré à l'aide d'IronPDF dans ASP.NET Core ", consulté à l'adresse localhost:7254/Pdf/DisplayFromHtml

La classe ChromePdfRenderer utilise Chromium pour un rendu précis, garantissant ainsi que vos CSS , JavaScript et images s'affichent exactement comme prévu. Le fait de définir Content-Disposition sur inline indique au navigateur d'afficher le PDF plutôt que de le télécharger.

Cela crée une expérience de visualisation transparente permettant aux utilisateurs d'accéder au document directement dans votre interface web. Pour les documents à la mise en page complexe, vous pouvez spécifier les paramètres de rendu tels que la largeur et la hauteur dans le code HTML ou à l'aide RenderingOptions . Les options WaitFor garantissent un rendu correct dans les environnements conteneurisés où la latence du réseau peut affecter le chargement des ressources.

Pour plus d'options de conversion HTML, consultez le guide de conversion de chaînes HTML en PDF et les conseils d'optimisation des performances .

Comment rendre des fichiers PDF à partir d'URL et de Razor Views?

IronPDF peut également convertir des pages web dynamiques en documents PDF. C'est idéal pour générer des rapports ou archiver du contenu web dans des systèmes distribués :

public IActionResult RenderFromUrl(string url = "___PROTECTED_URL_92___")
{
    var renderer = new ChromePdfRenderer();
    // Configure for production environments
    renderer.RenderingOptions.EnableJavaScript = true;
    renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;
    renderer.RenderingOptions.WaitFor.NetworkIdle = 2000; // Wait for network idle
    renderer.RenderingOptions.PaperFit.UseChromeDefaultRendering = false; // Consistent across environments

    var pdf = renderer.RenderUrlAsPdf(url);
    Response.Headers.Add("Content-Disposition", "inline; filename=webpage.pdf");
    // Add caching headers for CDN distribution
    Response.Headers.Add("Cache-Control", "public, max-age=3600");
    return File(pdf.BinaryData, "application/pdf");
}
public IActionResult RenderFromUrl(string url = "___PROTECTED_URL_92___")
{
    var renderer = new ChromePdfRenderer();
    // Configure for production environments
    renderer.RenderingOptions.EnableJavaScript = true;
    renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;
    renderer.RenderingOptions.WaitFor.NetworkIdle = 2000; // Wait for network idle
    renderer.RenderingOptions.PaperFit.UseChromeDefaultRendering = false; // Consistent across environments

    var pdf = renderer.RenderUrlAsPdf(url);
    Response.Headers.Add("Content-Disposition", "inline; filename=webpage.pdf");
    // Add caching headers for CDN distribution
    Response.Headers.Add("Cache-Control", "public, max-age=3600");
    return File(pdf.BinaryData, "application/pdf");
}
Public Function RenderFromUrl(Optional url As String = "___PROTECTED_URL_92___") As IActionResult
    Dim renderer = New ChromePdfRenderer()
    ' Configure for production environments
    renderer.RenderingOptions.EnableJavaScript = True
    renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print
    renderer.RenderingOptions.WaitFor.NetworkIdle = 2000 ' Wait for network idle
    renderer.RenderingOptions.PaperFit.UseChromeDefaultRendering = False ' Consistent across environments

    Dim pdf = renderer.RenderUrlAsPdf(url)
    Response.Headers.Add("Content-Disposition", "inline; filename=webpage.pdf")
    ' Add caching headers for CDN distribution
    Response.Headers.Add("Cache-Control", "public, max-age=3600")
    Return File(pdf.BinaryData, "application/pdf")
End Function
$vbLabelText   $csharpLabel

Comment s'affiche le rendu PDF basé sur une URL ?

Capture d'écran d'une visionneuse PDF affichant la page d'accueil de Wikipédia rendue dans une application web ASP.NET utilisant IronPDF, montrant le contenu principal de la page et les éléments de navigation avec l'intégralité du style CSS préservé.

Pour convertir des vues Razor en PDF , vous aurez besoin d'une méthode auxiliaire pour générer d'abord la vue au format HTML. Cette approche vous permet de réutiliser vos modèles existants pour l'affichage web et la génération de PDF , ce qui est essentiel pour garantir la cohérence entre les microservices.

public async Task<IActionResult> ViewToPdf()
{
    var invoiceModel = new InvoiceModel
    {
        InvoiceNumber = 1001,
        InvoiceDate = DateTime.Now,
        CustomerName = "Acme Corp.",
        Items = new List<ItemModel>
        {
            new ItemModel { Description = "Product A", Quantity = 2, UnitPrice = 50.00m },
            new ItemModel { Description = "Service B", Quantity = 1, UnitPrice = 150.00m }
        }
    };
    invoiceModel.TotalAmount = invoiceModel.Items.Sum(i => i.LineTotal);
    // NOTE: RenderViewToStringAsync uses the Request services and ActionContext
    var htmlContent = await RenderViewToStringAsync("Invoice", invoiceModel);

    var renderer = new IronPdf.ChromePdfRenderer();
    // Optimize for memory-constrained containers
    renderer.RenderingOptions.UseMarginsOnHeaderAndFooter = UseMargins.All;
    renderer.RenderingOptions.MarginTop = renderer.RenderingOptions.MarginBottom = 40;

    var pdf = renderer.RenderHtmlAsPdf(htmlContent, baseUrl: HttpContext.Request.Scheme + "://" + HttpContext.Request.Host);

    // Add monitoring metrics
    _logger.LogInformation($"PDF generated: Size={pdf.BinaryData.Length} bytes, Pages={pdf.PageCount}");

    return File(pdf.BinaryData, "application/pdf");
}
private async Task<string> RenderViewToStringAsync(string viewName, object model)
{
    // Use the current HttpContext's service provider (guaranteed available during a request)
    var actionContext = new ActionContext(HttpContext, RouteData, ControllerContext.ActionDescriptor);
    var viewEngine = HttpContext.RequestServices.GetRequiredService<IRazorViewEngine>();
    var tempDataFactory = HttpContext.RequestServices.GetRequiredService<ITempDataDictionaryFactory>();
    var tempData = tempDataFactory.GetTempData(HttpContext);
    ViewData.Model = model;
    var viewResult = viewEngine.FindView(actionContext, viewName, isMainPage: false);
    if (!viewResult.Success)
    {
        // Helpful error for debugging
        var searchedLocations = string.Join(Environment.NewLine, viewResult.SearchedLocations ?? Array.Empty<string>());
        throw new InvalidOperationException($"Couldn't find view '{viewName}'. Searched locations:{Environment.NewLine}{searchedLocations}");
    }
    await using var writer = new StringWriter();
    var viewContext = new ViewContext(
        actionContext,
        viewResult.View,
        ViewData,
        tempData,
        writer,
        new HtmlHelperOptions()
    );
    await viewResult.View.RenderAsync(viewContext);
    return writer.ToString();
}
public async Task<IActionResult> ViewToPdf()
{
    var invoiceModel = new InvoiceModel
    {
        InvoiceNumber = 1001,
        InvoiceDate = DateTime.Now,
        CustomerName = "Acme Corp.",
        Items = new List<ItemModel>
        {
            new ItemModel { Description = "Product A", Quantity = 2, UnitPrice = 50.00m },
            new ItemModel { Description = "Service B", Quantity = 1, UnitPrice = 150.00m }
        }
    };
    invoiceModel.TotalAmount = invoiceModel.Items.Sum(i => i.LineTotal);
    // NOTE: RenderViewToStringAsync uses the Request services and ActionContext
    var htmlContent = await RenderViewToStringAsync("Invoice", invoiceModel);

    var renderer = new IronPdf.ChromePdfRenderer();
    // Optimize for memory-constrained containers
    renderer.RenderingOptions.UseMarginsOnHeaderAndFooter = UseMargins.All;
    renderer.RenderingOptions.MarginTop = renderer.RenderingOptions.MarginBottom = 40;

    var pdf = renderer.RenderHtmlAsPdf(htmlContent, baseUrl: HttpContext.Request.Scheme + "://" + HttpContext.Request.Host);

    // Add monitoring metrics
    _logger.LogInformation($"PDF generated: Size={pdf.BinaryData.Length} bytes, Pages={pdf.PageCount}");

    return File(pdf.BinaryData, "application/pdf");
}
private async Task<string> RenderViewToStringAsync(string viewName, object model)
{
    // Use the current HttpContext's service provider (guaranteed available during a request)
    var actionContext = new ActionContext(HttpContext, RouteData, ControllerContext.ActionDescriptor);
    var viewEngine = HttpContext.RequestServices.GetRequiredService<IRazorViewEngine>();
    var tempDataFactory = HttpContext.RequestServices.GetRequiredService<ITempDataDictionaryFactory>();
    var tempData = tempDataFactory.GetTempData(HttpContext);
    ViewData.Model = model;
    var viewResult = viewEngine.FindView(actionContext, viewName, isMainPage: false);
    if (!viewResult.Success)
    {
        // Helpful error for debugging
        var searchedLocations = string.Join(Environment.NewLine, viewResult.SearchedLocations ?? Array.Empty<string>());
        throw new InvalidOperationException($"Couldn't find view '{viewName}'. Searched locations:{Environment.NewLine}{searchedLocations}");
    }
    await using var writer = new StringWriter();
    var viewContext = new ViewContext(
        actionContext,
        viewResult.View,
        ViewData,
        tempData,
        writer,
        new HtmlHelperOptions()
    );
    await viewResult.View.RenderAsync(viewContext);
    return writer.ToString();
}
Imports System
Imports System.Collections.Generic
Imports System.Linq
Imports System.Threading.Tasks
Imports Microsoft.AspNetCore.Mvc
Imports Microsoft.Extensions.DependencyInjection
Imports Microsoft.Extensions.Logging
Imports IronPdf

Public Class YourController
    Inherits Controller

    Private ReadOnly _logger As ILogger(Of YourController)

    Public Sub New(logger As ILogger(Of YourController))
        _logger = logger
    End Sub

    Public Async Function ViewToPdf() As Task(Of IActionResult)
        Dim invoiceModel As New InvoiceModel With {
            .InvoiceNumber = 1001,
            .InvoiceDate = DateTime.Now,
            .CustomerName = "Acme Corp.",
            .Items = New List(Of ItemModel) From {
                New ItemModel With {.Description = "Product A", .Quantity = 2, .UnitPrice = 50.0D},
                New ItemModel With {.Description = "Service B", .Quantity = 1, .UnitPrice = 150.0D}
            }
        }
        invoiceModel.TotalAmount = invoiceModel.Items.Sum(Function(i) i.LineTotal)
        ' NOTE: RenderViewToStringAsync uses the Request services and ActionContext
        Dim htmlContent As String = Await RenderViewToStringAsync("Invoice", invoiceModel)

        Dim renderer As New ChromePdfRenderer()
        ' Optimize for memory-constrained containers
        renderer.RenderingOptions.UseMarginsOnHeaderAndFooter = UseMargins.All
        renderer.RenderingOptions.MarginTop = 40
        renderer.RenderingOptions.MarginBottom = 40

        Dim pdf = renderer.RenderHtmlAsPdf(htmlContent, baseUrl:=HttpContext.Request.Scheme & "://" & HttpContext.Request.Host)

        ' Add monitoring metrics
        _logger.LogInformation($"PDF generated: Size={pdf.BinaryData.Length} bytes, Pages={pdf.PageCount}")

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

    Private Async Function RenderViewToStringAsync(viewName As String, model As Object) As Task(Of String)
        ' Use the current HttpContext's service provider (guaranteed available during a request)
        Dim actionContext As New ActionContext(HttpContext, RouteData, ControllerContext.ActionDescriptor)
        Dim viewEngine = HttpContext.RequestServices.GetRequiredService(Of IRazorViewEngine)()
        Dim tempDataFactory = HttpContext.RequestServices.GetRequiredService(Of ITempDataDictionaryFactory)()
        Dim tempData = tempDataFactory.GetTempData(HttpContext)
        ViewData.Model = model
        Dim viewResult = viewEngine.FindView(actionContext, viewName, isMainPage:=False)
        If Not viewResult.Success Then
            ' Helpful error for debugging
            Dim searchedLocations = String.Join(Environment.NewLine, viewResult.SearchedLocations ?? Array.Empty(Of String)())
            Throw New InvalidOperationException($"Couldn't find view '{viewName}'. Searched locations:{Environment.NewLine}{searchedLocations}")
        End If
        Await Using writer As New StringWriter()
            Dim viewContext As New ViewContext(
                actionContext,
                viewResult.View,
                ViewData,
                tempData,
                writer,
                New HtmlHelperOptions()
            )
            Await viewResult.View.RenderAsync(viewContext)
            Return writer.ToString()
        End Using
    End Function
End Class

Public Class InvoiceModel
    Public Property InvoiceNumber As Integer
    Public Property InvoiceDate As DateTime
    Public Property CustomerName As String
    Public Property Items As List(Of ItemModel)
    Public Property TotalAmount As Decimal
End Class

Public Class ItemModel
    Public Property Description As String
    Public Property Quantity As Integer
    Public Property UnitPrice As Decimal
    Public ReadOnly Property LineTotal As Decimal
        Get
            Return Quantity * UnitPrice
        End Get
    End Property
End Class
$vbLabelText   $csharpLabel

Quels sont les résultats de la génération de PDF avec Razor View ?

! La facture PDF affichée dans un navigateur Web montre la facture n° 1001 pour Acme Corp avec deux lignes pour un total de 250,00 $, démontrant la réussite de la conversion de l'affichage Razor en PDF.

Cette méthode d'assistance vous assure un chemin propre pour le rendu du contenu de votre vue Razor en une chaîne HTML, qu'IronPDF peut ensuite convertir. Le tutoriel Razor to PDF décrit ce flux de travail en détail. Pour les applications Blazor , des approches similaires fonctionnent avec le rendu des composants.

Comment traiter des fichiers PDF volumineux avec le streaming?

Lors du traitement de documents PDF volumineux dans des environnements conteneurisés, le streaming améliore les performances et réduit l'utilisation de la mémoire. L'utilisation d'un MemoryStream vous permet de servir des fichiers efficacement tout en maintenant une faible empreinte mémoire :

public IActionResult StreamLargePdf()
{
    var renderer = new ChromePdfRenderer();
    // Configure for memory efficiency
    renderer.RenderingOptions.CreatePdfFormsFromHtml = false; // Reduce memory if forms not needed

    var pdf = renderer.RenderHtmlAsPdf("<h1>Large Document</h1><p>Content here...</p>");

    // Optional: Compress for reduced bandwidth
    pdf.CompressImages(80); // 80% quality

    var stream = new MemoryStream(pdf.BinaryData);

    // Set response headers for optimal streaming
    Response.Headers.Add("Content-Length", pdf.BinaryData.Length.ToString());
    Response.Headers.Add("Accept-Ranges", "bytes");

    return new FileStreamResult(stream, "application/pdf");
}

// Async version for better container performance
public async Task<IActionResult> StreamLargePdfAsync()
{
    var renderer = new ChromePdfRenderer();
    var pdf = await renderer.RenderHtmlAsPdfAsync("<h1>Large Document</h1><p>Content here...</p>");

    var stream = new MemoryStream(pdf.BinaryData);
    return new FileStreamResult(stream, "application/pdf");
}
public IActionResult StreamLargePdf()
{
    var renderer = new ChromePdfRenderer();
    // Configure for memory efficiency
    renderer.RenderingOptions.CreatePdfFormsFromHtml = false; // Reduce memory if forms not needed

    var pdf = renderer.RenderHtmlAsPdf("<h1>Large Document</h1><p>Content here...</p>");

    // Optional: Compress for reduced bandwidth
    pdf.CompressImages(80); // 80% quality

    var stream = new MemoryStream(pdf.BinaryData);

    // Set response headers for optimal streaming
    Response.Headers.Add("Content-Length", pdf.BinaryData.Length.ToString());
    Response.Headers.Add("Accept-Ranges", "bytes");

    return new FileStreamResult(stream, "application/pdf");
}

// Async version for better container performance
public async Task<IActionResult> StreamLargePdfAsync()
{
    var renderer = new ChromePdfRenderer();
    var pdf = await renderer.RenderHtmlAsPdfAsync("<h1>Large Document</h1><p>Content here...</p>");

    var stream = new MemoryStream(pdf.BinaryData);
    return new FileStreamResult(stream, "application/pdf");
}
Imports System.IO
Imports System.Threading.Tasks
Imports Microsoft.AspNetCore.Mvc

Public Class PdfController
    Inherits Controller

    Public Function StreamLargePdf() As IActionResult
        Dim renderer As New ChromePdfRenderer()
        ' Configure for memory efficiency
        renderer.RenderingOptions.CreatePdfFormsFromHtml = False ' Reduce memory if forms not needed

        Dim pdf = renderer.RenderHtmlAsPdf("<h1>Large Document</h1><p>Content here...</p>")

        ' Optional: Compress for reduced bandwidth
        pdf.CompressImages(80) ' 80% quality

        Dim stream As New MemoryStream(pdf.BinaryData)

        ' Set response headers for optimal streaming
        Response.Headers.Add("Content-Length", pdf.BinaryData.Length.ToString())
        Response.Headers.Add("Accept-Ranges", "bytes")

        Return New FileStreamResult(stream, "application/pdf")
    End Function

    ' Async version for better container performance
    Public Async Function StreamLargePdfAsync() As Task(Of IActionResult)
        Dim renderer As New ChromePdfRenderer()
        Dim pdf = Await renderer.RenderHtmlAsPdfAsync("<h1>Large Document</h1><p>Content here...</p>")

        Dim stream As New MemoryStream(pdf.BinaryData)
        Return New FileStreamResult(stream, "application/pdf")
    End Function

End Class
$vbLabelText   $csharpLabel

Pour les projets ASP.NET Web Forms existants, vous pouvez implémenter des fonctionnalités similaires à l'aide de gestionnaires d'événements avec un nettoyage approprié des ressources :

protected void btnGeneratePdf_Click(object sender, EventArgs e)
{
    using (var renderer = new ChromePdfRenderer())
    {
        var pdf = renderer.RenderHtmlAsPdf("<h1>Web Form PDF</h1>");
        Response.ContentType = "application/pdf";
        Response.BinaryWrite(pdf.BinaryData);
        Response.End();
    }
}
protected void btnGeneratePdf_Click(object sender, EventArgs e)
{
    using (var renderer = new ChromePdfRenderer())
    {
        var pdf = renderer.RenderHtmlAsPdf("<h1>Web Form PDF</h1>");
        Response.ContentType = "application/pdf";
        Response.BinaryWrite(pdf.BinaryData);
        Response.End();
    }
}
Protected Sub btnGeneratePdf_Click(sender As Object, e As EventArgs)
    Using renderer = New ChromePdfRenderer()
        Dim pdf = renderer.RenderHtmlAsPdf("<h1>Web Form PDF</h1>")
        Response.ContentType = "application/pdf"
        Response.BinaryWrite(pdf.BinaryData)
        Response.End()
    End Using
End Sub
$vbLabelText   $csharpLabel

Pour les scénarios exigeant de hautes performances , envisagez d'utiliser des méthodes asynchrones et le traitement parallèle lors de la génération de plusieurs fichiers PDF. Le guide de performance d'IronPDF fournit des stratégies d'optimisation détaillées.

Quelles sont les fonctionnalités prises en charge par ce contrôle de visualisation PDF ?

En tirant parti du visualiseur PDF natif du navigateur, vos utilisateurs bénéficient automatiquement d'un ensemble complet de fonctionnalités : sélection de texte pour copier du contenu, fonction de recherche pour trouver des données spécifiques, options d'impression pour les copies physiques et possibilités de téléchargement pour un accès hors ligne.

Cette approche permet également de gérer les scénarios où les utilisateurs doivent télécharger un document existant pour le consulter, le modifier ou le fusionner . Le traitement côté serveur d'IronPDF gère l'exécution JavaScript , le rendu CSS et les formulaires , y compris les éléments interactifs que les utilisateurs peuvent remplir.

Le framework prend en charge l'intégration d'assistants de balises, les tailles de page personnalisées , les en-têtes et pieds de page , les filigranes et même les fonctionnalités d'édition . Pour les fonctionnalités de sécurité , IronPDF propose le chiffrement , les signatures numériques et la conformité PDF/A pour l'archivage à long terme.

Pour les déploiements conteneurisés, IronPDF fournit :

Pour un aperçu complet des fonctionnalités, consultez la page des fonctionnalités d'IronPDF .

Quelles sont les prochaines étapes de la mise en œuvre ?

La création d'une visionneuse PDF dans une application web ASP.NET est remarquablement simple avec IronPDF. En combinant son puissant moteur de rendu avec la visionneuse PDF intégrée au navigateur, vous obtenez une solution professionnelle pour l'affichage, le traitement et la gestion des fichiers PDF dans vos applications web. Que vous convertissiez du HTML , des URL ou des vues Razor , la mise en œuvre nécessite un minimum de code tout en offrant une fonctionnalité maximale.

Pour les déploiements en production, tenez compte des points suivants :

Vous êtes prêt à intégrer l'affichage des PDF dans votre projet ? Démarrez avec un essai gratuit d'IronPDF et transformez la façon dont votre application web .NET Core gère les documents. Pour les déploiements en production, consultez les options de licence adaptées aux besoins de votre équipe. Vous souhaitez voir d'autres exemples de conversion ? Découvrez comment IronPDF gère la conversion de DOCX en PDF , d'images en PDF et bien plus encore dans les guides pratiques.

Commencez avec IronPDF maintenant.
green arrow pointer

Questions Fréquemment Posées

Comment puis-je créer une visionneuse PDF dans une application web ASP.NET ?

Vous pouvez créer une visionneuse PDF dans une application web ASP.NET à l'aide d'IronPDF for .NET. Il vous permet d'afficher des documents PDF directement dans votre application, offrant une expérience de visualisation transparente sans nécessiter d'outils externes tels qu'Adobe Acrobat Reader.

Quels sont les avantages de l'utilisation d'IronPDF pour l'affichage de PDF en ASP.NET ?

IronPDF offre une expérience d'affichage de PDF fluide et intégrée dans les applications ASP.NET. Il vous permet d'afficher des documents en ligne, prend en charge différents types de fichiers et élimine la nécessité d'utiliser des visionneuses PDF tierces, ce qui améliore l'expérience de l'utilisateur.

Puis-je afficher des formulaires PDF interactifs dans mon application web ASP.NET ?

Oui, avec IronPDF, vous pouvez afficher des formulaires PDF interactifs dans votre application web ASP.NET. Il prend en charge le rendu des champs de formulaire et des éléments interactifs, ce qui permet aux utilisateurs d'interagir avec les documents directement dans le navigateur.

Est-il possible de présenter des factures et des rapports à l'aide d'IronPDF for .NET en ASP.NET ?

Dans l'absolu, IronPDF est bien adapté à l'affichage de factures, de rapports et d'autres types de documents dans les applications ASP.NET. Il garantit un rendu précis et efficace de vos documents au sein de l'application web.

Ai-je besoin d'Adobe Acrobat Reader pour visualiser les PDF dans les applications ASP.NET utilisant IronPDF ?

Non, vous n'avez pas besoin d'Adobe Acrobat Reader pour visualiser les PDF dans les applications ASP.NET lorsque vous utilisez IronPDF. Il vous permet de rendre et d'afficher les PDF directement dans le navigateur, sans dépendances tierces.

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