1. IronPDF
  2. IronPDF-Blog
  3. IronPDF verwenden
  4. bericht-asp-net-csharp
IRONPDF VERWENDEN

Wie man einen Bericht in ASP .NET erstellt

Chipego
Chipego Kalinda
3. April 2024
Teilen Sie:

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 an, die mithilfe des 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. Instanziieren Sie das ChromePdfRenderer-Objekt sender

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

  5. Fügen Sie "Content-Disposition" mit Response.Headers.Append hinzu

  6. Erstellen Sie einen Bericht mit der File-Methode mit PDF.BinaryData

Einführung in IronPDF

IronPDF ist eine vielseitige Bibliothek, die die Erstellung 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: HTML-Inhalte, einschließlich CSS-Stilen, mühelos in hochwertige PDF-Dokumente umwandeln.
  • PDF-Bearbeitung: Bestehende PDF-Dokumente durch Hinzufügen oder Entfernen von Text, Bildern und Anmerkungen bearbeiten.
  • PDF-Formularausfüllung: Füllen Sie PDF-Formulare dynamisch mit Daten aus Ihrer Webanwendung aus.
  • Barcode-Generierung: Erstellen Sie Barcodes und QR-Codes innerhalb von PDF-Dokumenten für Produktetiketten oder die Bestandsverfolgung.
  • Wasserzeichen: Fügen Sie Wasserzeichen zu PDF-Seiten hinzu, um vertrauliche Informationen zu schützen oder Dokumente zu brandmarken.
  • 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 ist auf Ihrem Computer installiert.
  • 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).

    Wie man einen Bericht in ASP .NET erstellt: Abbildung 1

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

    Erstellen eines Berichts in ASP .NET: Abbildung 2

  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. Suche nach "IronPDF" und "IronPDF.Extensions.Mvc.Core".

    Wie man einen Bericht in ASP .NET erstellt: Abbildung 3

  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 zuerst 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
$vbLabelText   $csharpLabel

Schritt 2: Erstellen Sie eine neue Webformularansicht

Erstellen Sie als Nächstes eine Razor-Ansicht (Sales.cshtml), um die Verkaufsdaten in tabellarischer Form anzuzeigen, und stellen Sie eine Schaltfläche bereit, um den PDF-Bericht zu erstellen.

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

Fügen Sie nun den Verkauf als Menüpunkt in der Datei _Layout.cshtml im Ordner Views->Shared hinzu, um eine Bericht-Assistenten-Ansicht zu erstellen:

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

Wie man einen Bericht in ASP .NET erstellt: Abbildung 4

Schritt 3: Registrierung des View Render Service

Die Registrierung des View-Render-Dienstes in der Datei Program.cs ist entscheidend, damit die Dependency Injection ordnungsgemäß funktioniert. Fügen Sie den folgenden Code zur Program.cs-Datei hinzu, um den IRazorViewRenderer-Dienst 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)()
$vbLabelText   $csharpLabel

Schritt 3: Web-API-Controller-Klasse implementieren

Implementieren Sie einen Controller (SalesController.cs) mit Aktionen, um die Verkaufsansicht darzustellen und den PDF-Bericht zu generieren. Injizieren Sie den IRazorViewRenderer-Dienst, der von IronPDF bereitgestellt wird, in den Controller-Konstruktor.

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
$vbLabelText   $csharpLabel

Im obigen Code wird im Konstruktor der Dienst IRazorViewRenderer dem privaten Feld _viewRenderService zugewiesen. Außerdem initialisiert der Controller eine Liste namens salesData, die Instanzen der SalesModel-Klasse enthält und Verkaufsinformationen für Demonstrationszwecke darstellt.

Die Sales()-Aktionsmethode gibt eine Ansicht mit dem Namen "Sales" zurück und übergibt die salesData-Liste 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.

Bericht in ASP .NET erstellen: Abbildung 5

Schritt 4: PDF-Bericht generieren

In der GeneratePdf-Aktion des Controllers verwenden Sie den ChromePdfRenderer von IronPDF, um das Razor-View in ein PDF-Berichtsdokument zu rendern. 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
$vbLabelText   $csharpLabel

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

  1. Lizenzschlüssel Einrichtung:

    • License.LicenseKey = "IHRE-LIZENZSCHLÜSSEL-HIER-EINSETZEN";

    • 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. Rendering von Ansichten zu PDF:

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

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

  4. Content-Disposition-Header:

    • Response.Headers.Append("Content-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ückgabe der PDF-Datei:

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

    • Der Inhalt des PDF-Dokuments wird als FileContentResult zurückgegeben. Es enthält die Binärdaten des PDF (pdf.BinaryData), gibt den MIME-Typ als "application/pdf" an und schlägt den 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.

    Wie man einen Bericht in ASP .NET erstellt: Abbildung 6

    Für detaillierte Informationen darüber, wie IronPDF den Prozess der PDF-Berichterstellung und andere PDF-bezogene Aufgaben vereinfacht, besuchen Sie bitte die Dokumentations-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 kostenlose Testversion an. Laden Sie die Bibliothek von hier herunter und probieren Sie sie aus.

Chipego
Chipego Kalinda
  Jetzt mit dem Ingenieurteam chatten
Software-Ingenieur
Chipego hat eine natürliche Fähigkeit zum Zuhören, die ihm hilft, Kundenprobleme zu verstehen und intelligente Lösungen anzubieten. Er trat dem Iron Software-Team 2023 bei, nachdem er einen Bachelor of Science in Informationstechnologie erworben hatte. IronPDF und IronOCR sind die beiden Produkte, auf die sich Chipego konzentriert hat, aber sein Wissen über alle Produkte wächst täglich, da er neue Wege findet, Kunden zu unterstützen. Er genießt die Zusammenarbeit bei Iron Software, da Teammitglieder aus dem gesamten Unternehmen ihre unterschiedlichen Erfahrungen einbringen und so zu effektiven, innovativen Lösungen beitragen. Wenn Chipego nicht an seinem Schreibtisch sitzt, kann man ihn oft bei einem guten Buch oder beim Fußballspielen antreffen.
< PREVIOUS
Erstellen von Berichtsanwendungen in C#
NÄCHSTES >
Wie man Daten aus PDF-Dokumenten auswertet

Ein Problem melden

Sind Sie bereit, loszulegen? Version: 2025.4 gerade veröffentlicht

Kostenloser Start
NuGet herunterladen DLL herunterladen Windows-Installationsprogramm Kostenlos testen
Lizenzen anzeigen >
Textlogo Iron Suite related to Wie man einen Bericht in ASP .NET erstellt

IronPDF ist ein Teil von IRONSUITE

10 .NET API-Produkte für Ihre Bürodokumente

Erhalten Sie 10 Produkte zum Preis von 2   Kostenlos testen