1. IronPDF
  2. Guides pratiques
  3. CSHTML en PDF (MVC Core)
Comment convertir des vues en PDF dans ASP.NET Core MVC | IronPDF

Comment convertir des vues en PDF en C#35 ; ASP.NET Core MVC

Curtis Chau
Curtis Chau
Mis à jour:
This article was translated from English: Does it need improvement?
Translated
View the article in English

Convertissez les vues ASP.NET Core MVC en PDF à l'aide de la méthode RenderRazorViewToPdf d'IronPDF, qui transforme les fichiers .cshtml en documents PDF de haute qualité avec une seule ligne de code dans votre application MVC.

Une vue est un composant du framework ASP.NET utilisé pour générer du balisage HTML dans les applications web. Il fait partie du modèle Modèle-Vue-Contrôleur (MVC), couramment utilisé dans les applications ASP.NET MVC et ASP.NET Core MVC. Les vues sont chargées de présenter des données aux utilisateurs en rendant le contenu HTML de manière dynamique. Les vues utilisent généralement la syntaxe Razor, une syntaxe de balisage permettant d'intégrer du code basé sur le serveur dans les pages web, ce qui en fait des outils puissants pour créer des documents PDF axés sur les données.

Démarrage rapide : Convertir CSHTML en PDF dans ASP.NET Core

Transformez les vues ASP.NET Core MVC en PDF à l'aide d'IronPDF. Avec une seule ligne de code, transformez vos fichiers '.cshtml' en documents PDF. Intégrez cette fonctionnalité directement dans votre application MVC pour une génération transparente de PDF à partir de vues HTML dynamiques. Suivez ce guide pour configurer votre environnement et commencer la conversion.

Nuget IconCommencez dès maintenant à créer des PDF avec NuGet :

  1. Installez IronPDF avec le gestionnaire de packages NuGet

    PM > Install-Package IronPdf

  2. Copiez et exécutez cet extrait de code.

    // using IronPdf.Extensions.Mvc.Core
new IronPdf.ChromePdfRenderer().RenderRazorViewToPdf(HttpContext, "Views/Home/Report.cshtml", model).SaveAs("report.pdf");

  3. Déployez pour tester sur votre environnement de production.

    Commencez à utiliser IronPDF dans votre projet dès aujourd'hui grâce à un essai gratuit.
    arrow pointer

ASP.NET Core Web App MVC (Model-View-Controller) est un cadre d'application web fourni par Microsoft pour la création d'applications web à l'aide d'ASP.NET Core.

  • Modèle : Représente les données et la logique commerciale, gère les interactions entre les données, communique avec les sources de données.
  • Vue : Présente l'interface utilisateur, affiche les données, rend les informations aux utilisateurs.
  • Contrôleur : gère les entrées des utilisateurs, répond aux demandes, communique avec le modèle, orchestre les interactions modèle-vue.

IronPDF permet de créer directement des fichiers PDF à partir de vues au sein de projets ASP.NET Core MVC. La génération de PDF devient ainsi simple dans ASP.NET Core MVC, prenant en charge des fonctionnalités modernes, notamment CSS styling, JavaScript execution, et polices personnalisées.

Flux de travail minimal (5 étapes)

  1. Télécharger la bibliothèque C# pour convertir les vues en PDF dans ASP.NET Core MVC
  2. Ajoutez une classe modèle pour les données
  3. Modifiez le fichier "HomeController.cs" et utilisez la méthode RenderRazorViewToPdf
  4. Créez une nouvelle vue et modifiez le fichier ".cshtml" pour rendre le PDF
  5. Téléchargez le projet d'exemple pour un démarrage rapide

Quel est le package dont j'ai besoin pour les extensions IronPDF?

Le package IronPdf.Extensions.Mvc.Core est une extension du package principal IronPdf. Les packages IronPdf.Extensions.Mvc.Core et IronPdf sont tous deux nécessaires pour effectuer le rendu des vues vers les documents PDF dans ASP.NET Core MVC. Le package d'extension fournit des fonctionnalités spécifiques pour l'intégration avec le système d'injection de dépendances d'ASP.NET Core et le pipeline de rendu de vues Razor.

Installer-Package IronPdf.Extensions.Mvc.Core

Pourquoi ai-je besoin d'IronPDF et du pack d'extensions?

Le package principal IronPDF contient le moteur de rendu PDF de base et les fonctionnalités fondamentales, tandis que le package Extensions.Mvc.Core fournit une intégration spécialisée avec le système de rendu de vues d'ASP.NET Core MVC. Cette séparation permet une meilleure modularité et garantit que vous n'incluez que les fonctionnalités spécifiques nécessaires à votre type de projet. Le paquet d'extension comprend l'interface IRazorViewRenderer et l'implémentation nécessaire pour convertir les vues Razor en HTML avant la génération de PDF.

