Warum sollte ich IronXL verwenden, um GridView-Daten nach Excel zu exportieren?

Mit IronXL können Sie in ASP.NET C# echte XLSX-Dateien aus GridView erstellen, ohne die üblichen Probleme, die mit HtmlTextWriter und StringWriter verbunden sind, wie Browserwarnungen und Formatierungsfehler.

Welche Einschränkungen gibt es bei der Verwendung von HtmlTextWriter für den Export nach Excel?

HtmlTextWriter erzeugt häufig gefälschte Excel-Dateien, die Browserwarnungen und Formatierungsprobleme verursachen können. IronXL behebt diese Probleme, indem es echte Excel-Dateien generiert.

Wie verbessert IronXL den Prozess des Datenexports aus GridView?

IronXL vereinfacht den Datenexport aus GridView, indem es Entwicklern ermöglicht, direkt aus ihren ASP.NET Anwendungen korrekt formatierte Excel-Dateien zu generieren, wodurch die Notwendigkeit von HTML-basierten Workarounds umgangen wird.

Welches Dateiformat verwendet IronXL für exportierte Excel-Dateien?

IronXL exportiert Daten in originale XLSX-Dateien, wodurch Kompatibilität und korrekte Formatierung beim Öffnen in Excel gewährleistet werden.

Kann IronXL bei Formatierungsproblemen beim Export nach Excel helfen?

Ja, IronXL beseitigt Formatierungsprobleme durch die Erstellung echter Excel-Dateien, wodurch sichergestellt wird, dass die Daten korrekt angezeigt werden, ohne Browserwarnungen auszulösen.

Gibt es ein Codebeispiel für den Export von GridView-Daten mit IronXL?

Ja, das Tutorial enthält Codebeispiele, die zeigen, wie man mit IronXL GridView-Daten effizient und effektiv nach Excel exportiert.

Unterstützt IronXL den Export großer Datensätze aus GridView?

IronXL ist für die effiziente Verarbeitung großer Datensätze konzipiert und eignet sich daher ideal für den Export umfangreicher Daten aus GridView nach Excel.

Welche Vorteile bietet die Verwendung von IronXL gegenüber herkömmlichen Methoden für den Excel-Export?

IronXL bietet eine zuverlässigere und effizientere Lösung, indem Browserwarnungen eliminiert, die korrekte Dateiformatierung sichergestellt und eine unkomplizierte Code-Implementierung für den Export von GridView-Daten bereitgestellt wird.

What steps should I follow to implement GridView export using IronXL?

First, install IronXL via NuGet. Then replace your traditional export logic with IronXL's method to create a WorkBook from a DataTable, apply necessary formatting, and stream the result to the browser.

How does IronXL handle Excel file streaming to the browser?

IronXL sets the response content type to the appropriate MIME type for Excel and writes directly to the browser's output stream, initiating a download without creating temporary files on the server.

Die C# Excel-Bibliothek

Explore IronXL Excel Spreadsheet Library for C# .NET Gratis testen

Excel-Dateien ohne Interop lesen

Alle Codebeispiele anzeigen

using IronXL;
using System;
using System.Linq;

// Supported for XLSX, XLS, XLSM, XLTX, CSV and TSV
WorkBook workBook = WorkBook.Load("sample.xlsx");

// Select worksheet at index 0
WorkSheet workSheet = workBook.WorkSheets[0];

// Get any existing worksheet
WorkSheet firstSheet = workBook.DefaultWorkSheet;

// Select a cell and return the converted value
int cellValue = workSheet["A2"].IntValue;

// Read from ranges of cells elegantly.
foreach (var cell in workSheet["A2:A10"])
{
    Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text);
}

// Calculate aggregate values such as Min, Max and Sum
decimal sum = workSheet["A2:A10"].Sum();

// Linq compatible
decimal max = workSheet["A2:A10"].Max(c => c.DecimalValue);

using IronXL;
using System;
using System.Linq;

// Supported for XLSX, XLS, XLSM, XLTX, CSV and TSV
WorkBook workBook = WorkBook.Load("sample.xlsx");

// Select worksheet at index 0
WorkSheet workSheet = workBook.WorkSheets[0];

// Get any existing worksheet
WorkSheet firstSheet = workBook.DefaultWorkSheet;

// Select a cell and return the converted value
int cellValue = workSheet["A2"].IntValue;

// Read from ranges of cells elegantly.
foreach (var cell in workSheet["A2:A10"])
{
    Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text);
}

// Calculate aggregate values such as Min, Max and Sum
decimal sum = workSheet["A2:A10"].Sum();

// Linq compatible
decimal max = workSheet["A2:A10"].Max(c => c.DecimalValue);

PM >Install-Package IronXL.Excel

Install-Package IronXL.Excel

IRONXL VERWENDEN

Wie exportiert man Daten aus einem GridView in C# mit IronXL nach Excel?

Curtis Chau

Updated: 28. Juni 2026

