Intégrer une visionneuse PDF dans une application ASP.NET Core est plus simple que la plupart des développeurs ne le pensent. En générant les PDF côté serveur et en les renvoyant avec le type MIME correct, vous pouvez afficher les documents directement dans n'importe quel navigateur moderne – sans plugins ni Adobe Acrobat Reader. IronPDF gère le rendu via son moteur basé sur Chrome , transformant HTML, CSS et JavaScript en PDF haute fidélité qui apparaissent directement dans la visionneuse intégrée du navigateur.
Ce tutoriel vous guide à travers tous les principaux scénarios : affichage de PDF générés à partir de chaînes HTML, rendu d'URL en direct, conversion de vues Razor , diffusion de fichiers volumineux et intégration de l'ensemble dans un contrôleur ASP.NET Core MVC. Les exemples de code ciblent .NET 10 avec des instructions de niveau supérieur lorsque cela est applicable.
Les navigateurs modernes sont livrés avec une visionneuse PDF intégrée. Lorsque qu'un serveur répond avec l'en-tête Content-Type: application/pdf, le navigateur rend le document en ligne au lieu de déclencher un téléchargement de fichier. La clé est d'associer cet en-tête avec Content-Disposition: inline.
Du côté serveur, votre tâche est de produire un binaire PDF valide et de le renvoyer via FileResult. Le navigateur gère la pagination, le Zoom, la sélection de texte, la recherche, l'impression et le téléchargement sans aucun code d'interface utilisateur supplémentaire de votre part.
IronPDF s'intègre naturellement à ce modèle. Sa classe ChromePdfRenderer convertit le HTML (ou une URL active) en un binaire PDF, et vous passez ce binaire directement à l'assistant File() d'ASP.NET. Le résultat est une visionneuse de documents complète qui fonctionne sur Chrome, Firefox, Edge et Safari.
Les navigateurs modernes implémentent la spécification de rendu PDF du W3C via leurs moteurs de visualisation natifs, ce qui signifie que tout PDF conforme renvoyé par votre serveur s'affichera correctement sans configuration supplémentaire. Le rendu d'IronPDF est entièrement conforme aux normes, vous pouvez donc compter sur un affichage cohérent sur toutes les versions de navigateurs.
Pour les déploiements conteneurisés, IronPDF fournit des images Docker officielles qui préconfigurent les dépendances Chromium afin que vous n'ayez pas besoin d'installer Chrome manuellement sur chaque nœud. Les conteneurs Linux et Windows sont tous deux pris en charge. Si vous avez besoin de faire évoluer la génération de PDF indépendamment, l' image Docker IronPDF Engine vous permet d'exécuter le processus de rendu en tant que microservice distinct.
Ouvrez votre projet ASP.NET Core dans Visual Studio, puis installez IronPDF via la console du gestionnaire de packages NuGet :
Ou utilisez le .NET CLI :
Après l'installation, ajoutez votre clé de licence à Program.cs avant d'appeler n'importe quelle API d'IronPDF :
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY";IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY"Si vous déployez votre application sur Azure , stockez la clé de licence dans Azure Key Vault ou dans la configuration de l'application plutôt que de l'intégrer directement dans le code. Pour les déploiements AWS Lambda, utilisez les variables d'environnement configurées dans les paramètres de votre fonction Lambda.
Voilà toute la configuration. IronPDF détecte et configure automatiquement Chromium lors de son exécution sous Windows. Sous Linux, consultez le guide d'installation pour connaître la poignée de paquets système requis.
Vous pouvez commencer par un essai gratuit pour évaluer l'ensemble des fonctionnalités avant de choisir un niveau de licence pour la production.
Le moyen le plus rapide de mettre un PDF devant un utilisateur est de rendre une chaîne HTML et de la renvoyer en ligne. Créez un contrôleur appelé PdfController et ajoutez une action comme ceci :
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();
public class PdfController : Controller
{
private readonly ChromePdfRenderer _renderer;
public PdfController()
{
_renderer = new ChromePdfRenderer();
_renderer.RenderingOptions.WaitFor.RenderDelay(100);
_renderer.RenderingOptions.Timeout = 30;
}
public IActionResult DisplayFromHtml()
{
string html = @"
<html>
<head>
<style>
body { font-family: Arial, sans-serif; padding: 40px; }
h1 { color: #2c3e50; }
p { line-height: 1.7; color: #444; }
</style>
</head>
<body>
<h1>Sample PDF Document</h1>
<p>This PDF was generated using IronPDF in an ASP.NET Core application.</p>
</body>
</html>";
PdfDocument pdf = _renderer.RenderHtmlAsPdf(html);
Response.Headers.Append("Content-Disposition", "inline; filename=document.pdf");
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()
Public Class PdfController
Inherits Controller
Private ReadOnly _renderer As ChromePdfRenderer
Public Sub New()
_renderer = New ChromePdfRenderer()
_renderer.RenderingOptions.WaitFor.RenderDelay(100)
_renderer.RenderingOptions.Timeout = 30
End Sub
Public Function DisplayFromHtml() As IActionResult
Dim html As String = "
<html>
<head>
<style>
body { font-family: Arial, sans-serif; padding: 40px; }
h1 { color: #2c3e50; }
p { line-height: 1.7; color: #444; }
</style>
</head>
<body>
<h1>Sample PDF Document</h1>
<p>This PDF was generated using IronPDF in an ASP.NET Core application.</p>
</body>
</html>"
Dim pdf As PdfDocument = _renderer.RenderHtmlAsPdf(html)
Response.Headers.Append("Content-Disposition", "inline; filename=document.pdf")
Return File(pdf.BinaryData, "application/pdf")
End Function
End Class
ChromePdfRenderer utilise Chromium en interne, donc la grille CSS, flexbox, les polices web et les fonctionnalités modernes de CSS se rendent avec précision. Définir Content-Disposition sur inline est ce qui indique au navigateur d'afficher le fichier plutôt que de le sauvegarder. Si vous changez cette valeur pour attachment, le navigateur demande à l'utilisateur de télécharger à la place.
Pour les documents à la mise en page complexe, vous pouvez affiner le rendu grâce à des options telles que les formats de papier personnalisés, les marges et le type de média CSS d'impression. L' API WaitFor est particulièrement utile dans les environnements conteneurisés où la latence du réseau peut retarder le chargement des ressources externes.
Pour un aperçu plus détaillé des options de conversion HTML, consultez le guide de conversion de chaîne HTML en PDF .
IronPDF peut capturer n'importe quelle page web en direct au format PDF – idéal pour archiver du contenu web ou générer des rapports à partir de pages existantes. La documentation ASP.NET Core explique comment les actions du contrôleur renvoient des résultats, ce qui correspond au modèle utilisé ici.
public IActionResult RenderFromUrl(string url = "https://en.wikipedia.org/wiki/Main_Page")
{
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.EnableJavaScript = true;
renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print;
renderer.RenderingOptions.WaitFor.NetworkIdle();
PdfDocument pdf = renderer.RenderUrlAsPdf(url);
Response.Headers.Append("Content-Disposition", "inline; filename=webpage.pdf");
Response.Headers.Append("Cache-Control", "public, max-age=3600");
return File(pdf.BinaryData, "application/pdf");
}Public Function RenderFromUrl(Optional url As String = "https://en.wikipedia.org/wiki/Main_Page") As IActionResult
Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.EnableJavaScript = True
renderer.RenderingOptions.CssMediaType = IronPdf.Rendering.PdfCssMediaType.Print
renderer.RenderingOptions.WaitFor.NetworkIdle()
Dim pdf As PdfDocument = renderer.RenderUrlAsPdf(url)
Response.Headers.Append("Content-Disposition", "inline; filename=webpage.pdf")
Response.Headers.Append("Cache-Control", "public, max-age=3600")
Return File(pdf.BinaryData, "application/pdf")
End Function
Lorsque vous devez convertir une vue Razor (comme un modèle de facture ou de relevé), vous commencez par convertir la vue en une chaîne HTML, puis vous transmettez cette chaîne à IronPDF. Cela permet de réutiliser vos modèles pour les sorties web et PDF :
public async Task<IActionResult> ViewToPdf()
{
var model = 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 }
}
};
model.TotalAmount = model.Items.Sum(i => i.LineTotal);
string htmlContent = await RenderViewToStringAsync("Invoice", model);
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.MarginTop = 40;
renderer.RenderingOptions.MarginBottom = 40;
string baseUrl = $"{HttpContext.Request.Scheme}://{HttpContext.Request.Host}";
PdfDocument pdf = renderer.RenderHtmlAsPdf(htmlContent, baseUrl);
return File(pdf.BinaryData, "application/pdf");
}
private async Task<string> RenderViewToStringAsync(string viewName, object model)
{
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)
{
string searched = string.Join(
Environment.NewLine,
viewResult.SearchedLocations ?? Array.Empty<string>());
throw new InvalidOperationException(
$"Could not find view '{viewName}'. Searched:{Environment.NewLine}{searched}");
}
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.AspNetCore.Mvc.ViewEngines
Imports Microsoft.AspNetCore.Mvc.Rendering
Imports Microsoft.AspNetCore.Mvc.ViewFeatures
Imports Microsoft.Extensions.DependencyInjection
Imports IronPdf
Public Class YourController
Inherits Controller
Public Async Function ViewToPdf() As Task(Of IActionResult)
Dim model 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}
}
}
model.TotalAmount = model.Items.Sum(Function(i) i.LineTotal)
Dim htmlContent As String = Await RenderViewToStringAsync("Invoice", model)
Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.MarginTop = 40
renderer.RenderingOptions.MarginBottom = 40
Dim baseUrl As String = $"{HttpContext.Request.Scheme}://{HttpContext.Request.Host}"
Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf(htmlContent, baseUrl)
Return File(pdf.BinaryData, "application/pdf")
End Function
Private Async Function RenderViewToStringAsync(viewName As String, model As Object) As Task(Of String)
Dim actionContext As New ActionContext(HttpContext, RouteData, ControllerContext.ActionDescriptor)
Dim viewEngine As IRazorViewEngine = HttpContext.RequestServices.GetRequiredService(Of IRazorViewEngine)()
Dim tempDataFactory As ITempDataDictionaryFactory = HttpContext.RequestServices.GetRequiredService(Of ITempDataDictionaryFactory)()
Dim tempData As ITempDataDictionary = tempDataFactory.GetTempData(HttpContext)
ViewData.Model = model
Dim viewResult As ViewEngineResult = viewEngine.FindView(actionContext, viewName, isMainPage:=False)
If Not viewResult.Success Then
Dim searched As String = String.Join(Environment.NewLine, viewResult.SearchedLocations ?? Array.Empty(Of String)())
Throw New InvalidOperationException($"Could not find view '{viewName}'. Searched:{Environment.NewLine}{searched}")
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
Le paramètre baseUrl est important lorsque votre vue Razor fait référence à des chemins CSS ou d'images relatifs. Le fait de transmettre l'URL de l'hôte actuel permet à IronPDF de résoudre correctement ces chemins. Consultez le tutoriel Razor vers PDF pour obtenir la présentation complète, y compris les modèles d'application Blazor .
Pour les documents pouvant atteindre plusieurs mégaoctets, le streaming réduit la consommation de mémoire maximale et commence à livrer les octets au client plus tôt. Utilisez FileStreamResult au lieu de File() avec un tableau d'octets brut :
public async Task<IActionResult> StreamLargePdf()
{
var renderer = new ChromePdfRenderer();
renderer.RenderingOptions.CreatePdfFormsFromHtml = false;
PdfDocument pdf = await renderer.RenderHtmlAsPdfAsync(
"<h1>Large Document</h1><p>Full content here...</p>");
pdf.CompressImages(80);
var stream = new MemoryStream(pdf.BinaryData);
Response.Headers.Append("Content-Length", pdf.BinaryData.Length.ToString());
Response.Headers.Append("Accept-Ranges", "bytes");
return new FileStreamResult(stream, "application/pdf");
}Imports System.IO
Imports System.Threading.Tasks
Imports Microsoft.AspNetCore.Mvc
Public Class YourController
Inherits Controller
Public Async Function StreamLargePdf() As Task(Of IActionResult)
Dim renderer As New ChromePdfRenderer()
renderer.RenderingOptions.CreatePdfFormsFromHtml = False
Dim pdf As PdfDocument = Await renderer.RenderHtmlAsPdfAsync("<h1>Large Document</h1><p>Full content here...</p>")
pdf.CompressImages(80)
Dim stream As New MemoryStream(pdf.BinaryData)
Response.Headers.Append("Content-Length", pdf.BinaryData.Length.ToString())
Response.Headers.Append("Accept-Ranges", "bytes")
Return New FileStreamResult(stream, "application/pdf")
End Function
End ClassCompressImages(80) réduit la qualité JPEG à 80%, ce qui réduit significativement la taille du fichier pour les documents riches en images avec une perte de qualité visible minimale. Définir Accept-Ranges: bytes signale au navigateur qu'il peut demander des fragments de plage d'octets, permettant une recherche plus rapide dans de grands PDFs sans télécharger le fichier entier d'abord.
La spécification PDF/A de l'ISO définit les exigences relatives aux fichiers PDF de qualité archivistique. Si votre application doit produire des documents d'archivage à long terme, le mode de conformité PDF/A d'IronPDF garantit que la sortie répond à ces normes, ce qui est particulièrement pertinent pour les flux de travail réglementaires ou juridiques.
Pour les projets ASP.NET Web Forms hérités, le modèle est légèrement différent car vous écrivez directement dans la réponse HTTP :
protected void btnGeneratePdf_Click(object sender, EventArgs e)
{
using var renderer = new ChromePdfRenderer();
PdfDocument 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 As New ChromePdfRenderer()
Dim pdf As PdfDocument = renderer.RenderHtmlAsPdf("<h1>Web Form PDF</h1>")
Response.ContentType = "application/pdf"
Response.BinaryWrite(pdf.BinaryData)
Response.End()
End Using
End SubPour les charges de travail qui génèrent simultanément de nombreux fichiers PDF, consultez le guide de l'API asynchrone IronPDF et la référence d'optimisation des performances pour connaître les paramètres permettant de réduire la surcharge mémoire dans les scénarios à haut débit.
Lorsqu'un navigateur affiche un PDF directement dans la page, il ouvre automatiquement une visionneuse complète. Vos utilisateurs bénéficient de la sélection de texte pour copier du contenu, d'une barre de recherche intégrée pour localiser des mots ou des chiffres spécifiques, de commandes d'impression et d'un téléchargement en un clic, le tout sans aucun code front-end de votre part.
Au-delà de la simple visualisation, IronPDF prend en charge un large éventail de fonctionnalités de document qui influent sur ce que les utilisateurs voient dans la visionneuse :
Le tableau suivant résume les principales méthodes de conversion disponibles dans la bibliothèque et quand utiliser chacune d'elles :
| Méthode | Saisir | Idéal pour |
|---|---|---|
RenderHtmlAsPdf | chaîne HTML | Modèles de documents, factures, rapports |
RenderUrlAsPdf | URL | Archivage de pages Web, instantanés de contenu en direct |
RenderHtmlAsPdf + Razor | Vue rendue HTML | Réutiliser les modèles MVC existants au format PDF |
RenderHtmlFileAsPdf | Fichier HTML local | Modèles statiques stockés sur disque |
Pour les déploiements conteneurisés, IronPDF prend également en charge le moteur distant, ce qui vous permet d'exécuter la génération de PDF en tant que microservice dédié. Consultez le guide d'optimisation de la mémoire pour connaître les paramètres adaptés aux environnements aux ressources limitées.
Pour un aperçu complet des fonctionnalités, consultez la page des fonctionnalités IronPDF .
IronPDF va bien au-delà du simple rendu. Vous pouvez ajouter une structure et une identité visuelle à chaque document grâce aux options ci-dessous.
Les options de mise en page incluent les formats de papier personnalisés, les paramètres d'orientation et la configuration des marges. Le support typographique couvre le rendu complet des polices web via les déclarations CSS @font-face, ce qui signifie que les documents correspondent exactement à vos polices de marque. Vous pouvez également intégrer et redimensionner des images dans les pages PDF, ce qui vous offre un contrôle total sur la fidélité visuelle.
Pour la manipulation de documents, IronPDF vous permet de fusionner ou de diviser des PDF existants, d'ajouter ou de supprimer des pages individuelles et d'extraire du texte et des images par programmation. L'exécution de JavaScript avant la capture supporte les graphiques dynamiques et visualisations de données -- utile lorsqu'il s'agit de générer des rapports qui reposent sur des bibliothèques de rendu côté client telles que Chart.js ou D3.js.
Grâce à ces fonctionnalités, vous pouvez produire des documents soignés et prêts à imprimer directement depuis votre application, sans couche de traitement de documents séparée.
Si vous devez accepter des PDF téléchargés par les utilisateurs et les afficher à côté de ceux générés, IronPDF lit les fichiers binaires PDF existants aussi facilement qu'il en crée de nouveaux. Chargez un fichier avec PdfDocument.FromFile() et renvoyez son BinaryData via le même assistant File().
Consultez le tutoriel C# sur l'édition de PDF pour une présentation détaillée de l'édition, de l'annotation et de la modification de documents existants.
Les deux alternatives les plus courantes à une approche IronPDF côté serveur consistent à intégrer une bibliothèque de visualisation PDF côté client (telle que PDF.js , la visionneuse open-source de Mozilla) et à rediriger les utilisateurs vers un système de gestion de documents distinct.
Les visionneuses côté client comme PDF.js fonctionnent bien pour les cas d'affichage simples, mais nécessitent de servir le bundle JavaScript de la visionneuse, de gérer CORS pour les PDF externes et de gérer soi-même la compatibilité avec les navigateurs. La génération côté serveur avec IronPDF maintient le pipeline PDF entièrement sur la pile .NET , simplifiant ainsi la politique de sécurité et évitant la complexité liée aux origines croisées.
Un système de gestion documentaire dédié engendre des frais généraux opérationnels dont la plupart des applications web n'ont pas besoin. Pour les équipes utilisant déjà ASP.NET Core, générer et diffuser des PDF directement depuis le contrôleur est la solution la plus simple.
L'affichage de fichiers PDF dans une application web ASP.NET Core ne nécessite que quelques lignes de code. Générez le PDF avec ChromePdfRenderer, définissez Content-Disposition: inline, et renvoyez un FileResult -- le visualiseur intégré du navigateur gère tout le reste.
Pour les déploiements en production, tenez compte des étapes suivantes pour préparer votre configuration :
Prêt à ajouter la visualisation des PDF à votre projet ? Commencez par un essai gratuit et exécutez les exemples ci-dessus en quelques minutes. Lorsque vous serez prêt à déployer votre solution, examinez les options de licence qui correspondent à la taille de votre équipe et à votre utilisation. Pour explorer les conversions connexes, consultez la bibliothèque de guides pratiques pour savoir comment IronPDF gère les conversions DOCX vers PDF , image vers PDF et autres formats.
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 et créer des manuels bien structurés et visuellement attrayants.
IronPDF fait partie de IRONSUITE
10 API .NET pour vos documents
Lorsque vous avez besoin que votre PDF ressemble à HTML, rapidement.
