Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronPDF
  2. IronPDF Blog
  3. IronPDF nutzen
  4. report-asp-net-csharp
IRONPDF NUTZEN

Wie man einen Bericht in ASP .NET erstellt

Curtis Chau
Curtis Chau
Aktualisiert:

Berichte sind unerlässlich, um Daten in einem strukturierten und ansprechend gestalteten Format zu präsentieren. Ob Verkaufsdaten, Analysen oder Finanzzusammenfassungen: Die Erstellung von Berichten ist eine gängige Anforderung in Webanwendungen. Microsoft bietet RDLC-Berichtsdienste, die mithilfe der Web Forms Report Viewer Control in Webanwendungen integriert werden können. Allerdings kann der Prozess oft komplex und zeitaufwändig sein.

Hier kommt IronPDF ins Spiel. IronPDF ist eine vielseitige Bibliothek, die die Erstellung von PDF-Berichten in ASP.NET und anderen Web-Frameworks vereinfacht, leistungsstarke Funktionen bietet und benutzerfreundlich ist. In diesem Artikel werden wir untersuchen, wie man einen Bericht in ASP.NET mit IronPDF erstellt.

Wie man einen Bericht in ASP.NET erstellt

  1. Erstellen Sie eine ASP.NET-Webanwendung mit Visual Studio
  2. Installieren Sie IronPDF und IronPDF.Extensions.MVC.Core
  3. Instanziieren Sie das ChromePdfRenderer-Objekt
  4. Rufen Sie die RenderRazorViewToPdf-Methode auf, um die Ansicht in PDF zu konvertieren
  5. Fügen Sie "Content-Disposition" mithilfe von Response.Headers.Append hinzu
  6. Erstellen Sie einen Bericht mithilfe 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. Sein reichhaltiges Funktionsset und seine intuitiven APIs machen es zur idealen Wahl für Entwickler, die dynamische Berichte, Rechnungen, Quittungen und mehr direkt aus ihren Webanwendungen generieren möchten. Mit IronPDF können Entwickler problemlos HTML, CSS und sogar Razor-Ansichten in hochwertige PDF-Dokumente konvertieren und somit eine nahtlose Integration der Berichterstellungsfunktion in ihre ASP.NET-Projekte ermöglichen.

Funktionen von IronPDF

  • HTML-zu-PDF-Konvertierung: Konvertieren Sie HTML-Inhalte, einschließlich CSS-Stile, mühelos in hochwertige PDF-Dokumente.
  • PDF-Bearbeitung: Bearbeiten 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 aus.
  • Barcode-Generierung: Generieren Sie Barcodes und QR-Codes innerhalb von PDF-Dokumenten für Produktetiketten oder Bestandsverfolgung.
  • Wasserzeichen: Fügen Sie Wasserzeichen zu PDF-Seiten hinzu, um vertrauliche Informationen zu schützen oder Dokumente zu kennzeichnen.
  • Verschlüsselung und Sicherheit: Sichern Sie PDF-Dokumente mit Verschlüsselung, Passwörtern und Berechtigungseinstellungen.

Voraussetzungen

Bevor wir beginnen, stellen Sie sicher, dass Sie die folgenden Voraussetzungen haben:

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

Schritte zur Erstellung 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 Projektschablone aus (z. B. MVC oder Razor Pages).

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

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

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

  1. Klicken Sie auf "Erstellen", um die Projektstruktur zu generieren.

IronPDF und IronPDF.Extensions.Mvc.Core installieren

Als Nächstes installieren wir IronPDF und das zugehörige MVC-Erweiterungspaket über den NuGet-Paket-Manager:

  1. Öffnen Sie den NuGet-Paket-Manager für Lösungen, indem Sie mit der rechten Maustaste auf den Lösungs-Explorer klicken.
  2. Suchen Sie nach "IronPDF" und "IronPDF.Extensions.Mvc.Core".

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

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

Schritte zur Erstellung eines Berichtsanzeige in einer ASP.NET-Webanwendung

Jetzt tauchen wir in die Schritte ein, um mit IronPDF in unserem ASP.NET-Projekt einen PDF-Bericht zu erstellen. Bevor wir eine Ansicht in einen Bericht konvertieren, benötigen wir ein Modell, eine Ansicht und einen Controller, um eine Datenquelle zum Erstellen und Herunterladen eines neuen Berichts im PDF-Format zu erstellen.

