ASP.NET -Export nach Excel: Vergleich von IronXL , ClosedXML und EPPlus

Was sind die gängigen Methoden zum Exportieren von Daten nach Excel in ASP.NET Core?

ASP.NET Core-Entwickler haben mehrere Möglichkeiten, wenn es darum geht, Excel-Exportfunktionen hinzuzufügen. Jeder Ansatz unterscheidet sich in der Qualität der Ausgabedatei, dem erforderlichen Implementierungsaufwand und den Lizenzierungsimplikationen für kommerzielle Projekte.

Traditionelles MIME-Typ-Streaming ist die älteste Technik. Der Server setzt den Content-Type-Header der Antwort auf application/vnd.ms-excel und schreibt eine HTML-Tabelle in den Ausgabestream. Der Browser interpretiert dies als Excel-Download, aber die Datei enthält HTML-Code statt echter Tabellendaten. Microsoft Excel erkennt die Diskrepanz und zeigt eine Formatwarnung an, bevor die Datei geöffnet wird. Diese Methode unterstützt weder Formeln noch getypte Spalten oder eine ordnungsgemäße Zellformatierung.

Bibliotheksbasierte Lösungen fügen ein NuGet-Paket hinzu, das echte XLSX-Dateien im von Microsoft definierten Open XML-Format erstellt. Optionen umfassen IronXL, ClosedXML und EPPlus. Alle drei erzeugen gültige Excel-Dateien, die ohne Warnungen geöffnet werden, unterstützen Zellformatierungen und funktionieren mit .NET Core. Die offizielle .NET-Dokumentation für Dateidownloads behandelt die ASP.NET Core-Mechanismen, die von all diesen Ansätzen genutzt werden.

Die folgende Tabelle fasst die wichtigsten Unterschiede zusammen:

Wie installiert man IronXL in einem ASP.NET Core-Projekt?

Bevor Sie Exportcode schreiben, fügen Sie IronXL über den NuGet-Paket-Manager oder die .NET CLI zu Ihrem Projekt hinzu. IronXL hat keine Abhängigkeit von Microsoft Office oder COM-Interop, daher ist die Installation auf jedem von .NET unterstützten Betriebssystem unkompliziert.

dotnet add package IronXl.Excel

dotnet add package IronXl.Excel

Alternativ verwenden Sie die Paket-Manager-Konsole in Visual Studio:

Install-Package IronXl.Excel

Install-Package IronXl.Excel

Sobald das Paket installiert ist, fügen Sie using IronXL; zu jeder Controller- oder Dienstklasse hinzu, die Excel-Dateien erzeugen muss. Für grundlegende Exportszenarien ist keine zusätzliche Konfiguration erforderlich. Für Lizenzierungs- und Bereitstellungsoptionen besuchen Sie die IronXL-Lizenzseite.

Wie funktioniert der traditionelle GridView-Exportansatz?

In älteren WebForms und einigen älteren MVC-Mustern haben Entwickler GridView-Daten exportiert, indem sie als HTML gerendert wurden und mit einem irreführenden Content-Type-Header an den Browser gestreamt wurden. Die Anwendung ruft Response.AddHeader auf, um den Dateinamen festzulegen und schreibt die HTML-Ausgabe direkt.

// Traditional approach -- exports HTML disguised as Excel
public void ExportToExcel(object sender, EventArgs e)
{
    Response.Clear();
    Response.Buffer = true;
    Response.ContentType = "application/vnd.ms-excel";
    Response.AddHeader("content-disposition", "attachment;filename=Report.xls");
    StringWriter stringWriter = new StringWriter();
    HtmlTextWriter htmlTextWriter = new HtmlTextWriter(stringWriter);
    // Render grid content as HTML
    DataGrid1.RenderControl(htmlTextWriter);
    Response.Write(stringWriter.ToString());
    Response.End();
}

public override void VerifyRenderingInServerForm(Control control)
{
    // Required to prevent server form rendering errors
}