Quelle version du package NuGet dois-je utiliser?

Utilisez toujours les versions correspondantes d'IronPDF et IronPdf.Extensions.Mvc.Core pour garantir la compatibilité. Pour obtenir les dernières versions stables et des informations sur la compatibilité des versions, consultez la documentation des packages NuGet. Lors de la mise à jour, veillez à ce que les deux paquets soient mis à jour en même temps afin de maintenir une fonctionnalité adéquate.

Quels sont les problèmes d'installation les plus courants ?

Les problèmes d'installation les plus courants sont les écarts de version entre les paquets de base et les paquets d'extension, les dépendances manquantes ou les exigences spécifiques à une plateforme. Si vous rencontrez des problèmes, assurez-vous que votre projet cible une version .NET prise en charge et consultez l'aperçu de l'installation pour connaître les étapes de dépannage.

Bibliothèque C# NuGet pour PDF

Installer avec NuGet

Installer-Package IronPdf.Extensions.Mvc.Core
nuget.org/packages/IronPdf.Extensions.Mvc.Core/

Comment rendre les vues en PDF?

Vous avez besoin d'un projet ASP.NET Core Web App (modèle-vue-contrôleur) pour convertir des vues en fichiers PDF. Le processus consiste à créer une action de contrôleur qui utilise la méthode RenderRazorViewToPdf d'IronPDF pour transformer vos vues Razor en documents PDF. Cette approche exploite toute la puissance de la syntaxe Razor, ce qui vous permet de créer des PDF complexes, axés sur les données et dotés d'un contenu dynamique.

Quel type de projet dois-je utiliser?

Utilisez le modèle ASP.NET Core Web App (modèle-vue-contrôleur) pour une compatibilité optimale avec les fonctionnalités de rendu de vue d'IronPDF. Ce type de projet fournit l'infrastructure nécessaire au rendu des vues, y compris le moteur de vue Razor et le routage approprié. Pour les projets existants, il convient de s'assurer qu'ils suivent le modèle MVC et que les fonctionnalités de rendu de vue requises sont installées.

Puis-je l'utiliser avec des API minimales?

Bien que les API minimales ne disposent pas d'une prise en charge intégrée des vues, vous pouvez toujours utiliser les fonctionnalités de conversion HTML vers PDF d'IronPDF. Pour la génération de PDF à partir de vues, utilisez l'approche MVC traditionnelle ou considérez Razor Pages comme une alternative.

Comment ajouter une classe de modèle?

  • Naviguez vers le dossier "Models".
  • Créez un nouveau fichier de classe C# nommé "Personne" Cette classe servira de modèle pour représenter les données individuelles. Utilisez l'extrait de code suivant :
:path=/static-assets/pdf/content-code-examples/how-to/cshtml-to-pdf-mvc-core-model.cs
namespace ViewToPdfMVCCoreSample.Models
{
    public class Person
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public string Title { get; set; }
        public string Description { get; set; }
    }
}
$vbLabelText   $csharpLabel

Pourquoi ai-je besoin d'un modèle pour la génération de PDF?

Les modèles fournissent des données structurées qui peuvent être transmises aux vues pour le rendu. Cette séparation des préoccupations permet de s'assurer que votre logique de génération de PDF reste propre et maintenable. Le modèle agit comme un contrat entre votre contrôleur et votre vue, assurant la sécurité des types et permettant la prise en charge IntelliSense dans vos vues Razor.

Quels sont les types de données qui fonctionnent le mieux avec les vues ?

Les types de données et les collections simples sont les mieux adaptés à la génération de PDF. Des objets complexes imbriqués peuvent être utilisés mais peuvent nécessiter une logique de vue supplémentaire. Pour des performances optimales, aplatissez les structures de données complexes dans votre contrôleur avant de les transmettre à la vue. Envisagez d'utiliser des ViewModels spécialement conçus pour la sortie PDF lorsque vos modèles de domaine sont trop complexes.

Voici un exemple de structure de modèle plus complexe adaptée à la génération de PDF :

public class InvoiceViewModel
{
    public string InvoiceNumber { get; set; }
    public DateTime InvoiceDate { get; set; }
    public decimal TotalAmount { get; set; }
    public List<InvoiceLineItem> LineItems { get; set; }
    public CustomerInfo Customer { get; set; }

    // Computed property for PDF display
    public string FormattedTotal => TotalAmount.ToString("C");
}

public class InvoiceLineItem
{
    public string Description { get; set; }
    public int Quantity { get; set; }
    public decimal UnitPrice { get; set; }
    public decimal LineTotal => Quantity * UnitPrice;
}

