Wie man einen Bericht in ASP .NET erstellt

Berichte sind für die Darstellung von Daten in einem strukturierten und visuell ansprechenden Format unerlässlich. Ob es sich um Verkaufsdaten, Analysen oder Finanzübersichten handelt, die Erstellung von Berichten ist eine häufige Anforderung in Webanwendungen. *Microsoft bietet rdlc-Berichtsdienste, die mit dem Web Forms Report Viewer Control in Webanwendungen integriert werden können. Das Verfahren ist jedoch oft komplex und zeitaufwändig.

An dieser Stelle kommt IronPDF ins Spiel. IronPDF ist eine vielseitige Bibliothek, die die Erstellung von PDF-Berichten in ASP.NET und anderen Web-Frameworks vereinfacht und dabei leistungsstarke Funktionen und einfache Bedienung bietet. In diesem Artikel erfahren Sie, wie Sie mit IronPDF einen Bericht in ASP.NET erstellen können.

Wie man in ASP.NET einen Bericht erstellt

1. Erstellen einer ASP.NET-Webanwendung mit Visual Studio

2. Installieren Sie IronPDF und IronPDF.Extensions.MVC.Core

3. Objekt ChromePdfRenderer instanziieren Sender

4. Rufen Sie die Methode RenderRazorViewToPdf auf, um die Ansicht in PDF zu konvertieren

5. Hinzufügen von "Content-Disposition" mit Response.Headers.Append

6. Erstellen eines Berichts mit der Methode File mit PDF.BinaryData

Einführung in IronPDF

IronPDF ist eine vielseitige Bibliothek, die die Erzeugung von PDF-Dokumenten in ASP.NET und anderen Web-Frameworks vereinfacht. Die umfangreichen Funktionen und intuitiven APIs machen es zur idealen Wahl für Entwickler, die dynamische Berichte, Rechnungen, Quittungen und vieles mehr direkt aus ihren Webanwendungen erstellen möchten. Mit IronPDF können Entwickler mühelos HTML-, CSS- und sogar Razor-Ansichten in qualitativ hochwertige PDF-Dokumente umwandeln und so eine nahtlose Integration von Berichtsfunktionen in ihre ASP.NET-Projekte ermöglichen.

Merkmale von IronPDF

• HTML-zu-PDF-Konvertierung: Konvertieren Sie HTML-Inhalte, einschließlich CSS-Stile, in hochwertige PDF-Dokumente.
• PDF-Bearbeitung: Ändern Sie vorhandene PDF-Dokumente, indem Sie Text, Bilder und Anmerkungen hinzufügen oder entfernen.
• PDF-Formularausfüllung: Füllen Sie PDF-Formulare dynamisch mit Daten aus Ihrer Webanwendung.
• Barcode-Erzeugung: Generieren Sie Barcodes und QR-Codes in PDF-Dokumenten für Produktetiketten oder die Bestandsverfolgung.
• Wasserzeichen: Fügen Sie Wasserzeichen zu PDF-Seiten hinzu, um sensible Informationen oder Markendokumente zu schützen.
• Verschlüsselung und Sicherheit: Sichern Sie PDF-Dokumente mit Verschlüsselung, Passwörtern und Berechtigungseinstellungen.

Voraussetzungen

Bevor wir beginnen, sollten Sie sicherstellen, dass Sie die folgenden Voraussetzungen erfüllen:

• Grundkenntnisse in der ASP.NET-Entwicklung.
• Visual Studio auf Ihrem Rechner installiert ist.
• IronPDF und IronPDF.Extensions.Mvc.Core

Schritte zum Erstellen eines ASP.NET-Projekts in Visual Studio

1. Öffnen Sie Visual Studio und erstellen Sie ein neues ASP.NET Core-Projekt.

2. Wählen Sie die gewünschte Projektvorlage (z.B. MVC oder Razor Pages).

   

3. Konfigurieren Sie Projekteinstellungen wie Projektname, Speicherort und Framework-Version.

   

4. Klicken Sie auf "Erstellen", um die Projektstruktur zu erstellen.

Installation von IronPDF und IronPDF.Extensions.Mvc.Core

Als nächstes installieren wir IronPDF und sein MVC-Erweiterungspaket mit dem NuGet Package Manager:

1. Öffnen Sie den NuGet Package Manager für Lösungen, indem Sie mit der rechten Maustaste auf den Solution Explorer klicken.

2. Suchen Sie nach "IronPDF" und "IronPDF.Extensions.Mvc.Core".

   

3. Installieren Sie beide Pakete in Ihre Lösung.

Schritte zum Erstellen von Report Viewer in ASP.NET Web Application

Lassen Sie uns nun in die Schritte eintauchen, um einen PDF-Bericht mit IronPDF in unserem ASP.NET-Projekt zu erstellen. Bevor wir eine Ansicht in einen Bericht umwandeln, benötigen wir ein Modell, eine Ansicht und einen Controller, um eine Datenquelle für die Erstellung und das Herunterladen eines neuen Berichts im PDF-Format zu erstellen.

Schritt 1: Definieren einer Modellklasse

Erstellen Sie zunächst eine Modellklasse (SalesModel.cs) um die Verkaufsdaten darzustellen. Diese Beispielklasse SalesModel enthält Eigenschaften wie Date, ProductName, Quantity, UnitPrice und TotalAmount. Dies ist nützlich, wenn Informationen aus einer Datenquelle wie Microsoft SQL Server oder MySQL Server abgerufen werden.

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

Schritt 2: Erstellen Sie eine neue Webformularansicht

