Comment créer un rapport en ASP .NET

Les rapports sont essentiels pour présenter les données dans un format structuré et visuellement attrayant. Qu'il s'agisse de données de vente, d'analyses ou de résumés financiers, la génération de rapports est une exigence courante dans les applications web. Microsoft fournit des services de rapports rdlc qui peuvent être intégrés dans des applications Web en utilisant le Web Forms Report Viewer Control. Cependant, le processus peut souvent être complexe et prendre du temps.

C'est là qu'intervient IronPDF. IronPDF est une bibliothèque polyvalente qui simplifie la génération de rapports PDF dans ASP.NET et d'autres frameworks web, offrant des fonctionnalités puissantes et une grande facilité d'utilisation. Dans cet article, nous verrons comment créer un rapport en ASP.NET à l'aide d'IronPDF for .NET.

Comment créer un rapport en ASP.NET

1. Créer une application Web ASP.NET à l'aide de Visual Studio

2. Installez IronPDF et IronPDF.Extensions.MVC.Core

3. Instancier l'objet ChromePdfRenderer expéditeur

4. Appelez la méthode RenderRazorViewToPdf pour convertir la vue en PDF

5. Ajoutez "Content-Disposition" en utilisant Response.Headers.Append

6. Créez un rapport en utilisant la méthode File avec PDF.BinaryData

Introduction à IronPDF

IronPDF est une bibliothèque polyvalente qui simplifie la génération de documents PDF dans ASP.NET et d'autres frameworks web. Ses riches fonctionnalités et ses API intuitives en font un choix idéal pour les développeurs qui souhaitent générer des rapports dynamiques, des factures, des reçus, etc. directement à partir de leurs applications web. Avec IronPDF, les développeurs peuvent convertir sans effort des vues HTML, CSS et même Razor en documents PDF de haute qualité, ce qui permet une intégration transparente de la fonctionnalité de création de rapports dans leurs projets ASP.NET.

Caractéristiques d'IronPDF

• Conversion HTML en PDF : Convertissez facilement le contenu HTML, y compris les styles CSS, en documents PDF de haute qualité.
• Édition de PDF : Modifiez des documents PDF existants en ajoutant ou en supprimant du texte, des images et des annotations.
• Remplissage de formulaires PDF : Remplissez dynamiquement les formulaires PDF avec les données de votre application web.
• Génération de Codes-Barres : Générer des codes-barres et des codes QR dans des documents PDF pour les étiquettes de produits ou le suivi des stocks.
• Filigrane : Ajoutez des filigranes aux pages PDF pour protéger les informations sensibles ou marquer les documents.
• Cryptage et Sécurité : Sécurisez les documents PDF avec le cryptage, des mots de passe, et des paramètres d'autorisations.

Conditions préalables

Avant de commencer, assurez-vous que vous disposez des conditions préalables suivantes :

• Connaissance de base du développement ASP.NET.
• Visual Studio est installé sur votre machine.
• IronPDF et IronPDF.Extensions.Mvc.Core

Étapes de la création d'un projet ASP.NET dans Visual Studio

1. Ouvrez Visual Studio et créez un nouveau projet ASP.NET Core.

2. Choisissez le modèle de projet souhaité (par exemple, MVC ou Razor Pages).

   

3. Configurer les paramètres du projet tels que le nom du projet, l'emplacement et la version du framework.

   

4. Cliquez sur "Créer" pour générer la structure du projet.

Installation d'IronPDF et d'IronPDF.Extensions.Mvc.Core

Ensuite, installons IronPDF et son package d'extension MVC à l'aide du NuGet Package Manager :

1. Ouvrez le gestionnaire de paquets NuGet pour les solutions en cliquant avec le bouton droit de la souris sur l'explorateur de solutions.

2. Cherchez "IronPDF" et "IronPDF.Extensions.Mvc.Core".

   

3. Installez les deux paquets dans votre solution.

Étapes de la création d'une visionneuse de rapports dans une application Web ASP.NET

Voyons maintenant les étapes de la création d'un rapport PDF à l'aide d'IronPDF for .NET dans notre projet ASP.NET. Avant de convertir une vue en rapport, nous avons besoin d'un modèle, d'une vue et d'un contrôleur pour créer une source de données permettant de créer et de télécharger un nouveau rapport au format PDF.

Étape 1 : Définir une classe de modèle