public class CustomerInfo
{
    public string Name { get; set; }
    public string Email { get; set; }
    public string Address { get; set; }
}
public class InvoiceViewModel
{
    public string InvoiceNumber { get; set; }
    public DateTime InvoiceDate { get; set; }
    public decimal TotalAmount { get; set; }
    public List<InvoiceLineItem> LineItems { get; set; }
    public CustomerInfo Customer { get; set; }

    // Computed property for PDF display
    public string FormattedTotal => TotalAmount.ToString("C");
}

public class InvoiceLineItem
{
    public string Description { get; set; }
    public int Quantity { get; set; }
    public decimal UnitPrice { get; set; }
    public decimal LineTotal => Quantity * UnitPrice;
}

public class CustomerInfo
{
    public string Name { get; set; }
    public string Email { get; set; }
    public string Address { get; set; }
}
$vbLabelText   $csharpLabel

Comment modifier le contrôleur?

Naviguez jusqu'au dossier "Controllers" et ouvrez le fichier "HomeController". Nous ne modifierons que le HomeController et ajouterons l'action Persons. Reportez-vous au code ci-dessous pour vous guider :

Le code ci-dessous instancie d'abord la classe ChromePdfRenderer, en transmettant un IRazorViewRenderer, le chemin vers notre Views/Home/Persons.cshtml, et la liste qui contient les données requises à la méthode RenderRazorViewToPdf. Les utilisateurs peuvent utiliser RenderingOptions pour accéder à une série de fonctionnalités, telles que l'ajout de texte personnalisé, l'inclusion d'en-têtes et de pieds de page HTML dans le PDF résultant, la définition de marges personnalisées et l'application de numéros de page. Pour des options de rendu plus avancées, voir la documentation sur les options de rendu.

Veuillez noterLe document PDF peut être visualisé dans le navigateur en utilisant le code suivant : File(pdf.BinaryData, "application/pdf"). Cependant, le téléchargement du PDF après son affichage dans le navigateur entraîne un document PDF endommagé.

using IronPdf.Extensions.Mvc.Core;
using Microsoft.AspNetCore.Mvc;
using System.Diagnostics;
using ViewToPdfMVCCoreSample.Models;

namespace ViewToPdfMVCCoreSample.Controllers
{
    public class HomeController : Controller
    {
        private readonly ILogger<HomeController> _logger;
        private readonly IRazorViewRenderer _viewRenderService;
        private readonly IHttpContextAccessor _httpContextAccessor;

        public HomeController(ILogger<HomeController> logger, IRazorViewRenderer viewRenderService, IHttpContextAccessor httpContextAccessor)
        {
            _logger = logger;
            _viewRenderService = viewRenderService;
            _httpContextAccessor = httpContextAccessor;
        }

        public IActionResult Index()
        {
            return View();
        }

        public async Task<IActionResult> Persons()
        {
            // Example list of persons
            var persons = new List<Person>
            {
                new Person { Name = "Alice", Title = "Mrs.", Description = "Software Engineer" },
                new Person { Name = "Bob", Title = "Mr.", Description = "Software Engineer" },
                new Person { Name = "Charlie", Title = "Mr.", Description = "Software Engineer" }
            };

            // Check if the request method is POST
            if (_httpContextAccessor.HttpContext.Request.Method == HttpMethod.Post.Method)
            {
                // Create a new PDF renderer
                ChromePdfRenderer renderer = new ChromePdfRenderer();

                // Configure rendering options for better output
                renderer.RenderingOptions.MarginTop = 40;
                renderer.RenderingOptions.MarginBottom = 40;
                renderer.RenderingOptions.PaperOrientation = IronPdf.Rendering.PdfPaperOrientation.Portrait;
                renderer.RenderingOptions.Title = "Persons Report";

                // Render View to PDF document
                PdfDocument pdf = renderer.RenderRazorViewToPdf(_viewRenderService, "Views/Home/Persons.cshtml", persons);

                Response.Headers.Add("Content-Disposition", "inline");

                // Output PDF document
                return File(pdf.BinaryData, "application/pdf", "viewToPdfMVCCore.pdf");
            }

            return View(persons);
        }

        public IActionResult Privacy()
        {
            return View();
        }

        [ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
        public IActionResult Error()
        {
            return View(new ErrorViewModel { RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier });
        }
    }
}
using IronPdf.Extensions.Mvc.Core;
using Microsoft.AspNetCore.Mvc;
using System.Diagnostics;
using ViewToPdfMVCCoreSample.Models;

namespace ViewToPdfMVCCoreSample.Controllers
{
    public class HomeController : Controller
    {
        private readonly ILogger<HomeController> _logger;
        private readonly IRazorViewRenderer _viewRenderService;
        private readonly IHttpContextAccessor _httpContextAccessor;

