Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. Iron Software
  2. IronXL Blog
  3. IronXL verwenden
  4. Export nach Excel aus Gridview
IRONXL VERWENDEN

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

Jordi Bardia
Jordi Bardia
Aktualisiert:

Das Exportieren von GridView-Daten in eine echte Excel-Datei ist eine der häufigsten Anforderungen in ASP.NET -Webanwendungen. Herkömmliche Ansätze mit HtmlTextWriter und StringWriter erzeugen gefälschte Excel-Dateien, die Browser-Warnungen und Formatfehler auslösen, wenn Benutzer versuchen, sie zu öffnen. Dieser Leitfaden zeigt Ihnen, wie Sie GridView-Daten mit IronXL in korrekt formatierte .xlsx-Dateien exportieren können - und damit die Probleme beseitigen, die Entwickler mit herkömmlichen Methoden haben.

Warum verursacht der traditionelle GridView-Exportansatz Probleme?

Die klassische Methode für den Export nach Excel aus GridView in ASP.NET C# beinhaltet das Rendern von HTML und das Setzen von Response Kopfzeilen mit Content-Disposition Werten für den Dateinamen des Anhangs. 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 mit einer .xls-Erweiterung, die Excel dazu veranlasst, Warnmeldungen anzuzeigen, 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 Umgehungslösung implementieren, wodurch Ihr Projekt mit technischen Schulden belastet wird Die resultierende Datei enthält keine korrekten Zellenmetadaten und ist daher für nachfolgende Automatisierungs- oder Berichtstools unbrauchbar.

IronXL löst diese Probleme, indem es echte .xlsx Excel-Dateien erstellt, ohne dass Microsoft Office auf dem Server installiert werden 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:

Install-Package IronXL.Excel
Install-Package IronXL.Excel
SHELL

Alternativ können Sie in der NuGet Package Manager UI nach IronXL.Excel suchen und es von dort aus installieren. Nach der Installation können Sie den IronXL Namensraum 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>
$vbLabelText   $csharpLabel

Dieses Markup erstellt eine einfache Seite mit einem gebundenen GridView und einer Schaltfläche, die den Export auslöst. Das Attribut AutoGenerateColumns="true" bedeutet, dass das Grid die Spaltennamen direkt aus dem gebundenen DataTable liest.

Binden von Beispieldaten an das GridView

Binden Sie in Ihrem Code-Behind einen DataTable an das Grid und speichern Sie ihn in Session für die spätere Verwendung während des Export-Postbacks:

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

Durch die Speicherung von DataTable in Session wird eine erneute Abfrage der Datenbank oder ein Neuaufbau der Daten während des durch die Export-Schaltfläche ausgelösten Postbacks vermieden. Für reale Anwendungen sollten die fest codierten Zeilen durch eine Datenbankabfrage mit Entity Framework oder ADO .NET ersetzt werden.

Export to Excel from GridView in ASP.NET C#: Eine saubere C#-Lösung: Bild 1 - UI mit den Daten des GridView-Beispiels

Wie exportiert man GridView-Daten mit IronXL nach Excel?

Der saubere Ansatz für den GridView-Export konvertiert Ihre DataTable in eine IronXL WorkBook und streamt das Ergebnis direkt in den 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
$vbLabelText   $csharpLabel

So funktioniert der Export Schritt für Schritt

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

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

Dies ist ein grundlegender Unterschied zu dem bisherigen 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.

Weitere Informationen zum programmgesteuerten Laden von Daten finden Sie in der IronXL WorkBook-Dokumentation und unter "DataTable in C# nach Excel exportieren" .

Export to Excel from 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 die Arbeitsmappe in einem Dateipfad, anstatt sie 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
$vbLabelText   $csharpLabel

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

In IronXL verfügbare Formatierungsoptionen

IronXL stellt über den IronXL.Styles-Namensraum eine Vielzahl von Formatierungseigenschaften zur Verfügung:

  • 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

Die vollständige API Referenz finden Sie in der Dokumentation zu IronXL-Zellenformatierung und IronXL-Zahlenformatierung.

Export to Excel from 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 aus Ihrer Datenquelle in einem 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 den DataSet einfügen, um eine Arbeitsmappe mit separaten Registerkarten zu erstellen:

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

Jeder DataTable.TableName ist der Name der Arbeitsblatt-Registerkarte in Excel. 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 -- erzeugt gültiges .xlsx Format, das sich ohne Browser-Warnungen oder Fehlermeldungen öffnet
  • Keine Office-Installation erforderlich - funktioniert auf jedem Webserver ohne Microsoft Excel oder Office-Interoperabilität
  • Kein VerifyRenderingInServerForm override -- eliminiert die Standardumgehung, die den traditionellen Code überlagert
  • 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.

Einen direkten Vergleich mit anderen Excel-Bibliotheken finden Sie unter IronXL vs ClosedXML und in der IronXL -Funktionsübersicht .

Was sind Ihre nächsten Schritte?

Sie haben nun alles, was Sie brauchen, um den veralteten HtmlTextWriter GridView-Export durch eine saubere, warnungsfreie 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 von 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

Häufig gestellte Fragen

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.

Jordi Bardia
Jordi Bardia
  Jetzt mit dem Ingenieurteam chatten
Software Ingenieur
Jordi ist am besten in Python, C# und C++ versiert. Wenn er nicht bei Iron Software seine Fähigkeiten einsetzt, programmiert er Spiele. Mit Verantwortung für Produkttests, Produktentwicklung und -forschung trägt Jordi mit immensem Wert zur kontinuierlichen Produktverbesserung bei. Die abwechslungsreiche Erfahrung hält ihn gefordert und engagiert, ...
Weiterlesen

Verwandte Artikel

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

Iron Support Team

Wir sind 24 Stunden am Tag, 5 Tage die Woche online.
Chat
E-Mail
Rufen Sie mich an