D'abord, créez une classe modèle (SalesModel.cs) pour représenter les données de ventes. Cet exemple de classe SalesModel comprendra des propriétés telles que Date, ProductName, Quantity, UnitPrice et TotalAmount. Cette fonction est utile pour récupérer des informations à partir d'une source de données telle que Microsoft SQL Server ou MySQL Server.

namespace ReportGenerator.Models
{
    public class SalesModel
    {
        public DateTime Date { get; set; }
        public string ProductName { get; set; }
        public int Quantity { get; set; }
        public decimal UnitPrice { get; set; }
        public decimal TotalAmount => Quantity * UnitPrice;
    }
}

namespace ReportGenerator.Models
{
    public class SalesModel
    {
        public DateTime Date { get; set; }
        public string ProductName { get; set; }
        public int Quantity { get; set; }
        public decimal UnitPrice { get; set; }
        public decimal TotalAmount => Quantity * UnitPrice;
    }
}

Namespace ReportGenerator.Models
	Public Class SalesModel
		Public Property [Date]() As DateTime
		Public Property ProductName() As String
		Public Property Quantity() As Integer
		Public Property UnitPrice() As Decimal
		Public ReadOnly Property TotalAmount() As Decimal
			Get
				Return Quantity * UnitPrice
			End Get
		End Property
	End Class
End Namespace

Étape 2 : Créer une nouvelle vue Web Form

Ensuite, créez une vue Razor (Sales.cshtml) pour afficher les données de vente sous forme de tableau et fournir un bouton pour générer le rapport PDF.

<!-- Index.cshtml -->
@model List<SalesModel>
<!DOCTYPE html>
<html>
<head>
    <title>Sales Report</title>
    <style>
        table {
            border-collapse: collapse;
            width: 100%;
        }
        th, td {
            border: 1px solid #dddddd;
            text-align: left;
            padding: 8px;
        }
        th {
            background-color: #f2f2f2;
        }
    </style>
</head>
<body>
    <h2>Sales Report</h2>
    <table>
        <tr>
            <th>Date</th>
            <th>Product Name</th>
            <th>Quantity</th>
            <th>Unit Price</th>
            <th>Total Amount</th>
        </tr>
        @foreach (var item in Model)
        {
            <tr>
                <td>@item.Date.ToShortDateString()</td>
                <td>@item.ProductName</td>
                <td>@item.Quantity</td>
                <td>@item.UnitPrice.ToString("C")</td>
                <td>@item.TotalAmount.ToString("C")</td>
            </tr>
        }
    </table>
    <br />
    @using (Html.BeginForm("GeneratePdf", "Sales", FormMethod.Post))
    {
        <button type="submit">Generate PDF Report</button>
    }
</body>
</html>

<!-- Index.cshtml -->
@model List<SalesModel>
<!DOCTYPE html>
<html>
<head>
    <title>Sales Report</title>
    <style>
        table {
            border-collapse: collapse;
            width: 100%;
        }
        th, td {
            border: 1px solid #dddddd;
            text-align: left;
            padding: 8px;
        }
        th {
            background-color: #f2f2f2;
        }
    </style>
</head>
<body>
    <h2>Sales Report</h2>
    <table>
        <tr>
            <th>Date</th>
            <th>Product Name</th>
            <th>Quantity</th>
            <th>Unit Price</th>
            <th>Total Amount</th>
        </tr>
        @foreach (var item in Model)
        {
            <tr>
                <td>@item.Date.ToShortDateString()</td>
                <td>@item.ProductName</td>
                <td>@item.Quantity</td>
                <td>@item.UnitPrice.ToString("C")</td>
                <td>@item.TotalAmount.ToString("C")</td>
            </tr>
        }
    </table>
    <br />
    @using (Html.BeginForm("GeneratePdf", "Sales", FormMethod.Post))
    {
        <button type="submit">Generate PDF Report</button>
    }
</body>
</html>

Maintenant, ajoutez les Ventes comme un élément de menu dans le fichier _Layout.cshtml situé dans le dossier Views->Shared pour créer une vue de créateur de rapport :

<li class="nav-item">
    <a class="nav-link text-dark" asp-area="" asp-controller="Sales" asp-action="Sales">Sales</a>
</li>

<li class="nav-item">
    <a class="nav-link text-dark" asp-area="" asp-controller="Sales" asp-action="Sales">Sales</a>
</li>

Étape 3 : Enregistrement du service View Render

L'inclusion de l'enregistrement du service de rendu de vue dans le fichier Program.cs est cruciale pour que l'injection de dépendances fonctionne correctement. Ajoutez le code suivant au fichier Program.cs pour enregistrer le service IRazorViewRenderer :

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

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