        public HomeController(ILogger<HomeController> logger, IRazorViewRenderer viewRenderService, IHttpContextAccessor httpContextAccessor)
        {
            _logger = logger;
            _viewRenderService = viewRenderService;
            _httpContextAccessor = httpContextAccessor;
        }

        public IActionResult Index()
        {
            return View();
        }

        public async Task<IActionResult> Persons()
        {
            // Example list of persons
            var persons = new List<Person>
            {
                new Person { Name = "Alice", Title = "Mrs.", Description = "Software Engineer" },
                new Person { Name = "Bob", Title = "Mr.", Description = "Software Engineer" },
                new Person { Name = "Charlie", Title = "Mr.", Description = "Software Engineer" }
            };

            // Check if the request method is POST
            if (_httpContextAccessor.HttpContext.Request.Method == HttpMethod.Post.Method)
            {
                // Create a new PDF renderer
                ChromePdfRenderer renderer = new ChromePdfRenderer();

                // Configure rendering options for better output
                renderer.RenderingOptions.MarginTop = 40;
                renderer.RenderingOptions.MarginBottom = 40;
                renderer.RenderingOptions.PaperOrientation = IronPdf.Rendering.PdfPaperOrientation.Portrait;
                renderer.RenderingOptions.Title = "Persons Report";

                // Render View to PDF document
                PdfDocument pdf = renderer.RenderRazorViewToPdf(_viewRenderService, "Views/Home/Persons.cshtml", persons);

                Response.Headers.Add("Content-Disposition", "inline");

                // Output PDF document
                return File(pdf.BinaryData, "application/pdf", "viewToPdfMVCCore.pdf");
            }

            return View(persons);
        }

        public IActionResult Privacy()
        {
            return View();
        }

        [ResponseCache(Duration = 0, Location = ResponseCacheLocation.None, NoStore = true)]
        public IActionResult Error()
        {
            return View(new ErrorViewModel { RequestId = Activity.Current?.Id ?? HttpContext.TraceIdentifier });
        }
    }
}
$vbLabelText   $csharpLabel

Après avoir utilisé la méthode RenderRazorViewToPdf, vous recevez un objet PdfDocument qui est ouvert à d'autres améliorations et modifications. Vous pouvez convertir le PDF aux formats PDF/A ou PDF/UA, ajouter votre signature numérique au PDF généré, ou encore fusionner et diviser des documents PDF selon vos besoins. De plus, la bibliothèque vous permet de faire pivoter des pages, d'insérer des annotations ou des signets, et d'imprimer des filigranes uniques sur vos fichiers PDF.

Qu'est-ce que le service IRazorViewRenderer?

Le IRazorViewRenderer est une interface de service fournie par le package IronPdf.Extensions.Mvc.Core qui gère la conversion des vues Razor en HTML. Il s'intègre au moteur de vue d'ASP.NET Core pour traiter les fichiers .cshtml avec leurs modèles associés, en exécutant toute la syntaxe Razor et en produisant le HTML final qu'IronPDF convertit en PDF.

Pourquoi vérifier la méthode POST avant le rendu?

La vérification de POST permet de s'assurer que la génération de PDF n'a lieu que lorsqu'elle est explicitement demandée par le biais d'un formulaire. Cela évite la génération accidentelle de PDF lors du chargement des pages et permet à la même action de servir à la fois la vue HTML (sur GET) et le téléchargement du PDF (sur POST). Ce modèle suit les principes RESTful et offre une meilleure expérience à l'utilisateur.

Comment puis-je personnaliser la sortie PDF?

IronPDF offre des options de personnalisation étendues par le biais de la propriété RenderingOptions. Voici un exemple avec des paramètres plus avancés :

// Advanced rendering configuration example
var renderer = new ChromePdfRenderer();

// Page setup
renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;
renderer.RenderingOptions.MarginLeft = 20;
renderer.RenderingOptions.MarginRight = 20;

// Headers and footers with merge fields
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter()
{
    Height = 25,
    HtmlFragment = "<div style='text-align: center; font-size: 12px;'>Page {page} of {total-pages}</div>"
};

// JavaScript execution delay for dynamic content
renderer.RenderingOptions.WaitFor = new WaitFor()
{
    RenderDelay = 500, // Wait 500ms for JS execution
    NetworkIdle = NetworkIdleTypes.NetworkIdle0 // Wait for network requests
};

// Apply watermark
renderer.RenderingOptions.TextHeader = new TextHeaderFooter()
{
    DrawDividerLine = true,
    CenterText = "CONFIDENTIAL",
    Font = new FontTypes() { FontSize = 16 }
};
// Advanced rendering configuration example
var renderer = new ChromePdfRenderer();

// Page setup
renderer.RenderingOptions.PaperSize = IronPdf.Rendering.PdfPaperSize.A4;
renderer.RenderingOptions.MarginLeft = 20;
renderer.RenderingOptions.MarginRight = 20;

// Headers and footers with merge fields
renderer.RenderingOptions.HtmlHeader = new HtmlHeaderFooter()
{
    Height = 25,
    HtmlFragment = "<div style='text-align: center; font-size: 12px;'>Page {page} of {total-pages}</div>"
};

// JavaScript execution delay for dynamic content
renderer.RenderingOptions.WaitFor = new WaitFor()
{
    RenderDelay = 500, // Wait 500ms for JS execution
    NetworkIdle = NetworkIdleTypes.NetworkIdle0 // Wait for network requests
};

// Apply watermark
renderer.RenderingOptions.TextHeader = new TextHeaderFooter()
{
    DrawDividerLine = true,
    CenterText = "CONFIDENTIAL",
    Font = new FontTypes() { FontSize = 16 }
};
$vbLabelText   $csharpLabel

Quelles sont les erreurs de contrôleur les plus courantes ?

Les erreurs les plus courantes sont les exceptions de référence nulle lorsque les services ne sont pas correctement injectés, les problèmes de chemin d'accès lors de la spécification de l'emplacement des vues et les problèmes de liaison de modèle. Assurez-vous que tous les services requis sont enregistrés dans Program.cs et utilisez des chemins relatifs à partir de la racine du projet lorsque vous spécifiez l'emplacement des vues. Pour le dépannage, activez les messages d'erreur détaillés en mode développement.

Comment ajouter une vue?

