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 -Entwicklern stehen mehrere Wege offen, um die Excel-Exportfunktionalität zu implementieren. Die einzelnen Ansätze unterscheiden sich hinsichtlich der Qualität der Ausgabedatei, des Aufwands für die Umsetzung und der lizenzrechtlichen Auswirkungen bei kommerziellen Projekten.

Das traditionelle Streaming von MIME-Typen 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-Markup anstelle von echten Tabellendaten. Microsoft Excel erkennt die Formatabweichung und zeigt vor dem Öffnen der Datei eine Formatwarnung an. Diese Methode unterstützt keine Formeln, textbasierte Spalten oder korrekte Zellformatierungen.

Bibliotheksbasierte Lösungen fügen ein NuGet Paket hinzu, das unter Verwendung des von Microsoft definierten Open XML-Formats echte XLSX-Dateien erstellt. Zu den Optionen gehören IronXL, ClosedXML und EPPlus. Alle drei erzeugen gültige Excel-Dateien, die sich ohne Warnungen öffnen lassen, die Formatierung auf Zellenebene unterstützen und mit .NET Core funktionieren. Die offizielle .NET Dokumentation für Dateidownloads beschreibt die zugrunde liegenden ASP.NET Core Mechanismen, die von allen diesen Ansätzen verwendet 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 -Paketmanager oder die .NET -Befehlszeilenschnittstelle zu Ihrem Projekt hinzu. IronXL ist nicht von Microsoft Office oder COM-Interop abhängig, daher ist die Installation auf jedem von .NET unterstützten Betriebssystem unkompliziert.

dotnet add package IronXl.Excel

dotnet add package IronXl.Excel

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

Install-Package IronXl.Excel

Install-Package IronXl.Excel

Sobald das Paket installiert ist, fügen Sie using IronXL; zu jeder Controller- oder Serviceklasse hinzu, die Excel-Dateien generieren muss. Für einfache Exportszenarien ist keine zusätzliche Konfiguration erforderlich. Informationen zu Lizenzierungs- und Bereitstellungsoptionen finden Sie auf der IronXL -Lizenzierungsseite.

Wie funktioniert der traditionelle GridView-Exportansatz?

In älteren WebForms-Versionen und einigen älteren MVC-Architekturmustern exportierten Entwickler GridView-Daten, indem sie diese als HTML renderten und mit einem irreführenden Content-Type-Header an den Browser streamten. 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
}

' Traditional approach -- exports HTML disguised as Excel
Public Sub ExportToExcel(sender As Object, e As EventArgs)
    Response.Clear()
    Response.Buffer = True
    Response.ContentType = "application/vnd.ms-excel"
    Response.AddHeader("content-disposition", "attachment;filename=Report.xls")
    Dim stringWriter As New StringWriter()
    Dim htmlTextWriter As New HtmlTextWriter(stringWriter)
    ' Render grid content as HTML
    DataGrid1.RenderControl(htmlTextWriter)
    Response.Write(stringWriter.ToString())
    Response.End()
End Sub

Public Overrides Sub VerifyRenderingInServerForm(control As Control)
    ' Required to prevent server form rendering errors
End Sub

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

IronXL bietet eine API zur Erstellung von originalen XLSX-Dateien, ohne dass Microsoft Office oder COM-Interop erforderlich sind. Die Bibliothek erstellt Arbeitsmappenobjekte vollständig in verwaltetem Code und läuft daher ohne zusätzliche Abhängigkeiten unter Linux, macOS und Windows.

Das folgende Beispiel erstellt eine Arbeitsmappe, füllt ein Arbeitsblatt mit Verkaufsdaten, formatiert die Kopfzeile fett und streamt 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.Now: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.Now:yyyyMMdd}.xlsx";
        return File(fileBytes,
            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            filename);
    }
}

Imports IronXL
Imports Microsoft.AspNetCore.Mvc

Public Class ExportController
    Inherits Controller

    <HttpPost>
    Public Function ExportReport() As IActionResult
        ' Create workbook and worksheet
        Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
        Dim worksheet As 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.0
        worksheet("A3").Value = "Widget B"
        worksheet("B3").Value = 230
        worksheet("C3").Value = 6900.0

        ' Apply bold formatting to headers
        Dim headerRange = worksheet("A1:C1")
        headerRange.Style.Font.Bold = True

        ' Stream file to browser
        Dim fileBytes As Byte() = workbook.ToByteArray()
        Dim filename As String = $"SalesReport_{DateTime.Now:yyyyMMdd}.xlsx"
        Return File(fileBytes, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", filename)
    End Function
End Class

// 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 DataTables und Datenbanken?

Viele ASP.NET Core Anwendungen rufen Daten aus SQL Server oder einer anderen relationalen Datenbank ab, bevor sie diese exportieren. IronXL bietet erstklassige Unterstützung für das direkte Laden eines DataTable in ein Arbeitsblatt, wodurch die Notwendigkeit entfällt, Zeilen manuell zu durchlaufen.

Das folgende Beispiel fragt eine Datenbank mithilfe von ADO .NET ab und füllt ein Excel-Arbeitsblatt mit den resultierenden Daten. 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");
    }
}

Imports IronXL
Imports System.Data
Imports System.Data.SqlClient
Imports Microsoft.AspNetCore.Mvc