Schritt 1: Definieren Sie eine Modellklasse

Erstellen Sie zuerst eine Modellklasse (SalesModel.cs), um die Verkaufsdaten darzustellen. Diese Beispielklasse SalesModel wird Eigenschaften wie Datum, Produktname, Menge, Stückpreis und Gesamtbetrag enthalten. 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 Webform-Ansicht

Erstellen Sie als Nächstes eine Razor-Ansicht (Sales.cshtml), um die Verkaufsdaten in tabellarischer Form anzuzeigen und eine Schaltfläche zum Generieren des PDF-Berichts bereitzustellen.

<!-- Sales.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>
<!-- Sales.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 die Sales als Menüpunkt in der Datei _Layout.cshtml im Ordner Ansichten->Gemeinsam genutzt hinzu, um eine Berichtsassistentenansicht zu erstellen:

<!— Layout.cshtml —>
<li class="nav-item">
    <a class="nav-link text-dark" asp-area="" asp-controller="Sales" asp-action="Sales">Sales</a>
</li>
<!— Layout.cshtml —>
<li class="nav-item">
    <a class="nav-link text-dark" asp-area="" asp-controller="Sales" asp-action="Sales">Sales</a>
</li>
HTML

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

Schritt 3: Registrierung des Ansichtsrenderservices

Die Registrierung des Ansichtsrenderservices in der Program.cs-Datei ist entscheidend dafür, dass die Abhängigkeitsinjektion ordnungsgemäß funktioniert. Fügen Sie den folgenden Code in die Program.cs-Datei ein, um den IRazorViewRenderer-Service 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 4: Implementierung der Web-API-Controller-Klasse

Implementieren Sie einen Controller (SalesController.cs) mit Aktionen zum Rendern der Verkaufsansicht und Generieren des PDF-Berichts. Injizieren Sie den von IronPDF bereitgestellten IRazorViewRenderer-Service 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 sales view with the sales data
            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 sales view with the sales data
            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 sales view with the sales data
			Return View(salesData)
		End Function
	End Class
End Namespace
$vbLabelText   $csharpLabel

Im obigen Code wird im Konstruktor der IRazorViewRenderer-Service dem privaten Feld _viewRenderService zugewiesen. Zusätzlich initialisiert der Controller eine Liste namens salesData, die Instanzen der Klasse SalesModel enthält und Verkaufsinformationen zu Demonstrationszwecken darstellt.

Die Methode Sales() gibt eine Ansicht namens "Sales" zurück und gibt die Liste salesData als Modell weiter. Diese Aktion ist dafür verantwortlich, die Verkaufsdaten in der zugehörigen Ansicht zu rendern, sodass Benutzer die Verkaufsinformationen in einem tabellarischen Format oder einem anderen gewünschten Layout visualisieren können.

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

Schritt 5: PDF-Bericht generieren

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

public FileContentResult GeneratePdf()
{
    // Set license key for IronPDF
    License.LicenseKey = "YOUR-LICENSE-KEY-HERE";

    // Initialize the ChromePdfRenderer
    ChromePdfRenderer renderer = new ChromePdfRenderer();

    // Render the Sales Razor view to a PDF document
    PdfDocument pdf = renderer.RenderRazorViewToPdf(_viewRenderService, "Views/Sales/Sales.cshtml", salesData);

    // Set HTTP response header to display the PDF inline
    Response.Headers.Append("Content-Disposition", "inline");

    // Return the PDF document as a FileContentResult
    return File(pdf.BinaryData, "application/pdf", "SalesReport.pdf");
}
public FileContentResult GeneratePdf()
{
    // Set license key for IronPDF
    License.LicenseKey = "YOUR-LICENSE-KEY-HERE";

    // Initialize the ChromePdfRenderer
    ChromePdfRenderer renderer = new ChromePdfRenderer();

    // Render the Sales Razor view to a PDF document
    PdfDocument pdf = renderer.RenderRazorViewToPdf(_viewRenderService, "Views/Sales/Sales.cshtml", salesData);

    // Set HTTP response header to display the PDF inline
    Response.Headers.Append("Content-Disposition", "inline");

    // Return the PDF document as a FileContentResult
    return File(pdf.BinaryData, "application/pdf", "SalesReport.pdf");
}
Public Function GeneratePdf() As FileContentResult
	' Set license key for IronPDF
	License.LicenseKey = "YOUR-LICENSE-KEY-HERE"

	' Initialize the ChromePdfRenderer
	Dim renderer As New ChromePdfRenderer()

	' Render the Sales Razor view to a PDF document
	Dim pdf As PdfDocument = renderer.RenderRazorViewToPdf(_viewRenderService, "Views/Sales/Sales.cshtml", salesData)

	' Set HTTP response header to display the PDF inline
	Response.Headers.Append("Content-Disposition", "inline")

	' Return the PDF document as a FileContentResult
	Return File(pdf.BinaryData, "application/pdf", "SalesReport.pdf")