Das Exportieren von GridView-Daten in eine echte Excel-Datei ist eine der häufigsten Anforderungen in ASP.NET -Webanwendungen. Traditionelle Ansätze mit HtmlTextWriter und StringWriter erzeugen gefälschte Excel-Dateien, die beim Öffnen im Browser Warnungen und Formatfehler auslösen. Dieser Leitfaden zeigt Ihnen, wie Sie GridView-Daten in korrekt formatierte .xlsx-Dateien mit IronXL exportieren – und damit die Kopfschmerzen vermeiden, die Entwickler mit veralteten Methoden haben.

Warum verursacht der traditionelle GridView-Exportansatz Probleme?

Die klassische Methode zum Exportieren nach Excel aus GridView in ASP.NET C# beinhaltet das Rendern von HTML und das Setzen von Response-Headern mit Content-Disposition-Dateianhang-Werten. Dieser Ansatz erfordert das Überschreiben von public override void VerifyRenderingInServerForm, um Laufzeitfehler zu vermeiden. Die resultierende Datei ist keine echte Excel-Datei – es handelt sich um HTML, das sich als .xls-Erweiterung tarnt, was dazu führt, dass Excel Warnmeldungen anzeigt, wenn Benutzer sie öffnen.

Die traditionelle Methode hat insbesondere folgende Nachteile:

Excel zeigt bei jedem Öffnen eine Warnung an: "Dateiformat und Dateierweiterung stimmen nicht überein." Formatierung und Datentypen gehen verloren, da die Daten als unformatiertes HTML gespeichert werden.

Sie müssen VerifyRenderingInServerForm als Workaround implementieren, was technologische Schulden in Ihr Projekt einbringt Die resultierende Datei enthält keine korrekten Zellenmetadaten und ist daher für nachfolgende Automatisierungs- oder Berichtstools unbrauchbar.

IronXL löst diese Probleme, indem echte .xlsx Excel-Dateien erstellt werden, ohne dass Microsoft Office auf dem Server installiert sein muss. Sie erhalten eine Datei, die sich von jeder Tabellenkalkulationsanwendung problemlos öffnen lässt, wobei die korrekten Datentypen, Formatierungen und die OOXML-Struktur erhalten bleiben.

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

Bevor Sie die Exportlogik implementieren, fügen Sie IronXL mithilfe des NuGet Paketmanagers zu Ihrem Projekt hinzu. Öffnen Sie die Paketmanager-Konsole in Visual Studio und führen Sie den Befehl aus:

PM > Install-Package IronXL.Excel

Install-Package IronXL.Excel

Alternativ suchen Sie im NuGet-Paketmanager-UI nach IronXL.Excel und installieren es von dort aus. Nach der Installation können Sie den IronXL-Namespace in jeder Code-Behind-Datei referenzieren.

IronXL ist für .NET Standard 2.0 und höher ausgelegt und funktioniert daher sowohl mit modernen ASP.NET Core -Projekten als auch mit klassischen ASP.NET Framework-Anwendungen. Es werden weder COM-Interoperabilität noch eine Office-Installation oder zusätzliche native Abhängigkeiten auf Ihrem Webserver benötigt.

Weitere Informationen finden Sie im IronXL-Installationshandbuch und auf der Seite zum IronXL-NuGet-Paket.

Wie richtet man das ASP.NET GridView für den Export ein?

Erstellen Sie Ihre Default.aspx-Seite mit einem GridView-Steuerelement und einem Export-Button. Die Auszeichnung entspricht dem Standard von Web Forms:

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Default.aspx.cs" Inherits="GridViewExportTest.Default" %>
<!DOCTYPE html>
<html>
<head runat="server">
    <title>Export GridView to Excel</title>
</head>
<body>
    <form id="form1" runat="server">
        <div>
            <h2>IronXL GridView Export Demo</h2>
            <asp:GridView ID="GridView1" runat="server" AutoGenerateColumns="true"
                HeaderStyle-BackColor="#3AC0F2" HeaderStyle-ForeColor="White" CellPadding="5">
            </asp:GridView>
            <br />
            <asp:Button ID="btnExport" runat="server" Text="Export to Excel (.xlsx)"
                OnClick="btnExport_Click" />
        </div>
    </form>
</body>
</html>

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Default.aspx.cs" Inherits="GridViewExportTest.Default" %>
<!DOCTYPE html>
<html>
<head runat="server">
    <title>Export GridView to Excel</title>
</head>
<body>
    <form id="form1" runat="server">
        <div>
            <h2>IronXL GridView Export Demo</h2>
            <asp:GridView ID="GridView1" runat="server" AutoGenerateColumns="true"
                HeaderStyle-BackColor="#3AC0F2" HeaderStyle-ForeColor="White" CellPadding="5">
            </asp:GridView>
            <br />
            <asp:Button ID="btnExport" runat="server" Text="Export to Excel (.xlsx)"
                OnClick="btnExport_Click" />
        </div>
    </form>
</body>
</html>

net

net

Dieses Markup erstellt eine einfache Seite mit einem gebundenen GridView und einem Button, der den Export auslöst. Das AutoGenerateColumns="true"-Attribut bedeutet, dass das Grid die Spaltennamen direkt vom gebundenen DataTable liest.