// Traditional approach -- exports HTML disguised as Excel
public void ExportToExcel(object sender, EventArgs e)
{
    Response.Clear();
    Response.Buffer = true;
    Response.ContentType = "application/vnd.ms-excel";
    Response.AddHeader("content-disposition", "attachment;filename=Report.xls");
    StringWriter stringWriter = new StringWriter();
    HtmlTextWriter htmlTextWriter = new HtmlTextWriter(stringWriter);
    // Render grid content as HTML
    DataGrid1.RenderControl(htmlTextWriter);
    Response.Write(stringWriter.ToString());
    Response.End();
}

public override void VerifyRenderingInServerForm(Control control)
{
    // Required to prevent server form rendering errors
}

Wie vereinfacht IronXL die Erstellung von Excel-Dateien in ASP.NET Core?

IronXL bietet eine API zur Erstellung echter XLSX-Dateien, ohne dass Microsoft Office oder COM-Interop erforderlich sind. Die Bibliothek erstellt Arbeitsobjekte vollständig im verwalteten Code, sodass sie auf Linux, macOS und Windows ohne zusätzliche Abhängigkeiten läuft.

Das folgende Beispiel erstellt ein Arbeitsbuch, füllt ein Arbeitsblatt mit Verkaufsdaten, wendet eine fette Formatierung auf die Kopfzeile an und überträgt die Datei an den Browser:

using IronXL;
using Microsoft.AspNetCore.Mvc;

public class ExportController : Controller
{
    [HttpPost]
    public IActionResult ExportReport()
    {
        // Create workbook and worksheet
        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet worksheet = workbook.CreateWorkSheet("Sales Data");

        // Add header row
        worksheet["A1"].Value = "Product";
        worksheet["B1"].Value = "Quantity";
        worksheet["C1"].Value = "Revenue";

        // Populate data rows
        worksheet["A2"].Value = "Widget A";
        worksheet["B2"].Value = 150;
        worksheet["C2"].Value = 4500.00;
        worksheet["A3"].Value = "Widget B";
        worksheet["B3"].Value = 230;
        worksheet["C3"].Value = 6900.00;

        // Apply bold formatting to headers
        var headerRange = worksheet["A1:C1"];
        headerRange.Style.Font.Bold = true;

        // Stream file to browser
        byte[] fileBytes = workbook.ToByteArray();
        string filename = $"SalesReport_{DateTime.Neinw:yyyyMMdd}.xlsx";
        return File(fileBytes,
            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            filename);
    }
}

using IronXL;
using Microsoft.AspNetCore.Mvc;

public class ExportController : Controller
{
    [HttpPost]
    public IActionResult ExportReport()
    {
        // Create workbook and worksheet
        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet worksheet = workbook.CreateWorkSheet("Sales Data");

        // Add header row
        worksheet["A1"].Value = "Product";
        worksheet["B1"].Value = "Quantity";
        worksheet["C1"].Value = "Revenue";

        // Populate data rows
        worksheet["A2"].Value = "Widget A";
        worksheet["B2"].Value = 150;
        worksheet["C2"].Value = 4500.00;
        worksheet["A3"].Value = "Widget B";
        worksheet["B3"].Value = 230;
        worksheet["C3"].Value = 6900.00;

        // Apply bold formatting to headers
        var headerRange = worksheet["A1:C1"];
        headerRange.Style.Font.Bold = true;

        // Stream file to browser
        byte[] fileBytes = workbook.ToByteArray();
        string filename = $"SalesReport_{DateTime.Neinw:yyyyMMdd}.xlsx";
        return File(fileBytes,
            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            filename);
    }
}

// Export as CSV instead of XLSX
workbook.SaveAsCsv("output.csv");

// Export as CSV instead of XLSX
workbook.SaveAsCsv("output.csv");

Wie handhabt IronXL die Integration von DataTable und Datenbanken?

Viele ASP.NET Core-Anwendungen holen Daten aus SQL Server oder einer anderen relationalen Datenbank, bevor sie diese exportieren. IronXL bietet erstklassige Unterstützung zum Laden eines DataTable direkt in ein Arbeitsblatt, was die manuelle Zeileniteration überflüssig macht.

Das untenstehende Beispiel fragt eine Datenbank mit ADO.NET ab und füllt ein Excel-Arbeitsblatt mit dem resultierenden DataTable:

using IronXL;
using System.Data;
using System.Data.SqlClient;
using Microsoft.AspNetCore.Mvc;

public class ReportController : Controller
{
    private readonly string _connectionString;

    public ReportController(IConfiguration config)
    {
        _connectionString = config.GetConnectionString("DefaultConnection");
    }

    [HttpGet]
    public IActionResult DownloadReport()
    {
        DataTable table = new DataTable();

        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            string query = "SELECT OrderId, CustomerName, Total, OrderDate FROM Orders";
            using SqlDataAdapter adapter = new SqlDataAdapter(query, connection);
            adapter.Fill(table);
        }

        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet worksheet = workbook.CreateWorkSheet("Orders");

        // Write column headers from DataTable schema
        for (int col = 0; col < table.Columns.Count; col++)
        {
            worksheet[0, col].Value = table.Columns[col].ColumnName;
        }

        // Write data rows
        for (int row = 0; row < table.Rows.Count; row++)
        {
            for (int col = 0; col < table.Columns.Count; col++)
            {
                worksheet[row + 1, col].Value = table.Rows[row][col].ToString();
            }
        }

        byte[] fileBytes = workbook.ToByteArray();
        return File(fileBytes,
            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            "Orders.xlsx");
    }
}

using IronXL;
using System.Data;
using System.Data.SqlClient;
using Microsoft.AspNetCore.Mvc;

public class ReportController : Controller
{
    private readonly string _connectionString;

    public ReportController(IConfiguration config)
    {
        _connectionString = config.GetConnectionString("DefaultConnection");
    }

    [HttpGet]
    public IActionResult DownloadReport()
    {
        DataTable table = new DataTable();

        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            string query = "SELECT OrderId, CustomerName, Total, OrderDate FROM Orders";
            using SqlDataAdapter adapter = new SqlDataAdapter(query, connection);
            adapter.Fill(table);
        }

        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet worksheet = workbook.CreateWorkSheet("Orders");

        // Write column headers from DataTable schema
        for (int col = 0; col < table.Columns.Count; col++)
        {
            worksheet[0, col].Value = table.Columns[col].ColumnName;
        }

        // Write data rows
        for (int row = 0; row < table.Rows.Count; row++)
        {
            for (int col = 0; col < table.Columns.Count; col++)
            {
                worksheet[row + 1, col].Value = table.Rows[row][col].ToString();
            }
        }

        byte[] fileBytes = workbook.ToByteArray();
        return File(fileBytes,
            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            "Orders.xlsx");
    }
}

Dieses Muster hält den Controller schlank und testbar. Die Datenbankabfrage und der Arbeitsbuchaufbau sind klar voneinander getrennt, was es einfach macht, die Datenquelle auszutauschen oder zusätzliche Arbeitsblätter für Zusammenfassungsdaten hinzuzufügen. Eine Anleitung zum Lesen vorhandener Excel-Dateien in ein DataTable finden Sie im IronXL-Leitfaden zum Lesen von Excel-Dateien.

Wie lassen sich ClosedXML und EPPlus vergleichen?

ClosedXML umschließt das Open XML SDK von Microsoft mit einer zugänglichen API. Installieren Sie es aus NuGet:

Install-Package ClosedXML

Install-Package ClosedXML

Das folgende Beispiel zeigt eine typische ClosedXML-Exportaktion:

using ClosedXML.Excel;
using Microsoft.AspNetCore.Mvc;

public class ExportController : Controller
{
    [HttpGet]
    public IActionResult ExportWithClosedXML()
    {
        using var workbook = new XLWorkbook();
        var worksheet = workbook.AddWorksheet("Data");
        worksheet.Cell(1, 1).Value = "Name";
        worksheet.Cell(1, 2).Value = "Amount";
        worksheet.Cell(2, 1).Value = "Alpha";
        worksheet.Cell(2, 2).Value = 1200;

        using var stream = new MemoryStream();
        workbook.SaveAs(stream);
        return File(stream.ToArray(),
            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            "export.xlsx");
    }
}

using ClosedXML.Excel;
using Microsoft.AspNetCore.Mvc;