End Function
$vbLabelText   $csharpLabel

Lassen Sie uns das oben genannte Code in Detail verstehen:

  1. Einrichtung des Lizenzschlüssels:
    • License.LicenseKey = "YOUR-LICENSE-KEY-HERE";
    • Diese Zeile legt den Lizenzschlüssel fest, der für IronPDF erforderlich ist. Es ist wichtig, um IronPDF-Funktionen innerhalb der Anwendung zu nutzen.
  2. Renderer-Initialisierung:
    • ChromePdfRenderer renderer = new ChromePdfRenderer();
    • Eine Instanz von ChromePdfRenderer wird erstellt. Dieser Renderer ist für die Konvertierung von Razor-Ansichten in das PDF-Format mithilfe der Chromium-Browser-Engine verantwortlich.
  3. Rendering der Ansicht in PDF:
    • PdfDocument PDF = renderer.RenderRazorViewToPdf(_viewRenderService, "Views/Sales/Sales.cshtml", salesData);
    • Die Methode RenderRazorViewToPdf() des ChromePdfRenderer wird aufgerufen, um die angegebene Razor-Ansicht (Views/Sales/Sales.cshtml) in ein PDF-Dokument zu rendern. Die Variable salesData dient als Modell für die Ansicht.
  4. Content-Disposition-Header:
    • Response.Headers.Append("Content-Disposition", "inline");
    • Der HTTP-Antwort-Header Content-Disposition wird auf "inline" gesetzt. Dies weist den Browser an, den PDF-Inhalt direkt anzuzeigen, um Berichte im Browserfenster oder -tab zu betrachten, wenn sie geöffnet werden.
  5. PDF-Datei zurückgeben:
    • return File(pdf.BinaryData, "application/pdf", "SalesReport.pdf");
    • Der PDF-Dokumenteninhalt wird als FileContentResult zurückgegeben. Es enthält die Binärdaten des PDFs (pdf.BinaryData), spezifiziert den MIME-Typ als "application/pdf" und schlägt den Dateinamen als "SalesReport.pdf" vor.

Insgesamt koordiniert diese Methode effizient den Prozess der Erstellung eines PDF-Berichts aus einer Razor-Ansicht, was sie zur geeigneten Integration in die ASP.NET-Anwendung zur Verbesserung der Berichterstellungsfunktionen macht.

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

Für detaillierte Informationen, wie IronPDF den Prozess der PDF-Berichtserstellung und andere PDF-bezogene Aufgaben erleichtert, besuchen Sie bitte die Dokumentations-Seite.

Abschluss

In diesem Artikel haben wir untersucht, wie IronPDF den Prozess der Erstellung von PDF-Berichten in ASP.NET-Anwendungen vereinfacht. Indem Sie der obigen Schritt-für-Schritt-Anleitung folgen, können Sie IronPDF schnell in Ihre ASP.NET-Projekte integrieren und dynamische PDF-Berichte mit Leichtigkeit erstellen.

Mit seinem reichhaltigen Funktionsspektrum und nahtloser Integration befähigt IronPDF Entwickler, Berichte in professioneller Qualität zu erstellen, die den Bedürfnissen ihrer Anwender und Unternehmen gerecht werden.

IronPDF bietet eine kostenlose Testversion an. Laden Sie die Bibliothek von hier herunter und probieren Sie sie aus.

Häufig gestellte Fragen

Wie kann ich einen PDF-Bericht in ASP.NET erstellen?

Sie können einen PDF-Bericht in ASP.NET erstellen, indem Sie IronPDF verwenden. Beginnen Sie mit der Einrichtung einer ASP.NET-Webanwendung in Visual Studio, dann installieren Sie IronPDF und seine MVC-Erweiterung. Verwenden Sie die ChromePdfRenderer-Klasse, um Razor-Ansichten in PDFs zu konvertieren, und verwenden Sie die File-Methode, um den Bericht zu erstellen.