Binden von Beispieldaten an das GridView

Binden Sie in Ihrem Code-Behind einen DataTable an das Grid und speichern ihn in Session, um ihn später beim Export-Postback zu verwenden:

using System;
using System.Data;
using System.Web.UI;
using IronXL;

namespace GridViewExport
{
    public partial class Default : Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {
            if (!IsPostBack)
            {
                BindGridView();
            }
        }

        private void BindGridView()
        {
            DataTable dt = new DataTable("Employees");
            dt.Columns.Add("EmployeeID", typeof(int));
            dt.Columns.Add("Name", typeof(string));
            dt.Columns.Add("Department", typeof(string));
            dt.Columns.Add("Salary", typeof(decimal));

            dt.Rows.Add(1, "John Smith", "Engineering", 75000);
            dt.Rows.Add(2, "Sarah Johnson", "Marketing", 65000);
            dt.Rows.Add(3, "Mike Wilson", "Sales", 70000);
            dt.Rows.Add(4, "Emily Davis", "Engineering", 80000);

            GridView1.DataSource = dt;
            GridView1.DataBind();

            // Store DataTable in Session for export postback
            Session["GridData"] = dt;
        }
    }
}

using System;
using System.Data;
using System.Web.UI;
using IronXL;

namespace GridViewExport
{
    public partial class Default : Page
    {
        protected void Page_Load(object sender, EventArgs e)
        {
            if (!IsPostBack)
            {
                BindGridView();
            }
        }

        private void BindGridView()
        {
            DataTable dt = new DataTable("Employees");
            dt.Columns.Add("EmployeeID", typeof(int));
            dt.Columns.Add("Name", typeof(string));
            dt.Columns.Add("Department", typeof(string));
            dt.Columns.Add("Salary", typeof(decimal));

            dt.Rows.Add(1, "John Smith", "Engineering", 75000);
            dt.Rows.Add(2, "Sarah Johnson", "Marketing", 65000);
            dt.Rows.Add(3, "Mike Wilson", "Sales", 70000);
            dt.Rows.Add(4, "Emily Davis", "Engineering", 80000);

            GridView1.DataSource = dt;
            GridView1.DataBind();

            // Store DataTable in Session for export postback
            Session["GridData"] = dt;
        }
    }
}

Imports System
Imports System.Data
Imports System.Web.UI
Imports IronXL

Namespace GridViewExport
    Partial Public Class [Default]
        Inherits Page

        Protected Sub Page_Load(sender As Object, e As EventArgs)
            If Not IsPostBack Then
                BindGridView()
            End If
        End Sub

        Private Sub BindGridView()
            Dim dt As New DataTable("Employees")
            dt.Columns.Add("EmployeeID", GetType(Integer))
            dt.Columns.Add("Name", GetType(String))
            dt.Columns.Add("Department", GetType(String))
            dt.Columns.Add("Salary", GetType(Decimal))

            dt.Rows.Add(1, "John Smith", "Engineering", 75000)
            dt.Rows.Add(2, "Sarah Johnson", "Marketing", 65000)
            dt.Rows.Add(3, "Mike Wilson", "Sales", 70000)
            dt.Rows.Add(4, "Emily Davis", "Engineering", 80000)

            GridView1.DataSource = dt
            GridView1.DataBind()

            ' Store DataTable in Session for export postback
            Session("GridData") = dt
        End Sub
    End Class
End Namespace

Imports System
Imports System.Data
Imports System.Web.UI
Imports IronXL

Namespace GridViewExport
    Partial Public Class [Default]
        Inherits Page

        Protected Sub Page_Load(sender As Object, e As EventArgs)
            If Not IsPostBack Then
                BindGridView()
            End If
        End Sub

        Private Sub BindGridView()
            Dim dt As New DataTable("Employees")
            dt.Columns.Add("EmployeeID", GetType(Integer))
            dt.Columns.Add("Name", GetType(String))
            dt.Columns.Add("Department", GetType(String))
            dt.Columns.Add("Salary", GetType(Decimal))

            dt.Rows.Add(1, "John Smith", "Engineering", 75000)
            dt.Rows.Add(2, "Sarah Johnson", "Marketing", 65000)
            dt.Rows.Add(3, "Mike Wilson", "Sales", 70000)
            dt.Rows.Add(4, "Emily Davis", "Engineering", 80000)

            GridView1.DataSource = dt
            GridView1.DataBind()

            ' Store DataTable in Session for export postback
            Session("GridData") = dt
        End Sub
    End Class
End Namespace

Das Speichern des DataTable in Session vermeidet das erneute Abfragen der Datenbank oder den Wiederaufbau der Daten beim durch den Export-Button ausgelösten Postback. Für reale Anwendungen sollten die fest codierten Zeilen durch eine Datenbankabfrage mit Entity Framework oder ADO .NET ersetzt werden.

Export nach Excel von GridView in ASP .NET C#: Eine saubere C#-Lösung: Bild 1 - UI zeigt die Beispiel-GridView-Daten