' Register the IRazorViewRenderer service
builder.Services.AddSingleton(Of IRazorViewRenderer, RazorViewRenderer)()

Étape 3 : Mise en œuvre de la classe de contrôleur de l'API Web

Implémentez un contrôleur (SalesController.cs) avec des actions pour rendre la vue des ventes et générer le rapport PDF. Injectez le service IRazorViewRenderer fourni par IronPDF dans le constructeur du contrôleur.

using ReportGenerator.Models;
namespace ReportGenerator.Controllers
{
    public class SalesController : Controller
    {
        private readonly IRazorViewRenderer _viewRenderService;
        private readonly List<SalesModel> salesData;
        public SalesController(IRazorViewRenderer viewRenderService)
        {
            _viewRenderService = viewRenderService;
            // Example data with sales information
            salesData = new List<SalesModel>
            {
                new SalesModel { Date = DateTime.Parse("2024-03-01"), ProductName = "Product A", Quantity = 10, UnitPrice = 50.00m },
                new SalesModel { Date = DateTime.Parse("2024-03-02"), ProductName = "Product B", Quantity = 15, UnitPrice = 40.00m },
                new SalesModel { Date = DateTime.Parse("2024-03-03"), ProductName = "Product C", Quantity = 20, UnitPrice = 30.00m }
                // Add more data as needed
            };
        }
        public IActionResult Sales()
        {
        // Renders the data in Sales view
            return View(salesData);
        }
    }
}

using ReportGenerator.Models;
namespace ReportGenerator.Controllers
{
    public class SalesController : Controller
    {
        private readonly IRazorViewRenderer _viewRenderService;
        private readonly List<SalesModel> salesData;
        public SalesController(IRazorViewRenderer viewRenderService)
        {
            _viewRenderService = viewRenderService;
            // Example data with sales information
            salesData = new List<SalesModel>
            {
                new SalesModel { Date = DateTime.Parse("2024-03-01"), ProductName = "Product A", Quantity = 10, UnitPrice = 50.00m },
                new SalesModel { Date = DateTime.Parse("2024-03-02"), ProductName = "Product B", Quantity = 15, UnitPrice = 40.00m },
                new SalesModel { Date = DateTime.Parse("2024-03-03"), ProductName = "Product C", Quantity = 20, UnitPrice = 30.00m }
                // Add more data as needed
            };
        }
        public IActionResult Sales()
        {
        // Renders the data in Sales view
            return View(salesData);
        }
    }
}

Imports ReportGenerator.Models
Namespace ReportGenerator.Controllers
	Public Class SalesController
		Inherits Controller

		Private ReadOnly _viewRenderService As IRazorViewRenderer
		Private ReadOnly salesData As List(Of SalesModel)
		Public Sub New(ByVal viewRenderService As IRazorViewRenderer)
			_viewRenderService = viewRenderService
			' Example data with sales information
			salesData = New List(Of SalesModel) From {
				New SalesModel With {
					.Date = DateTime.Parse("2024-03-01"),
					.ProductName = "Product A",
					.Quantity = 10,
					.UnitPrice = 50.00D
				},
				New SalesModel With {
					.Date = DateTime.Parse("2024-03-02"),
					.ProductName = "Product B",
					.Quantity = 15,
					.UnitPrice = 40.00D
				},
				New SalesModel With {
					.Date = DateTime.Parse("2024-03-03"),
					.ProductName = "Product C",
					.Quantity = 20,
					.UnitPrice = 30.00D
				}
			}
		End Sub
		Public Function Sales() As IActionResult
		' Renders the data in Sales view
			Return View(salesData)
		End Function
	End Class
End Namespace

Dans le code ci-dessus, à l'intérieur du constructeur, le service IRazorViewRenderer est assigné au champ privé _viewRenderService. De plus, le contrôleur initialise une liste nommée salesData contenant des instances de la classe SalesModel, représentant des informations de ventes à des fins de démonstration.

La méthode d'action Sales() retourne une vue nommée "Sales", en passant la liste salesData comme modèle. Cette action est responsable du rendu des données de vente dans la vue associée, ce qui permet aux utilisateurs de visualiser les informations de vente dans un format tabulaire ou dans toute autre disposition souhaitée.

Étape 4 : Générer un rapport PDF

Dans l'action GeneratePdf du contrôleur, utilisez le ChromePdfRenderer d'IronPDF pour rendre le document de rapport Razor view to a PDF. Définir les en-têtes de réponse appropriés et renvoyer le fichier PDF au client.