Als nächstes erstellen Sie eine Razor-Ansicht (Sales.cshtml) um die Verkaufsdaten in einem tabellarischen Format anzuzeigen und eine Schaltfläche zur Erstellung des PDF-Berichts bereitzustellen.

<!-- 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>

Fügen Sie nun in der Datei _Layout.cshtml, die sich im Ordner Ansichten->Gemeinsam befindet, den Punkt Verkäufe als Menüpunkt hinzu, um eine Ansicht des Berichtsassistenten zu erstellen:

<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>

Schritt 3: Registrierung des View Render Service

Die Aufnahme der Registrierung des View-Rendering-Dienstes in die Datei Program.cs ist entscheidend für die korrekte Funktion der Dependency Injection. Fügen Sie den folgenden Code in die Datei Program.cs ein, um den Dienst IRazorViewRenderer zu registrieren:

// 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)()

Schritt 3: Web-API-Controller-Klasse implementieren

Implementierung eines Controllers (SalesController.cs) mit Aktionen zur Darstellung der Verkaufsansicht und zur Erstellung des PDF-Berichts. Injizieren Sie den von IronPDF bereitgestellten Dienst IRazorViewRenderer in den Konstruktor des Controllers.

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

Im obigen Code wird innerhalb des Konstruktors der Dienst IRazorViewRenderer dem privaten Feld _viewRenderService zugewiesen. Außerdem initialisiert der Controller eine Liste mit dem Namen salesData, die Instanzen der Klasse SalesModel enthält, die Verkaufsinformationen zu Demonstrationszwecken darstellen.

Der Verkauf() Die Aktionsmethode gibt eine Ansicht mit dem Namen "Sales" zurück und übergibt die Liste salesData als Modell. Diese Aktion ist für die Darstellung der Verkaufsdaten in der zugehörigen Ansicht verantwortlich, so dass die Benutzer die Verkaufsinformationen in einem Tabellenformat oder einem anderen gewünschten Layout anzeigen können.

Schritt 4: PDF-Bericht generieren

Verwenden Sie in der Aktion GeneratePdf des Controllers den ChromePdfRenderer von IronPDF, um die Razor-Ansicht zu einer PDF-Datei Berichtsdokument. Setzen Sie die entsprechenden Antwort-Header und geben Sie die PDF-Datei an den Client zurück.

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

Lassen Sie uns die Funktionsweise des obigen Codes im Detail verstehen:

1. Lizenzschlüssel-Setup:

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

   • In dieser Zeile wird der für IronPDF erforderliche Lizenzschlüssel festgelegt. Sie ist für die Nutzung der IronPDF-Funktionen innerhalb der Anwendung unerlässlich.

2. Renderer-Initialisierung:

   * **ChromePdfRenderer renderer = new ChromePdfRenderer();**

   • Eine Instanz von ChromePdfRenderer wird erstellt. Dieser Renderer ist für die Umwandlung von Razor-Ansichten in das PDF-Format unter Verwendung der Chromium-Browser-Engine zuständig.

3. Ansicht in PDF rendern:

   * **PdfDocument PDF = renderer.RenderRazorViewToPdf(_viewRenderService, "Ansichten/Verkauf/Verkauf.cshtml", salesData);**

   • Die Funktion RenderRazorViewToPdf() Methode von ChromePdfRenderer wird aufgerufen, um die angegebene Razor-Ansicht zu rendern (Views/Verkauf/Verkauf.cshtml) in ein PDF-Dokument. Die Variable salesData dient als Modell für die Ansicht.

4. Content-Disposition Header:

   * **Response.Headers.Append("Inhalt-Disposition", "inline");**

   • Der HTTP-Antwort-Header Content-Disposition ist auf "inline " gesetzt. Dies weist den Browser an, den PDF-Inhalt direkt anzuzeigen, um Berichte innerhalb des Browserfensters oder der Registerkarte anzuzeigen, wenn diese geöffnet werden.

5. Rückkehrende PDF-Datei:

   • Rückgabe Datei(pdf.BinaryData, "application/pdf", "SalesReport.pdf");

   • Der Inhalt des PDF-Dokuments wird als FileContentResult zurückgegeben. Sie enthält die Binärdaten der PDF-Datei (pdf.BinaryData)an, gibt als MIME-Typ "application/pdf " an und schlägt als Dateinamen "SalesReport.pdf " vor.

   Insgesamt wird mit dieser Methode der Prozess der Erstellung eines PDF-Berichts aus einer Razor-Ansicht effizient orchestriert, so dass sie sich für die Integration in eine ASP.NET-Anwendung eignet, um die Berichtsfunktionen zu verbessern.

   

   Ausführliche Informationen darüber, wie IronPDF die Erstellung von PDF-Berichten und andere PDF-bezogene Aufgaben vereinfacht, finden Sie auf der Website Dokumentation seite.

Schlussfolgerung

In diesem Artikel haben wir uns angesehen, wie IronPDF den Prozess der Erstellung von PDF-Berichten in ASP.NET-Anwendungen vereinfacht. Wenn Sie die oben beschriebene Schritt-für-Schritt-Anleitung befolgen, können Sie IronPDF schnell in Ihre ASP.NET-Projekte integrieren und mit Leichtigkeit dynamische PDF-Berichte erstellen.

Mit seinem umfangreichen Funktionsumfang und der nahtlosen Integration ermöglicht IronPDF Entwicklern die Erstellung von Berichten in professioneller Qualität, die den Anforderungen ihrer Benutzer und Unternehmen entsprechen.

IronPDF bietet eine kostenlos testen. Laden Sie die Bibliothek herunter von *hier und probieren Sie es aus.