  • Cliquez avec le bouton droit de la souris sur l'action Personne nouvellement ajoutée et sélectionnez "Ajouter une vue"

Menu contextuel de Visual Studio montrant l'option 'Add View...' en surbrillance lors d'un clic droit sur la méthode Persons()

Sélectionnez le modèle

Ajouter une boîte de dialogue Razor View dans Visual Studio montrant un modèle de liste et une sélection de classe de modèle de personne avec des options de mise en page

  • Sélectionnez le modèle "List" et la classe de modèle Person.

Ajouter une boîte de dialogue Razor View dans Visual Studio montrant un modèle de liste et une sélection de classe de modèle de personne avec des options de mise en page

Cela crée un fichier .cshtml nommé Personnes.

  • Naviguez jusqu'au dossier "Views" -> dossier "Home" -> fichier Persons.cshtml.

Pour ajouter un bouton qui invoque l'action Personnes, utilisez le code ci-dessous :

@using (Html.BeginForm("Persons", "Home", FormMethod.Post))
{
    <input type="submit" value="Print Person" />
}
@using (Html.BeginForm("Persons", "Home", FormMethod.Post))
{
    <input type="submit" value="Print Person" />
}
HTML

Pourquoi utiliser FormMethod.Post pour la génération de PDF?

L'utilisation de POST pour la génération de PDF respecte les meilleures pratiques du web en rendant l'action explicite et en empêchant la génération indésirable de PDF à partir de rafraîchissements du navigateur ou d'URL marquées d'un signet. les requêtes GET doivent être idempotentes (ne pas modifier l'état du serveur), tandis que les requêtes POST indiquent une action qui produit un résultat - dans ce cas, la génération d'un document PDF.

Comment styliser le bouton d'impression PDF?

Styliser le bouton d'impression à l'aide de classes CSS et l'améliorer à l'aide de JavaScript pour une meilleure expérience de l'utilisateur. Voici une version améliorée :

@using (Html.BeginForm("Persons", "Home", FormMethod.Post, new { @class = "pdf-form" }))
{
    <button type="submit" class="btn btn-primary pdf-download-btn">
        <i class="fas fa-file-pdf"></i> Download as PDF
    </button>
}

<style>
    .pdf-download-btn {
        background-color: #dc3545;
        color: white;
        padding: 10px 20px;
        border: none;
        border-radius: 5px;
        cursor: pointer;
        transition: background-color 0.3s ease;
    }

    .pdf-download-btn:hover {
        background-color: #c82333;
    }

    .pdf-download-btn:active {
        transform: translateY(1px);
    }
</style>

<script>
    // Optional: Show loading indicator during PDF generation
    document.querySelector('.pdf-form').addEventListener('submit', function() {
        const button = this.querySelector('button');
        button.innerHTML = '<i class="fas fa-spinner fa-spin"></i> Generating PDF...';
        button.disabled = true;
    });
</script>
@using (Html.BeginForm("Persons", "Home", FormMethod.Post, new { @class = "pdf-form" }))
{
    <button type="submit" class="btn btn-primary pdf-download-btn">
        <i class="fas fa-file-pdf"></i> Download as PDF
    </button>
}

<style>
    .pdf-download-btn {
        background-color: #dc3545;
        color: white;
        padding: 10px 20px;
        border: none;
        border-radius: 5px;
        cursor: pointer;
        transition: background-color 0.3s ease;
    }

    .pdf-download-btn:hover {
        background-color: #c82333;
    }

    .pdf-download-btn:active {
        transform: translateY(1px);
    }
</style>

<script>
    // Optional: Show loading indicator during PDF generation
    document.querySelector('.pdf-form').addEventListener('submit', function() {
        const button = this.querySelector('button');
        button.innerHTML = '<i class="fas fa-spinner fa-spin"></i> Generating PDF...';
        button.disabled = true;
    });
</script>
HTML

Quels sont les modèles d'affichage qui conviennent le mieux aux PDF ?

Les modèles List et Details sont particulièrement adaptés à la génération de PDF, car ils fournissent des mises en page structurées. Les modèles personnalisés, conçus spécifiquement pour la production de PDF, donnent souvent les meilleurs résultats. Envisagez de créer des vues PDF dédiées qui optimisent la mise en page pour l'impression plutôt que l'affichage à l'écran, en supprimant les éléments de navigation et en vous concentrant sur la présentation du contenu.

Comment ajouter une section à la barre de navigation supérieure ?

  • Dans le même dossier "Views", naviguez jusqu'au dossier "Shared" -> _Layout.cshtml. Placez l'élément de navigation Personne après Accueil.

Assurez-vous que la valeur de l'attribut asp-action correspond exactement au nom de notre fichier, qui dans ce cas est Personnes.

<header>
    <nav class="navbar navbar-expand-sm navbar-toggleable-sm navbar-light bg-white border-bottom box-shadow mb-3">
        <div class="container-fluid">
            <a class="navbar-brand" asp-area="" asp-controller="Home" asp-action="Index">ViewToPdfMVCCoreSample</a>
            <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target=".navbar-collapse" aria-controls="navbarSupportedContent"
                    aria-expanded="false" aria-label="Toggle navigation">
                <span class="navbar-toggler-icon"></span>
            </button>
            <div class="navbar-collapse collapse d-sm-inline-flex justify-content-between">
                <ul class="navbar-nav flex-grow-1">
                    <li class="nav-item">
                        <a class="nav-link text-dark" asp-area="" asp-controller="Home" asp-action="Index">Home</a>
                    </li>
                    <li class="nav-item">
                        <a class="nav-link text-dark" asp-area="" asp-controller="Home" asp-action="Persons">Person</a>
                    </li>
                    <li class="nav-item">
                        <a class="nav-link text-dark" asp-area="" asp-controller="Home" asp-action="Privacy">Privacy</a>
                    </li>
                </ul>
            </div>
        </div>
    </nav>
</header>
<header>
    <nav class="navbar navbar-expand-sm navbar-toggleable-sm navbar-light bg-white border-bottom box-shadow mb-3">
        <div class="container-fluid">
            <a class="navbar-brand" asp-area="" asp-controller="Home" asp-action="Index">ViewToPdfMVCCoreSample</a>
            <button class="navbar-toggler" type="button" data-bs-toggle="collapse" data-bs-target=".navbar-collapse" aria-controls="navbarSupportedContent"
                    aria-expanded="false" aria-label="Toggle navigation">
                <span class="navbar-toggler-icon"></span>
            </button>
            <div class="navbar-collapse collapse d-sm-inline-flex justify-content-between">
                <ul class="navbar-nav flex-grow-1">
                    <li class="nav-item">
                        <a class="nav-link text-dark" asp-area="" asp-controller="Home" asp-action="Index">Home</a>
                    </li>
                    <li class="nav-item">
                        <a class="nav-link text-dark" asp-area="" asp-controller="Home" asp-action="Persons">Person</a>
                    </li>
                    <li class="nav-item">
                        <a class="nav-link text-dark" asp-area="" asp-controller="Home" asp-action="Privacy">Privacy</a>
                    </li>
                </ul>
            </div>
        </div>
    </nav>
</header>
HTML

Pourquoi l'asp-action doit-elle correspondre exactement ?

L'attribut asp-action utilise les aides de balise d'ASP.NET Core pour générer l'URL correcte en fonction de votre configuration de routage. Une correspondance exacte permet de s'assurer que le lien renvoie à l'action correcte du contrôleur. Les incohérences entraînent des erreurs 404 ou un acheminement vers des actions non souhaitées. Le système d'aide aux balises est sensible à la casse et doit correspondre au nom exact de la méthode dans votre contrôleur.

Qu'arrive-t-il si les liens de navigation ne correspondent pas?

Lorsque les liens de navigation ne correspondent pas aux actions des contrôleurs, les utilisateurs rencontrent des erreurs 404 ou sont dirigés vers des pages incorrectes. Pendant le développement, la page d'exception du développeur d'ASP.NET Core affiche les erreurs de routage détaillées. En production, les utilisateurs voient des pages d'erreur génériques. Vérifiez toujours que les liens de navigation correspondent exactement aux noms des actions des contrôleurs afin d'éviter les erreurs d'utilisation.

Comment modifier le fichier Program.cs?

Enregistrer l'interface IHttpContextAccessor et IRazorViewRenderer dans le conteneur d'injection de dépendances (DI). Consultez le code ci-dessous à titre de référence.

using IronPdf.Extensions.Mvc.Core;
using Microsoft.AspNetCore.Mvc.ViewFeatures;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddControllersWithViews();

builder.Services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();
builder.Services.AddSingleton<ITempDataProvider, CookieTempDataProvider>();

// Register IRazorViewRenderer here
builder.Services.AddSingleton<IRazorViewRenderer, RazorViewRenderer>();

// Optional: Configure IronPDF license if you have one
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";

var app = builder.Build();

// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Home/Error");
    // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
    app.UseHsts();
}

app.UseHttpsRedirection();
app.UseStaticFiles();

app.UseRouting();

app.UseAuthorization();

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

app.Run();
using IronPdf.Extensions.Mvc.Core;
using Microsoft.AspNetCore.Mvc.ViewFeatures;

var builder = WebApplication.CreateBuilder(args);

// Add services to the container.
builder.Services.AddControllersWithViews();

builder.Services.AddSingleton<IHttpContextAccessor, HttpContextAccessor>();
builder.Services.AddSingleton<ITempDataProvider, CookieTempDataProvider>();

// Register IRazorViewRenderer here
builder.Services.AddSingleton<IRazorViewRenderer, RazorViewRenderer>();

// Optional: Configure IronPDF license if you have one
IronPdf.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";

var app = builder.Build();

// Configure the HTTP request pipeline.
if (!app.Environment.IsDevelopment())
{
    app.UseExceptionHandler("/Home/Error");
    // The default HSTS value is 30 days. You may want to change this for production scenarios, see https://aka.ms/aspnetcore-hsts.
    app.UseHsts();
}

app.UseHttpsRedirection();
app.UseStaticFiles();

app.UseRouting();

app.UseAuthorization();

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

app.Run();
$vbLabelText   $csharpLabel

Pourquoi enregistrer les services en tant que singleton?

Les services singleton sont créés une seule fois et réutilisés pendant toute la durée de vie de l'application, ce qui les rend efficaces pour les services sans état comme IRazorViewRenderer. Ce modèle réduit la surcharge de mémoire et améliore les performances puisque le service de rendu de la vue ne conserve pas d'état spécifique à la demande. Le IHttpContextAccessor doit être singleton pour être accessible à travers différentes durées de vie de service.

À quoi sert ITempDataProvider?

ITempDataProvider permet le stockage temporaire de données entre les requêtes, généralement utilisé pour afficher des messages après les redirections. Dans le contexte de la génération de PDF, elle garantit que l'état de la vue est correctement maintenu lors du rendu des vues au format PDF. Le CookieTempDataProvider stocke ces données temporaires dans des cookies cryptés, fournissant ainsi un mécanisme sécurisé pour la gestion de l'état.

Puis-je utiliser les Scoped Services à la place?

Bien que vous puissiez utiliser des services étendus pour certains scénarios, IRazorViewRenderer fonctionne mieux en tant que singleton parce qu'il ne conserve pas d'état spécifique à la demande. L'utilisation de services étendus créerait de nouvelles instances pour chaque demande, ce qui augmenterait l'utilisation de la mémoire sans aucun avantage. Toutefois, si vous devez injecter des services à portée dans vos vues, veillez à gérer correctement la durée de vie des services afin d'éviter les erreurs d'exécution.

Exécuter le projet

Ce document montre comment exécuter le projet et générer un document PDF. Lorsque vous exécutez l'application, accédez à la page Personnes à l'aide du menu de navigation supérieur, puis cliquez sur le bouton Imprimer la personne pour générer et télécharger le PDF.

Visual Studio showing HomeController.cs with ASP.NET Core MVC controller code and IntelliSense assistance

Où puis-je télécharger le projet ASP.NET Core MVC?

Téléchargez le code complet de ce guide. Il se présente sous la forme d'un fichier zippé que vous pouvez ouvrir dans Visual Studio en tant que projet ASP.NET Core Web App (Modèle-Vue-Contrôleur).

Télécharger l'exemple de projet ASP.NET Core MVC

Qu'est-ce qui est inclus dans l'exemple de projet?

Le projet d'exemple comprend une application ASP.NET Core MVC entièrement configurée avec l'intégration IronPDF, démontrant la conversion de la vue au format PDF. Il contient le modèle Person, HomeController avec la logique de génération de PDF, la vue Persons avec la syntaxe Razor appropriée, et tous les enregistrements de services nécessaires dans Program.cs. Le projet comprend également des exemples de configurations de style et de mise en page optimisées pour la sortie PDF.

Quelle version de Visual Studio dois-je utiliser ?

Visual Studio 2022 (version 17.0 ou ultérieure) est recommandé pour une expérience optimale avec les projets .NET 6+. Visual Studio Code avec les extensions C# fonctionne également bien pour le développement multiplateforme. Assurez-vous d'avoir installé ASP.NET et la charge de travail de développement web. Le projet cible .NET 6.0 par défaut mais peut être mis à jour pour des versions plus récentes.

Comment résoudre les problèmes de configuration de projet?

Les problèmes d'installation les plus courants sont les paquets NuGet manquants, les versions incorrectes du SDK .NET ou les problèmes de configuration. Tout d'abord, restaurez les packages NuGet à l'aide de dotnet restore ou via le gestionnaire de packages de Visual Studio. Vérifiez que la version de votre SDK .NET correspond aux exigences du projet en utilisant dotnet --version. Pour les questions de licence, voir la documentation sur les clés de licence. En cas de problèmes de rendu, consultez le guide de dépannage pour trouver des solutions.

Prêt à voir ce que vous pouvez faire d'autre? Consultez notre page de tutoriels ici : Convertir les PDFs

Questions Fréquemment Posées

Quel est le moyen le plus simple de convertir des vues CSHTML en PDF dans ASP.NET Core MVC ?

Le moyen le plus simple consiste à utiliser la méthode RenderRazorViewToPdf d'IronPDF, qui peut convertir vos fichiers .cshtml en documents PDF en une seule ligne de code. Il suffit d'appeler : new IronPdf.ChromePdfRenderer().RenderRazorViewToPdf(HttpContext, "Views/Home/Report.cshtml", model).SaveAs("report.pdf") ;

Quels sont les packages NuGet dont j'ai besoin pour convertir des vues en PDF dans ASP.NET Core MVC ?

Vous avez besoin de deux paquets : IronPDF (le package principal) et IronPdf.Extensions.Mvc.Core (le package d'extension). Le package d'extension fournit des fonctionnalités spécifiques pour s'intégrer au système d'injection de dépendances et au pipeline de rendu de vues Razor d'ASP.NET Core.

Puis-je appliquer le style CSS et JavaScript lors de la conversion de CSHTML en PDF ?

Oui, IronPDF prend entièrement en charge le style CSS, l'exécution JavaScript et les polices personnalisées lors du rendu des vues au format PDF. Cela garantit que vos PDF conservent la même apparence et la même fonctionnalité que vos vues Web, y compris le CSS réactif et le contenu JavaScript dynamique.

Quelles sont les principales étapes pour mettre en œuvre la conversion View to PDF dans mon projet ASP.NET Core MVC ?

Le flux de travail comprend 5 étapes : 1) Télécharger IronPDF et son extension MVC Core, 2) Ajouter une classe de modèle pour vos données, 3) Modifier votre contrôleur pour utiliser la méthode RenderRazorViewToPdf, 4) Créer ou modifier une vue (fichier .cshtml) pour le rendu PDF, et 5) Exécuter votre application pour générer des PDF.

Comment le modèle MVC fonctionne-t-il avec la génération de PDF à partir de vues ?

Dans ASP.NET Core MVC, le modèle contient vos données et votre logique métier, la vue (votre fichier .cshtml) présente l'interface utilisateur et affiche les données, et le contrôleur traite les demandes et utilise la méthode IronPDF's RenderRazorViewToPdf pour orchestrer la génération de PDF à partir de la vue.

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
Revu par
Jeff Fritz
Jeffrey T. Fritz
Responsable principal du programme - Équipe de la communauté .NET
Jeff est également responsable principal du programme pour les équipes .NET et Visual Studio. Il est le producteur exécutif de la série de conférences virtuelles .NET Conf et anime 'Fritz and Friends', une diffusion en direct pour développeurs qui est diffusée deux fois par semaine où il parle de technologie et écrit du code avec les téléspectateurs. Jeff écrit des ateliers, des présentations et prévoit du contenu pour les plus grands événements de développement Microsoft, y compris Microsoft Build, Microsoft Ignite, .NET Conf et le sommet Microsoft MVP
Prêt à commencer?
Nuget Téléchargements 17,012,929 | Version : 2025.12 vient de sortir