Public Class ReportController
    Inherits Controller

    Private ReadOnly _connectionString As String

    Public Sub New(config As IConfiguration)
        _connectionString = config.GetConnectionString("DefaultConnection")
    End Sub

    <HttpGet>
    Public Function DownloadReport() As IActionResult
        Dim table As New DataTable()

        Using connection As New SqlConnection(_connectionString)
            Dim query As String = "SELECT OrderId, CustomerName, Total, OrderDate FROM Orders"
            Using adapter As New SqlDataAdapter(query, connection)
                adapter.Fill(table)
            End Using
        End Using

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

        ' Write column headers from DataTable schema
        For col As Integer = 0 To table.Columns.Count - 1
            worksheet(0, col).Value = table.Columns(col).ColumnName
        Next

        ' Write data rows
        For row As Integer = 0 To table.Rows.Count - 1
            For col As Integer = 0 To table.Columns.Count - 1
                worksheet(row + 1, col).Value = table.Rows(row)(col).ToString()
            Next
        Next

        Dim fileBytes As Byte() = workbook.ToByteArray()
        Return File(fileBytes, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "Orders.xlsx")
    End Function
End Class

Dieses Muster sorgt für einen schlanken und testbaren Controller. Die Datenbankabfrage und die Erstellung der Arbeitsmappe sind klar voneinander getrennt, sodass es einfach ist, die Datenquelle auszutauschen oder zusätzliche Arbeitsblätter für zusammenfassende Daten hinzuzufügen. Hinweise zum Einlesen vorhandener Excel-Dateien in einen DataTable finden Sie in der IronXL -Anleitung zum Lesen von Excel-Dateien .

Wie lassen sich ClosedXML und EPPlus vergleichen?

ClosedXML kapselt Microsofts Open XML SDK in eine zugängliche API ein. Installieren Sie es über 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");
    }
}

Imports ClosedXML.Excel
Imports Microsoft.AspNetCore.Mvc
Imports System.IO

Public Class ExportController
    Inherits Controller

    <HttpGet>
    Public Function ExportWithClosedXML() As IActionResult
        Using workbook As New XLWorkbook()
            Dim 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 stream As New MemoryStream()
                workbook.SaveAs(stream)
                Return File(stream.ToArray(), "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "export.xlsx")
            End Using
        End Using
    End Function
End Class

Wie wählt man die richtige Bibliothek für sein Projekt aus?

Die Auswahl der richtigen Excel-Exportbibliothek hängt von drei Faktoren ab: den benötigten Ausgabeformaten, den Lizenzbeschränkungen Ihres Projekts und der Frage, ob Sie Professional Unterstützung benötigen.

Wählen Sie IronXL, wenn Ihre Anwendung eine Ausgabe in verschiedenen Formaten (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, Zellformatierung oder Diagrammerstellung benötigen. Die Dokumentation von IronXL deckt jede API-Schnittstelle detailliert ab, und das Support-Team antwortet Lizenzinhabern direkt. Weitere Schnittmuster und Anleitungen finden Sie im IronXL -Blog .

Wählen Sie ClosedXML, wenn Ihr Projekt Open Source oder nicht kommerziell ist und nur eine XLSX-Ausgabe erfordert. Die MIT-Lizenz legt keine Beschränkungen für die Weiterverbreitung fest, und die API ist durch Community-Ressourcen gut dokumentiert.

Wählen Sie EPPlus, wenn eine bestehende Codebasis bereits EPPlus verwendet und die Migration zu einer anderen Bibliothek mehr kosten würde als der Kauf einer kommerziellen Lizenz.

Für Teams, die IronXL mit Alternativen vergleichen, ermöglicht die IronXL -Testlizenz ein umfassendes Testen vor dem Kauf. Weitere Codebeispiele zum Lesen und Schreiben von Excel-Dateien finden Sie auf der IronXL Beispielseite.

Was sind Ihre nächsten Schritte?

Nachdem Sie die verfügbaren Exportmethoden für Excel unter ASP.NET Core kennengelernt haben, können Sie wie folgt vorgehen:

• Installieren Sie IronXL mit dem Code dotnet add package IronXl.Excel und folgen Sie der Kurzanleitung, um Ihre erste Arbeitsmappe zu erstellen.
• Vergleichen Sie Codebeispiele , indem Sie die IronXL -Beispielseite nach Szenarien durchsuchen, die Ihrem Anwendungsfall entsprechen, wie z. B. Datenbankexport, Arbeitsmappen mit mehreren Tabellenblättern oder formatierte Berichte.
• Informieren Sie sich über die Lizenzbedingungen , indem Sie die IronXL -Lizenzseite besuchen, um die Optionen für Entwicklungs-, Staging- und Produktionsumgebungen kennenzulernen.
• Erkunden Sie zusätzliche Formate , indem Sie die Methoden SaveAsCsv, SaveAsJson und SaveAsXml testen, falls Ihre Anwendung Daten in mehreren Formaten aus derselben Codebasis exportieren muss.
• Migrieren Sie von Legacy-Code , indem Sie alle vorhandenen Response.ContentType = "application/vnd.ms-excel"-Muster in Ihrer Lösung identifizieren und diese durch die IronXL Arbeitsmappenerstellung ersetzen, wodurch Formatwarnungen für Ihre Benutzer vermieden werden.

Für den Einsatz in Produktionsumgebungen ist der Kauf einer Lizenz erforderlich , um Professional Support freizuschalten und die Einhaltung der IronXL -Lizenzbedingungen sicherzustellen.

Starten Sie jetzt mit IronXL.

Jetzt kostenlos starten