public FileContentResult GeneratePdf()
{
    License.LicenseKey = "YOUR-LICENSE-KEY-HERE";
    ChromePdfRenderer renderer = new ChromePdfRenderer();
    // Render View to PDF document
    PdfDocument pdf = renderer.RenderRazorViewToPdf(_viewRenderService, "Views/Sales/Sales.cshtml", salesData);
    Response.Headers.Append("Content-Disposition", "inline");
    // Output PDF document
    return File(pdf.BinaryData, "application/pdf", "SalesReport.pdf");
}

public FileContentResult GeneratePdf()
{
    License.LicenseKey = "YOUR-LICENSE-KEY-HERE";
    ChromePdfRenderer renderer = new ChromePdfRenderer();
    // Render View to PDF document
    PdfDocument pdf = renderer.RenderRazorViewToPdf(_viewRenderService, "Views/Sales/Sales.cshtml", salesData);
    Response.Headers.Append("Content-Disposition", "inline");
    // Output PDF document
    return File(pdf.BinaryData, "application/pdf", "SalesReport.pdf");
}

Public Function GeneratePdf() As FileContentResult
	License.LicenseKey = "YOUR-LICENSE-KEY-HERE"
	Dim renderer As New ChromePdfRenderer()
	' Render View to PDF document
	Dim pdf As PdfDocument = renderer.RenderRazorViewToPdf(_viewRenderService, "Views/Sales/Sales.cshtml", salesData)
	Response.Headers.Append("Content-Disposition", "inline")
	' Output PDF document
	Return File(pdf.BinaryData, "application/pdf", "SalesReport.pdf")
End Function

Comprenons en détail le fonctionnement du code ci-dessus :

1. Configuration de la clé de licence :

   • License.LicenseKey = "VOTRE-CLÉ-DE-LICENCE-ICI";

   • Cette ligne définit la clé de licence requise pour IronPDF. Il est essentiel pour utiliser les fonctionnalités d'IronPDF dans l'application.

2. Initialisation du moteur de rendu :

   • ChromePdfRenderer renderer = new ChromePdfRenderer();

   • Une instance de ChromePdfRenderer est créée. Ce moteur de rendu est responsable de la conversion des vues Razor au format PDF à l'aide du moteur de navigation Chromium.

3. Rendu de la vue au format PDF :

   • PdfDocument PDF = renderer.RenderRazorViewToPdf(_viewRenderService, "Views/Sales/Sales.cshtml", salesData);

   • La méthode RenderRazorViewToPdf() de ChromePdfRenderer est invoquée pour rendre la vue Razor spécifiée (Views/Sales/Sales.cshtml) en un document PDF. La variable salesData sert de modèle pour la vue.

4. En-tête Content-Disposition :

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

   • L'en-tête de réponse HTTP Content-Disposition est défini sur "inline". Cela indique au navigateur d'afficher le contenu du PDF directement pour visualiser les rapports dans la fenêtre ou l'onglet du navigateur lorsqu'il est ouvert.

5. Retour du fichier PDF :

   • return File(pdf.BinaryData, "application/pdf", "SalesReport.pdf");

   • Le contenu du document PDF est renvoyé sous forme de FileContentResult. Il inclut les données binaires du PDF (pdf.BinaryData), spécifie le type MIME comme "application/pdf" et suggère le nom de fichier comme "SalesReport.pdf".

   Dans l'ensemble, cette méthode orchestre efficacement le processus de génération d'un rapport PDF à partir d'une vue Razor, ce qui la rend adaptée à l'intégration dans l'application ASP.NET pour améliorer les capacités de création de rapports.

   

   Pour des informations détaillées sur la façon dont IronPDF facilite le processus de génération de rapports PDF et d'autres tâches liées aux PDF, veuillez visiter la page de documentation.

Conclusion

Dans cet article, nous avons exploré comment IronPDF simplifie le processus de génération de rapports PDF dans les applications ASP.NET. En suivant le guide étape par étape fourni ci-dessus, vous pouvez rapidement intégrer IronPDF dans vos projets ASP.NET et générer facilement des rapports PDF dynamiques.

Grâce à son riche ensemble de fonctionnalités et à son intégration transparente, IronPDF permet aux développeurs de créer des rapports de qualité professionnelle qui répondent aux besoins de leurs utilisateurs et de leurs entreprises.

IronPDF propose un essai gratuit. Téléchargez la bibliothèque depuis ici et essayez-la.