public class ExportController : Controller
{
    [HttpGet]
    public IActionResult ExportWithClosedXML()
    {
        using var workbook = new XLWorkbook();
        var worksheet = workbook.AddWorksheet("Data");
        worksheet.Cell(1, 1).Value = "Name";
        worksheet.Cell(1, 2).Value = "Amount";
        worksheet.Cell(2, 1).Value = "Alpha";
        worksheet.Cell(2, 2).Value = 1200;

        using var stream = new MemoryStream();
        workbook.SaveAs(stream);
        return File(stream.ToArray(),
            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            "export.xlsx");
    }
}

Wie wählen Sie die richtige Bibliothek für Ihr Projekt aus?

Die Auswahl der richtigen Excel-Exportbibliothek hängt von drei Faktoren ab: den benötigten Ausgabeformaten, den Lizenzierungsbeschränkungen Ihres Projekts und der Neintwendigkeit professioneller Unterstützung.

Wählen Sie IronXL, wenn Ihre Anwendung mehrachsige Ausgabe (XLSX, CSV, JSON, XML) benötigt, wenn Sie ein kommerzielles Produkt entwickeln, das einen garantierten Supportkanal erfordert, oder wenn Sie erweiterte Excel-Funktionen wie Formelauswertung, Zellstilisierung oder Diagrammerstellung benötigen. Die Dokumentation von IronXL behandelt jede API-Oberfläche im Detail, und das Support-Team antwortet Lizenzinhabern direkt. Lesen Sie den IronXL-Blog für zusätzliche Muster und Tutorials.

Wählen Sie ClosedXML, wenn Ihr Projekt Open Source oder nicht-kommerziell ist und nur XLSX-Ausgabe erfordert. Die MIT-Lizenz verhängt keine Beschränkungen bei der Weiterverbreitung, und die API ist gut dokumentiert über Community-Ressourcen.

Wählen Sie EPPlus, wenn ein bestehender Code-Stand bereits EPPlus verwendet und die Migration zu einer anderen Bibliothek teurer wäre als der Erwerb einer kommerziellen Lizenz.

Für Teams, die IronXL gegen seine Alternativen evaluieren, ermöglicht die IronXL-Testlizenz ein vollständiges Testen aller Funktionen vor dem Kauf. Zusätzliche Code-Beispiele zum Lesen und Schreiben von Excel-Dateien sind auf der IronXL-Beispielseite verfügbar.

Was sind Ihre nächsten Schritte?

Nun, da Sie die verfügbaren Excel-Exportansätze für ASP.NET Core überprüft haben, können Sie die folgenden Schritte unternehmen, um weiter voranzukommen:

• Installieren Sie IronXL mit dotnet add package IronXl.Excel und gehen Sie das Anleitung zum Einstieg durch, um Ihr erstes Arbeitsbuch zu erstellen.
• Vergleichen Sie Code-Muster, indem Sie die IronXL Beispielseite für Szenarien überprüfen, die Ihrem Anwendungsfall entsprechen, wie z.B. Datenbankexport, mehrblättrige Arbeitsbücher oder formatierte Berichte.
• Bewerten Sie die Lizenzierung, indem Sie die IronXL-Lizenzseite besuchen, um die Optionen für Entwicklung, Staging und Produktionsbereitstellungen zu verstehen.
• Erforschen Sie zusätzliche Formate, indem Sie die SaveAsCsv-, SaveAsJson- und SaveAsXml-Methoden testen, wenn Ihre Anwendung Daten in mehreren Formaten aus demselben Codebasis exportieren muss.
• Migrieren Sie von Legacy-Code, indem Sie vorhandene Response.ContentType = "application/vnd.ms-excel"-Muster in Ihrer Lösung identifizieren und sie durch IronXL-Arbeitsbuch-Erstellung ersetzen, um Formatwarnungen für Ihre Benutzer zu beseitigen.

Für Produktionsbereitstellungen kaufen Sie eine Lizenz, um professionellen Support zu freizuschalten und die Einhaltung der IronXL-Lizenzbedingungen sicherzustellen.

Starten Sie jetzt mit IronXL.

Jetzt kostenlos starten