Welche Vorteile hat die Verwendung einer PDF-Bibliothek für ASP.NET?

Die Verwendung einer PDF-Bibliothek wie IronPDF für ASP.NET vereinfacht den Prozess der Erstellung und Verwaltung von PDF-Berichten. Sie unterstützt die Umwandlung von HTML in PDF, das Bearbeiten von PDFs, das Ausfüllen von Formularen, die Barcode-Erstellung und die Dokumentensicherheit und macht sie damit vielseitig einsetzbar für verschiedene Webanwendungsbedürfnisse.

Wie konvertiere ich Razor-Ansichten in PDF in ASP.NET?

Um Razor-Ansichten in PDF in ASP.NET zu konvertieren, können Sie die ChromePdfRenderer.RenderRazorViewToPdf-Methode von IronPDF verwenden. Dies ermöglicht es Ihnen, die Erstellung von PDFs nahtlos in Ihre ASP.NET-Anwendungen zu integrieren.

Welche Funktionen bietet IronPDF für die PDF-Berichterstellung?

IronPDF bietet Funktionen wie die Umwandlung von HTML in PDF, das Bearbeiten von PDFs, das Ausfüllen von Formularen, die Barcode-Erstellung, das Hinzufügen von Wasserzeichen und die Verschlüsselung und Sicherheit von Dokumenten. Diese Funktionen erleichtern die Erstellung dynamischer und sicherer PDF-Berichte.

Wie kann ich PDF-Dokumente in ASP.NET sichern?

IronPDF bietet Verschlüsselungs- und Sicherheitsfunktionen, die es Entwicklern ermöglichen, PDF-Dokumente mit Verschlüsselung, Passwörtern und Berechtigungseinstellungen zu sichern. Dies stellt sicher, dass sensible Informationen in Ihren ASP.NET-Anwendungen geschützt bleiben.

Gibt es eine kostenlose Testversion für IronPDF?

Ja, IronPDF bietet eine kostenlose Testversion an. Sie können die Bibliothek von der IronPDF-Website herunterladen und ihre Funktionen zur Erstellung von professionellen PDF-Berichten in Ihren Anwendungen erkunden.

Wie füge ich ein Wasserzeichen zu einem PDF in einer ASP.NET-Anwendung hinzu?

Sie können ein Wasserzeichen zu einem PDF in einer ASP.NET-Anwendung mit IronPDF hinzufügen. Die Bibliothek bietet APIs zum Überlagern von Wasserzeichen auf PDF-Dokumente, sodass Sie sensible Informationen effektiv schützen oder Ihre Dokumente kennzeichnen können.

Was sind die Voraussetzungen für die Verwendung von IronPDF in meinem ASP.NET-Projekt?

Bevor Sie IronPDF verwenden, sollten Sie ein grundlegendes Verständnis der ASP.NET-Entwicklung haben und Visual Studio installiert haben. Darüber hinaus müssen Sie IronPDF und seine MVC-Erweiterung in Ihrem Projekt installieren, um seine Funktionen nutzen zu können.

Wo finde ich weitere Informationen zu IronPDF?

Für detailliertere Informationen zu IronPDF und seinen Fähigkeiten können Sie die Dokumentationsseite auf der IronPDF-Website besuchen. Die Dokumentation bietet Einblicke in die Einrichtung, Funktionen und Beispielcode.

Ist IronPDF mit .NET 10 kompatibel und welche Vorteile bietet das?

Ja, IronPDF unterstützt .NET 10 vollständig für Web-, Desktop- und Konsolenprojekte. Es nutzt die Laufzeit-Leistungsverbesserungen von .NET 10 (wie reduzierte Heap-Speicherbelegung und schnellere JIT-Kompilierung), die Verbesserungen der C#-Sprache und moderne APIs. Entwickler können Methoden wie RenderHtmlAsPdf und RenderHtmlAsPdfAsync nahtlos in .NET 10-Anwendungen verwenden und von höherer Ausgabegeschwindigkeit, plattformübergreifender Bereitstellung und saubererem Code profitieren.

Curtis Chau
Curtis Chau
  Jetzt mit dem Ingenieurteam chatten
Technischer Autor

Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender ...

Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Testversion