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 à l'aide du contrôle Web Forms Report Viewer. 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. Instanciation de l'objet ChromePdfRenderer sender

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

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

6. Créer 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 de HTML en PDF : Convertissez facilement le contenu HTML, y compris les styles CSS, en documents PDF de haute qualité.
• Édition PDF : Modifiez des documents PDF existants en ajoutant ou en supprimant du texte, des images et des annotations.
• Remplissage de formulaires PDF : Remplir dynamiquement des formulaires PDF avec des données provenant de votre application web.
• Génération de codes-barres : Générez des codes-barres et des codes QR dans les 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 les documents de marque.
• Cryptage et sécurité : Sécurisez les documents PDF grâce au cryptage, aux mots de passe et aux paramètres d'autorisation.

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. Recherchez "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

Créez d'abord une classe de modèle(SalesModel.cs) pour représenter les données de vente. 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

Créez ensuite 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 élément de menu dans le fichier _Layout.cshtml qui se trouve dans le dossier Views->Shared pour créer une vue de l'assistant 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>

'INSTANT VB TODO TASK: The following line uses invalid syntax:
'<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

Mettre en place un contrôleur(SalesController.cs) avec des actions pour afficher la vue des ventes et générer le rapport PDF. Injecter 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, dans le constructeur, le service IRazorViewRenderer est assigné au champ privé _viewRenderService. En outre, le contrôleur initialise une liste nommée salesData contenant des instances de la classe SalesModel, représentant des informations sur les ventes à des fins de démonstration.

Les ventes() La méthode d'action renvoie 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 effectuer le rendu du fichierVue rasoir vers un PDF Document de rapport. 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. License Key Setup:

   • License.LicenseKey = "YOUR-LICENSE-KEY-HERE";

   • 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. Renderer Initialization:

   • ChromePdfRenderer renderer = nouveau 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 fonction RenderRazorViewToPdf() La méthode de ChromePdfRenderer est invoquée pour rendre la vue Razor spécifiée(Views/Sales/Sales.cshtml) vers un document PDF. La variable salesData sert de modèle à la vue.

4. Content-Disposition Header:

   • 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. Fichier PDF de retour:

   • retour Fichier(pdf.BinaryData, "application/pdf", "SalesReport.pdf");

   • Le contenu du document PDF est renvoyé sous la forme d'un FileContentResult. Il comprend les données binaires du PDF(pdf.BinaryData)spécifie le type MIME comme "application/pdf ", et propose le nom de fichier "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 obtenir des informations détaillées sur la manière dont IronPDF facilite le processus de génération de rapports PDF et d'autres tâches liées aux PDF, veuillez consulter la pagedocumentation page.

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 offre un service deessai gratuit. Télécharger la bibliothèque à partir deici et l'essayer.