Wie exportiert man GridView-Daten mit IronXL nach Excel?

Der saubere Ansatz für den GridView-Export konvertiert Ihr DataTable in ein IronXL WorkBook und streamt das Ergebnis direkt zum Browser. Hier ist die vollständige Exportmethode:

protected void btnExport_Click(object sender, EventArgs e)
{
    ExportGridViewToExcel();
}

private void ExportGridViewToExcel()
{
    DataTable dt = (DataTable)Session["GridData"];

    // Create a workbook and load data from the DataTable
    WorkBook workbook = WorkBook.Create();
    WorkBook.LoadWorkSheetsFromDataSet(new DataSet { Tables = { dt } }, workbook);
    WorkSheet worksheet = workbook.DefaultWorkSheet;

    // Apply header row formatting
    var headerRange = worksheet["A1:D1"];
    headerRange.Style.Font.Bold = true;
    headerRange.Style.Font.Size = 12;
    headerRange.Style.SetBackgroundColor("#3AC0F2");

    // Stream the file to the browser
    string filename = "GridViewExport_" + DateTime.Now.ToString("yyyyMMdd") + ".xlsx";
    Response.Clear();
    Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
    Response.AddHeader("content-disposition", "attachment;filename=" + filename);
    workbook.SaveAsStream(Response.OutputStream, IronXL.Enum.FileFormat.Xlsx);
    Response.Flush();
    Response.End();
}

protected void btnExport_Click(object sender, EventArgs e)
{
    ExportGridViewToExcel();
}

private void ExportGridViewToExcel()
{
    DataTable dt = (DataTable)Session["GridData"];

    // Create a workbook and load data from the DataTable
    WorkBook workbook = WorkBook.Create();
    WorkBook.LoadWorkSheetsFromDataSet(new DataSet { Tables = { dt } }, workbook);
    WorkSheet worksheet = workbook.DefaultWorkSheet;

    // Apply header row formatting
    var headerRange = worksheet["A1:D1"];
    headerRange.Style.Font.Bold = true;
    headerRange.Style.Font.Size = 12;
    headerRange.Style.SetBackgroundColor("#3AC0F2");

    // Stream the file to the browser
    string filename = "GridViewExport_" + DateTime.Now.ToString("yyyyMMdd") + ".xlsx";
    Response.Clear();
    Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
    Response.AddHeader("content-disposition", "attachment;filename=" + filename);
    workbook.SaveAsStream(Response.OutputStream, IronXL.Enum.FileFormat.Xlsx);
    Response.Flush();
    Response.End();
}

Imports System
Imports System.Data

Protected Sub btnExport_Click(sender As Object, e As EventArgs)
    ExportGridViewToExcel()
End Sub

Private Sub ExportGridViewToExcel()
    Dim dt As DataTable = DirectCast(Session("GridData"), DataTable)

    ' Create a workbook and load data from the DataTable
    Dim workbook As WorkBook = WorkBook.Create()
    WorkBook.LoadWorkSheetsFromDataSet(New DataSet With {.Tables = {dt}}, workbook)
    Dim worksheet As WorkSheet = workbook.DefaultWorkSheet

    ' Apply header row formatting
    Dim headerRange = worksheet("A1:D1")
    headerRange.Style.Font.Bold = True
    headerRange.Style.Font.Size = 12
    headerRange.Style.SetBackgroundColor("#3AC0F2")

    ' Stream the file to the browser
    Dim filename As String = "GridViewExport_" & DateTime.Now.ToString("yyyyMMdd") & ".xlsx"
    Response.Clear()
    Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
    Response.AddHeader("content-disposition", "attachment;filename=" & filename)
    workbook.SaveAsStream(Response.OutputStream, IronXL.Enum.FileFormat.Xlsx)
    Response.Flush()
    Response.End()
End Sub

Imports System
Imports System.Data

Protected Sub btnExport_Click(sender As Object, e As EventArgs)
    ExportGridViewToExcel()
End Sub

Private Sub ExportGridViewToExcel()
    Dim dt As DataTable = DirectCast(Session("GridData"), DataTable)

    ' Create a workbook and load data from the DataTable
    Dim workbook As WorkBook = WorkBook.Create()
    WorkBook.LoadWorkSheetsFromDataSet(New DataSet With {.Tables = {dt}}, workbook)
    Dim worksheet As WorkSheet = workbook.DefaultWorkSheet

    ' Apply header row formatting
    Dim headerRange = worksheet("A1:D1")
    headerRange.Style.Font.Bold = True
    headerRange.Style.Font.Size = 12
    headerRange.Style.SetBackgroundColor("#3AC0F2")

    ' Stream the file to the browser
    Dim filename As String = "GridViewExport_" & DateTime.Now.ToString("yyyyMMdd") & ".xlsx"
    Response.Clear()
    Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
    Response.AddHeader("content-disposition", "attachment;filename=" & filename)
    workbook.SaveAsStream(Response.OutputStream, IronXL.Enum.FileFormat.Xlsx)
    Response.Flush()
    Response.End()
End Sub

So funktioniert der Export Schritt für Schritt

Der Prozess lässt sich in drei logische Schritte unterteilen:

Rufen Sie das DataTable ab -- Session["GridData"] gibt dasselbe DataTable zurück, das an das Grid gebunden war. Dadurch werden doppelte Datenbankabfragen vermieden.
Bauen Sie das Arbeitsbuch -- WorkBook.LoadWorkSheetsFromDataSet erstellt automatisch ein Arbeitsblatt pro DataTable im DataSet und kopiert die Spaltenüberschriften und Zeilenwerte in die entsprechenden Zellen.
Stream zum Browser -- Das Setzen von Content-Type auf den OOXML-MIME-Typ und das Schreiben an Response.OutputStream löst einen Browser-Download mit der korrekten .xlsx-Erweiterung aus. Es wird keine temporäre Datei auf die Festplatte geschrieben.

Dies ist grundlegend anders als der veraltete HtmlTextWriter-Ansatz. Die exportierte Datei verwendet das Open XML-Format – dasselbe Format, das Microsoft Excel nativ verwendet – sodass sie sich ohne Warnungen öffnen lässt.

Für weitere Informationen zum programmgesteuerten Laden von Daten lesen Sie die IronXL WorkBook-Dokumentation und wie Sie DataTable nach Excel in C# exportieren.

Export nach Excel von GridView in ASP .NET C#: Eine saubere C#-Lösung: Bild 2 - Exportierte Excel-Datei

Wie kann ich die Excel-Datei auf der Festplatte speichern, anstatt sie zu streamen?

Wenn Ihre Anwendung Exporte auf dem Server archivieren muss, bevor sie dem Benutzer einen Download-Link liefert, speichern Sie das Arbeitsbuch in einem Dateipfad anstatt es an Response.OutputStream zu streamen:

private void SaveExcelToDisk(WorkBook workbook, string exportFolder)
{
    // Ensure the exports directory exists
    if (!System.IO.Directory.Exists(exportFolder))
    {
        System.IO.Directory.CreateDirectory(exportFolder);
    }

    string timestamp = DateTime.Now.ToString("yyyyMMdd_HHmmss");
    string filename = System.IO.Path.Combine(exportFolder, $"Report_{timestamp}.xlsx");

    workbook.SaveAs(filename);

    // Return the relative path for generating a download link
    string relativePath = "~/Exports/Report_" + timestamp + ".xlsx";
    Response.Write($"<script>alert('File saved to {relativePath}');</script>");
}

private void SaveExcelToDisk(WorkBook workbook, string exportFolder)
{
    // Ensure the exports directory exists
    if (!System.IO.Directory.Exists(exportFolder))
    {
        System.IO.Directory.CreateDirectory(exportFolder);
    }

    string timestamp = DateTime.Now.ToString("yyyyMMdd_HHmmss");
    string filename = System.IO.Path.Combine(exportFolder, $"Report_{timestamp}.xlsx");

    workbook.SaveAs(filename);

    // Return the relative path for generating a download link
    string relativePath = "~/Exports/Report_" + timestamp + ".xlsx";
    Response.Write($"<script>alert('File saved to {relativePath}');</script>");
}

Private Sub SaveExcelToDisk(workbook As WorkBook, exportFolder As String)
    ' Ensure the exports directory exists
    If Not System.IO.Directory.Exists(exportFolder) Then
        System.IO.Directory.CreateDirectory(exportFolder)
    End If

    Dim timestamp As String = DateTime.Now.ToString("yyyyMMdd_HHmmss")
    Dim filename As String = System.IO.Path.Combine(exportFolder, $"Report_{timestamp}.xlsx")

    workbook.SaveAs(filename)

    ' Return the relative path for generating a download link
    Dim relativePath As String = "~/Exports/Report_" & timestamp & ".xlsx"
    Response.Write($"<script>alert('File saved to {relativePath}');</script>")
End Sub

Private Sub SaveExcelToDisk(workbook As WorkBook, exportFolder As String)
    ' Ensure the exports directory exists
    If Not System.IO.Directory.Exists(exportFolder) Then
        System.IO.Directory.CreateDirectory(exportFolder)
    End If

    Dim timestamp As String = DateTime.Now.ToString("yyyyMMdd_HHmmss")
    Dim filename As String = System.IO.Path.Combine(exportFolder, $"Report_{timestamp}.xlsx")

    workbook.SaveAs(filename)

    ' Return the relative path for generating a download link
    Dim relativePath As String = "~/Exports/Report_" & timestamp & ".xlsx"
    Response.Write($"<script>alert('File saved to {relativePath}');</script>")
End Sub

Auswahl zwischen Streaming und Festplattenspeicherung

Vergleich von Streaming- und Festplatten-Exportstrategien
Strategie	Vorteile	Nachteile	Am besten für
Stream an Browser	Keine Festplattennutzung, sofortige Lieferung	Kann nicht archiviert oder erneut gesendet werden	On-Demand-Benutzerexporte
Auf Festplatte speichern	Die Datei bleibt zur Prüfung, zum erneuten Herunterladen oder zum Versenden per E-Mail erhalten.	Erfordert Aufräumarbeiten und Speicherplatzverwaltung	Geplante Berichte, Prüfprotokolle

Für die meisten interaktiven Webanwendungen ist das direkte Streaming an den Browser die richtige Wahl. Speichern Sie die Datei auf der Festplatte, wenn Sie sie per E-Mail versenden, aus Compliance-Gründen aufbewahren oder erneute Downloads über eine Dateiverwaltungsseite ermöglichen möchten.

Wie wendet man erweiterte Formatierungen auf das exportierte Excel-Arbeitsblatt an?

IronXL bietet Ihnen detaillierte Kontrolle über Zellenstile, Spaltenbreiten, Zahlenformate und vieles mehr. Das folgende Beispiel zeigt, wie man einen professionell gestalteten Export erstellt:

private void ExportWithFormatting()
{
    DataTable dt = new DataTable("Products");
    dt.Columns.Add("Product", typeof(string));
    dt.Columns.Add("Category", typeof(string));
    dt.Columns.Add("Price", typeof(decimal));
    dt.Columns.Add("InStock", typeof(bool));

    dt.Rows.Add("Widget A", "Hardware", 29.99m, true);
    dt.Rows.Add("Widget B", "Hardware", 49.99m, false);
    dt.Rows.Add("Service Plan", "Support", 199.00m, true);

    WorkBook workbook = WorkBook.Create();
    WorkBook.LoadWorkSheetsFromDataSet(new DataSet { Tables = { dt } }, workbook);
    WorkSheet sheet = workbook.WorkSheets[0];

    // Style the header row
    sheet["A1:D1"].Style.Font.Bold = true;
    sheet["A1:D1"].Style.Font.Size = 13;
    sheet["A1:D1"].Style.SetBackgroundColor("#2196F3");
    sheet["A1:D1"].Style.Font.Color = "#FFFFFF";

    // Apply currency format to the Price column (column C, rows 2 onwards)
    sheet["C2:C4"].Style.NumberFormat.Format = "$#,##0.00";

    // Auto-size all columns for readability
    for (int col = 0; col < 4; col++)
    {
        sheet.AutoSizeColumn(col);
    }

    // Freeze the header row so it stays visible when scrolling
    sheet.FreezePanes(0, 0, 1, 0);

    workbook.SaveAs("FormattedExport.xlsx");
}

private void ExportWithFormatting()
{
    DataTable dt = new DataTable("Products");
    dt.Columns.Add("Product", typeof(string));
    dt.Columns.Add("Category", typeof(string));
    dt.Columns.Add("Price", typeof(decimal));
    dt.Columns.Add("InStock", typeof(bool));

    dt.Rows.Add("Widget A", "Hardware", 29.99m, true);
    dt.Rows.Add("Widget B", "Hardware", 49.99m, false);
    dt.Rows.Add("Service Plan", "Support", 199.00m, true);

    WorkBook workbook = WorkBook.Create();
    WorkBook.LoadWorkSheetsFromDataSet(new DataSet { Tables = { dt } }, workbook);
    WorkSheet sheet = workbook.WorkSheets[0];

    // Style the header row
    sheet["A1:D1"].Style.Font.Bold = true;
    sheet["A1:D1"].Style.Font.Size = 13;
    sheet["A1:D1"].Style.SetBackgroundColor("#2196F3");
    sheet["A1:D1"].Style.Font.Color = "#FFFFFF";

    // Apply currency format to the Price column (column C, rows 2 onwards)
    sheet["C2:C4"].Style.NumberFormat.Format = "$#,##0.00";

    // Auto-size all columns for readability
    for (int col = 0; col < 4; col++)
    {
        sheet.AutoSizeColumn(col);
    }

    // Freeze the header row so it stays visible when scrolling
    sheet.FreezePanes(0, 0, 1, 0);

    workbook.SaveAs("FormattedExport.xlsx");
}

Private Sub ExportWithFormatting()
    Dim dt As New DataTable("Products")
    dt.Columns.Add("Product", GetType(String))
    dt.Columns.Add("Category", GetType(String))
    dt.Columns.Add("Price", GetType(Decimal))
    dt.Columns.Add("InStock", GetType(Boolean))

    dt.Rows.Add("Widget A", "Hardware", 29.99D, True)
    dt.Rows.Add("Widget B", "Hardware", 49.99D, False)
    dt.Rows.Add("Service Plan", "Support", 199.0D, True)

    Dim workbook As WorkBook = WorkBook.Create()
    WorkBook.LoadWorkSheetsFromDataSet(New DataSet With {.Tables = {dt}}, workbook)
    Dim sheet As WorkSheet = workbook.WorkSheets(0)

    ' Style the header row
    sheet("A1:D1").Style.Font.Bold = True
    sheet("A1:D1").Style.Font.Size = 13
    sheet("A1:D1").Style.SetBackgroundColor("#2196F3")
    sheet("A1:D1").Style.Font.Color = "#FFFFFF"

    ' Apply currency format to the Price column (column C, rows 2 onwards)
    sheet("C2:C4").Style.NumberFormat.Format = "$#,##0.00"

    ' Auto-size all columns for readability
    For col As Integer = 0 To 3
        sheet.AutoSizeColumn(col)
    Next

    ' Freeze the header row so it stays visible when scrolling
    sheet.FreezePanes(0, 0, 1, 0)

    workbook.SaveAs("FormattedExport.xlsx")
End Sub

Private Sub ExportWithFormatting()
    Dim dt As New DataTable("Products")
    dt.Columns.Add("Product", GetType(String))
    dt.Columns.Add("Category", GetType(String))
    dt.Columns.Add("Price", GetType(Decimal))
    dt.Columns.Add("InStock", GetType(Boolean))

    dt.Rows.Add("Widget A", "Hardware", 29.99D, True)
    dt.Rows.Add("Widget B", "Hardware", 49.99D, False)
    dt.Rows.Add("Service Plan", "Support", 199.0D, True)

    Dim workbook As WorkBook = WorkBook.Create()
    WorkBook.LoadWorkSheetsFromDataSet(New DataSet With {.Tables = {dt}}, workbook)
    Dim sheet As WorkSheet = workbook.WorkSheets(0)

    ' Style the header row
    sheet("A1:D1").Style.Font.Bold = True
    sheet("A1:D1").Style.Font.Size = 13
    sheet("A1:D1").Style.SetBackgroundColor("#2196F3")
    sheet("A1:D1").Style.Font.Color = "#FFFFFF"

    ' Apply currency format to the Price column (column C, rows 2 onwards)
    sheet("C2:C4").Style.NumberFormat.Format = "$#,##0.00"

    ' Auto-size all columns for readability
    For col As Integer = 0 To 3
        sheet.AutoSizeColumn(col)
    Next

    ' Freeze the header row so it stays visible when scrolling
    sheet.FreezePanes(0, 0, 1, 0)

    workbook.SaveAs("FormattedExport.xlsx")
End Sub

In IronXL verfügbare Formatierungsoptionen

IronXL bietet eine reichhaltige Menge an Formatierungseigenschaften über das IronXL.Styles-Namespace:

Schriftstil – fett, kursiv, unterstrichen, Schriftart und Größe
Zellhintergrundfarben -- Hexadezimalfarbzeichenfolgen werden direkt akzeptiert
Zahlen- und Datumsformate – beliebige Excel-Formatzeichenfolgen, einschließlich Währungs-, Prozent- und Datumsmuster
Spaltenbreite -- manuelle Pixelbreite oder AutoSizeColumn für automatische Anpassung
Fenster fixieren – Kopfzeilen oder Spalten beim Scrollen sperren
Zellenrahmen – alle vier Rahmen mit konfigurierbarem Stil und Farbe
Zellen zusammenführen – Zellen aus verschiedenen Zeilen oder Spalten für Berichtskopfzeilen kombinieren

For the full API reference, see IronXL cell styling documentation and IronXL number formatting.

Export nach Excel von GridView in ASP .NET C#: Eine saubere C#-Lösung: Bild 3 - Exportiertes formatiertes Excel-Dokument

Wie verarbeitet man große Datensätze beim Export in GridView?

Wenn das GridView an Tausende von Zeilen gebunden ist, sorgen einige Techniken für einen schnellen und speichereffizienten Export:

Paging und serverseitige Datentabelle

Exportieren Sie nicht nur die sichtbare Seite des GridView. Rufen Sie den vollständigen Datensatz von Ihrer Datenquelle in ein DataTable ab, bevor Sie WorkBook.LoadWorkSheetsFromDataSet aufrufen. IronXL schreibt Zeilen in einem einzigen Durchgang, ohne die gesamte Arbeitsmappe mehrfach in den Speicher zu laden, wodurch es sich für Zehntausende von Zeilen eignet.

Mehrere Arbeitsblätter hinzufügen

Sie können mehrere DataTable-Objekte in dem DataSet einfügen, um ein Arbeitsbuch mit separaten Registerkarten zu erzeugen:

DataSet exportSet = new DataSet();
exportSet.Tables.Add(GetEmployeeData());    // Sheet 1
exportSet.Tables.Add(GetDepartmentData());  // Sheet 2
exportSet.Tables.Add(GetSalaryReport());    // Sheet 3

WorkBook workbook = WorkBook.Create();
WorkBook.LoadWorkSheetsFromDataSet(exportSet, workbook);

Response.Clear();
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
Response.AddHeader("content-disposition", "attachment;filename=MultiSheetReport.xlsx");
workbook.SaveAsStream(Response.OutputStream, IronXL.Enum.FileFormat.Xlsx);
Response.Flush();
Response.End();

DataSet exportSet = new DataSet();
exportSet.Tables.Add(GetEmployeeData());    // Sheet 1
exportSet.Tables.Add(GetDepartmentData());  // Sheet 2
exportSet.Tables.Add(GetSalaryReport());    // Sheet 3

WorkBook workbook = WorkBook.Create();
WorkBook.LoadWorkSheetsFromDataSet(exportSet, workbook);

Response.Clear();
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
Response.AddHeader("content-disposition", "attachment;filename=MultiSheetReport.xlsx");
workbook.SaveAsStream(Response.OutputStream, IronXL.Enum.FileFormat.Xlsx);
Response.Flush();
Response.End();

Imports System.Data
Imports IronXL

Dim exportSet As New DataSet()
exportSet.Tables.Add(GetEmployeeData()) ' Sheet 1
exportSet.Tables.Add(GetDepartmentData()) ' Sheet 2
exportSet.Tables.Add(GetSalaryReport()) ' Sheet 3

Dim workbook As WorkBook = WorkBook.Create()
WorkBook.LoadWorkSheetsFromDataSet(exportSet, workbook)

Response.Clear()
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
Response.AddHeader("content-disposition", "attachment;filename=MultiSheetReport.xlsx")
workbook.SaveAsStream(Response.OutputStream, IronXL.Enum.FileFormat.Xlsx)
Response.Flush()
Response.End()

Imports System.Data
Imports IronXL

Dim exportSet As New DataSet()
exportSet.Tables.Add(GetEmployeeData()) ' Sheet 1
exportSet.Tables.Add(GetDepartmentData()) ' Sheet 2
exportSet.Tables.Add(GetSalaryReport()) ' Sheet 3

Dim workbook As WorkBook = WorkBook.Create()
WorkBook.LoadWorkSheetsFromDataSet(exportSet, workbook)

Response.Clear()
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
Response.AddHeader("content-disposition", "attachment;filename=MultiSheetReport.xlsx")
workbook.SaveAsStream(Response.OutputStream, IronXL.Enum.FileFormat.Xlsx)
Response.Flush()
Response.End()

Jeder DataTable.TableName wird in Excel der Arbeitsblatt-Registerkartenname. Dieses Muster eignet sich gut für Managementberichte, die zusammengehörige Daten aus verschiedenen Ansichten kombinieren.

Verwandte Leitfäden:

Was sind die wichtigsten Vorteile der Verwendung von IronXL für den GridView-Export?

Die Verwendung von IronXL zum Exportieren von GridView-Daten bietet klare Vorteile gegenüber dem herkömmlichen HTML-Wrapping-Ansatz:

Echte Excel-Dateien -- erstellt ein gültiges .xlsx-Format, das ohne Browser-Warnungen oder Fehlermeldungen geöffnet wird
Keine Office-Installation erforderlich - funktioniert auf jedem Webserver ohne Microsoft Excel oder Office-Interoperabilität
Keine VerifyRenderingInServerForm-Überschreibung -- beseitigt das Boilerplate-Workaround, das den traditionellen Code überfrachtet
Volle Formatierungskontrolle – Zellen formatieren, Zahlenformate anwenden, Bereiche fixieren und Professional Arbeitsblätter programmgesteuert erstellen
Unterstützung mehrerer Tabellenblätter – Export zusammengehöriger Datensätze als separate Tabellenblätter in einer einzigen Arbeitsmappe
Plattformübergreifende Kompatibilität – funktioniert einwandfrei auf Windows- und Linux-Servern, einschließlich Docker-Containern und Azure App Service.

Die Bibliothek ist auf NuGet verfügbar und unterstützt alle modernen .NET Ziele, einschließlich .NET 10. Sie unterstützt außerdem das Lesen und Schreiben anderer Formate wie CSV und ODS, wodurch sie zu einer einzigen Abhängigkeit für alle Tabellenkalkulationsanforderungen Ihrer Anwendung wird.

Für einen direkten Vergleich mit anderen Excel-Bibliotheken, siehe IronXL vs ClosedXML und die IronXL-Funktionsübersicht.

Was sind Ihre nächsten Schritte?

Sie haben nun alles, was Sie benötigen, um den veralteten HtmlTextWriter GridView-Export mit einer sauberen, warnfreien IronXL-Implementierung zu ersetzen. So geht es weiter:

Testen Sie die kostenlose Testversion – starten Sie eine kostenlose 30-Tage-Testversion von IronXL ohne Angabe von Kreditkartendaten und testen Sie den Exportcode in Ihrem eigenen Projekt.
Entdecken Sie weitere IronXL Tutorials – der IronXL Blog behandelt Datenimport, Zellformeln, Diagrammerstellung und Excel-Vorlagen-Workflows.
Lesen Sie die API-Referenz -- die IronXL API-Dokumentation deckt jede Methode zu WorkBook, WorkSheet und der Styling-API ab
Lizenzoptionen vergleichen – sehen Sie sich die IronXL Preise an, um die passende Lizenz für Ihre Teamgröße und Ihr Einsatzszenario zu finden.
Stellen Sie eine Frage – das Support-Team von Iron Software und die Community-Foren stehen Ihnen zur Verfügung, falls Sie auf unerwartete Probleme stoßen

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 Handbücher.

...