Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. Iron Software
  2. IronXL Blog
  3. IronXL verwenden
  4. Gridview nach Excel exportieren (XLSX)
IRONXL VERWENDEN

Wie exportiert man ein GridView-Steuerelement in C# mit IronXL nach Excel (XLSX)?

Curtis Chau
Curtis Chau
Aktualisiert:

Daten aus einem ASP.NET GridView in eine Excel-Datei exportieren

Sie können eine ASP.NET GridView in eine Excel XLSX-Datei in C# exportieren, indem Sie IronXL installieren, einen WorkBook erstellen, über GridView-Zeilen iterieren, jeden Zellwert an die entsprechende Arbeitsblattposition schreiben und das Arbeitsbuch auf die Festplatte oder den HTTP-Antwortstrom speichern. Dieser Ansatz erfordert keine Installation von Microsoft Office auf dem Server und funktioniert zuverlässig mit .NET Framework, .NET Core und .NET 5 bis .NET 10 Webanwendungen.

Der Export von GridView-Daten nach Excel ist eine Standardanforderung in ASP.NET Web Forms- Enterprise . Die Nutzer müssen tabellarische Daten aus dem Browser in Tabellenkalkulationen exportieren, um Berichte zu erstellen, Offline-Analysen durchzuführen und die Daten zu archivieren. Die Herausforderung besteht darin, die Lücke zwischen der serverseitigen GridView-Steuerung und einer ordnungsgemäß strukturierten .xlsx-Datei zu überbrücken, ohne Office Interop-Abhängigkeiten einzuführen, die in Webserver-Umgebungen Probleme verursachen.

Dieses Handbuch führt Sie durch drei fortschreitend reichhaltigere Exportmuster: einen minimalen Zeilen-für-Zeilen-Export, einen Header-plus-Daten-Export mit automatischer Spaltengrößenanpassung und einen DataTable-gesteuerten Export, der das gerenderte HTML vollständig umgeht. Jedes Beispiel verwendet C#-Code, der mit Top-Level-Anweisungen kompatibel ist, und die IronXL-API.

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

Öffnen Sie die Package Manager Console in Visual Studio und führen Sie folgendes aus:

Install-Package IronXL.Excel

Alternativ klicken Sie mit der rechten Maustaste auf das Projekt im Projektmappen-Explorer, wählen NuGet-Pakete verwalten, suchen nach IronXL, und klicken Installieren. NuGet löst alle transitiven Abhängigkeiten automatisch auf.

Nachdem das Paket installiert wurde, fügen Sie die folgenden using-Direktiven zu Ihrer Code-Behind-Datei hinzu:

using System;
using System.Data;
using System.Web.UI;
using IronXL;
using System;
using System.Data;
using System.Web.UI;
using IronXL;
Imports System
Imports System.Data
Imports System.Web.UI
Imports IronXL
$vbLabelText   $csharpLabel

IronXL unterstützt .NET Framework 4.6.2 und höher sowie .NET Core 3.1 und .NET 5 bis .NET 10. Auf dem Server ist keine Office-Installation oder COM-Registrierung erforderlich. Die vollständige API-Dokumentation finden Sie in der IronXL Objektreferenz .

Welche NuGet Paket-ID sollten Sie verwenden?

Die korrekte Paket-ID ist IronXL (nicht IronXL.Excel, was ein veraltetes Alias ist). Nach der Installation wird die Assembly IronXL.dll automatisch referenziert. Sie können die installierte Version überprüfen, indem Sie den Pakete-Knoten im Projektmappen-Explorer überprüfen oder dotnet list package aus dem Projektverzeichnis ausführen.

Funktioniert IronXL in ASP.NET Core Webanwendungen?

Ja. Die gleiche API funktioniert sowohl in ASP.NET Web Forms- als auch in ASP.NET Core -Projekten (MVC oder Razor Pages). In .NET Core-Projekten ersetzen Sie Server.MapPath durch IWebHostEnvironment.WebRootPath oder Path.Combine(Directory.GetCurrentDirectory(), "Exports") beim Erstellen von serverseitigen Dateipfaden.

Wie exportiert man ein GridView in eine Excel-Datei?

Das einfachste Exportmuster iteriert über jede gerenderte Zeile im GridView und kopiert den Text jeder Zelle in die entsprechende Excel-Arbeitsblattzelle. Fügen Sie im ASPX-Markup ein <asp:GridView ID="gvEmployees" runat="server" AutoGenerateColumns="true" />-Steuerelement und einen <asp:Button ID="btnExport" runat="server" Text="Export to Excel" OnClick="btnExport_Click" />-Button hinzu. Das runat="server"-Attribut macht beide Steuerungen im Code-Behind zugänglich.

Der Code-Behind bindet beim ersten Laden Beispieldaten und exportiert sie beim Klicken auf die Schaltfläche:

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

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

    private void BindGridView()
    {
        DataTable dt = new DataTable();
        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, "Michael Chen", "Finance", 70000);

        ViewState["EmployeeData"] = dt;
        gvEmployees.DataSource = dt;
        gvEmployees.DataBind();
    }

    protected void btnExport_Click(object sender, EventArgs e)
    {
        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet worksheet = workbook.CreateWorkSheet("Employees");

        // Write header row
        for (int j = 0; j < gvEmployees.HeaderRow.Cells.Count; j++)
        {
            worksheet.SetCellValue(0, j, gvEmployees.HeaderRow.Cells[j].Text);
        }

        // Write data rows
        for (int i = 0; i < gvEmployees.Rows.Count; i++)
        {
            for (int j = 0; j < gvEmployees.Rows[i].Cells.Count; j++)
            {
                worksheet.SetCellValue(i + 1, j, gvEmployees.Rows[i].Cells[j].Text);
            }
        }

        string filePath = Server.MapPath("~/Exports/EmployeeData.xlsx");
        workbook.SaveAs(filePath);
    }
}
using System;
using System.Data;
using System.Web.UI;
using IronXL;

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

    private void BindGridView()
    {
        DataTable dt = new DataTable();
        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, "Michael Chen", "Finance", 70000);

        ViewState["EmployeeData"] = dt;
        gvEmployees.DataSource = dt;
        gvEmployees.DataBind();
    }

    protected void btnExport_Click(object sender, EventArgs e)
    {
        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet worksheet = workbook.CreateWorkSheet("Employees");

        // Write header row
        for (int j = 0; j < gvEmployees.HeaderRow.Cells.Count; j++)
        {
            worksheet.SetCellValue(0, j, gvEmployees.HeaderRow.Cells[j].Text);
        }

        // Write data rows
        for (int i = 0; i < gvEmployees.Rows.Count; i++)
        {
            for (int j = 0; j < gvEmployees.Rows[i].Cells.Count; j++)
            {
                worksheet.SetCellValue(i + 1, j, gvEmployees.Rows[i].Cells[j].Text);
            }
        }

        string filePath = Server.MapPath("~/Exports/EmployeeData.xlsx");
        workbook.SaveAs(filePath);
    }
}
Imports System
Imports System.Data
Imports System.Web.UI
Imports IronXL

Public Partial Class GridViewExport
    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()
        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, "Michael Chen", "Finance", 70000)

        ViewState("EmployeeData") = dt
        gvEmployees.DataSource = dt
        gvEmployees.DataBind()
    End Sub

    Protected Sub btnExport_Click(sender As Object, e As EventArgs)
        Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
        Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Employees")

        ' Write header row
        For j As Integer = 0 To gvEmployees.HeaderRow.Cells.Count - 1
            worksheet.SetCellValue(0, j, gvEmployees.HeaderRow.Cells(j).Text)
        Next

        ' Write data rows
        For i As Integer = 0 To gvEmployees.Rows.Count - 1
            For j As Integer = 0 To gvEmployees.Rows(i).Cells.Count - 1
                worksheet.SetCellValue(i + 1, j, gvEmployees.Rows(i).Cells(j).Text)
            Next
        Next

        Dim filePath As String = Server.MapPath("~/Exports/EmployeeData.xlsx")
        workbook.SaveAs(filePath)
    End Sub
End Class
$vbLabelText   $csharpLabel

Der WorkBook.Create(ExcelFileFormat.XLSX)-Aufruf initialisiert ein speicherinternes Arbeitsbuch, das auf das moderne Open XML-Format abzielt. CreateWorkSheet("Employees") fügt das erste Blatt hinzu. Die äußere Schleife (i) bewegt sich durch die Datenzeilen; die innere Schleife (j) bewegt sich durch die Spalten. Der Zeilenindex i + 1 wird für Datenzellen verwendet, damit die Kopfzeile in Zeile 0 nicht überschrieben wird.

Warum IronXL anstelle von Excel Interop verwenden?

Für Excel Interop ist eine lizenzierte Kopie von Microsoft Excel erforderlich, die auf dem Server installiert ist. Außerdem werden COM-Objekte erstellt, die explizit freigegeben werden müssen, um Speicherlecks zu vermeiden. IronXL liest und schreibt .xlsx-Dateien direkt als Open XML-Pakete - kein COM, kein Office, kein Marshal.ReleaseComObject-Standard. Dadurch ist es zuverlässig in IIS, Azure App Service, Docker und anderen Serverumgebungen, in denen Office nicht verfügbar ist.

Welcher MIME-Typ ist für XLSX-Downloads korrekt?

Wenn Sie möchten, dass der Browser einen Dateispeichern-Dialog anzeigt, anstatt die Bytes inline zu liefern, setzen Sie den Antwortinhaltstyp auf application/vnd.openxmlformats-officedocument.spreadsheetml.sheet und fügen Sie einen Content-Disposition: attachment-Header hinzu, bevor Sie die Arbeitsbuch-Bytes in den Antwortstrom schreiben.

Wie fügt man Spaltenüberschriften hinzu und passt die Spaltenbreite automatisch an?

Das grundlegende Beispiel schreibt Header, die aus HeaderRow.Cells extrahiert wurden, aber ein Produktionsexport sollte auch jede Spalte automatisch anpassen, damit die Daten in Excel ohne manuelle Anpassungen lesbar sind:

protected void btnExport_Click(object sender, EventArgs e)
{
    WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
    WorkSheet worksheet = workbook.CreateWorkSheet("Employees");

    // Write column headers
    int colCount = gvEmployees.HeaderRow.Cells.Count;
    for (int i = 0; i < colCount; i++)
    {
        string header = gvEmployees.HeaderRow.Cells[i].Text;
        worksheet.SetCellValue(0, i, header);
    }

    // Write data rows
    for (int i = 0; i < gvEmployees.Rows.Count; i++)
    {
        for (int j = 0; j < gvEmployees.Rows[i].Cells.Count; j++)
        {
            worksheet.SetCellValue(i + 1, j, gvEmployees.Rows[i].Cells[j].Text);
        }
    }

    // Auto-size each column for readability
    for (int col = 0; col < colCount; col++)
    {
        worksheet.AutoSizeColumn(col);
    }

    string filePath = Server.MapPath("~/Exports/EmployeeReport.xlsx");
    workbook.SaveAs(filePath);
}
protected void btnExport_Click(object sender, EventArgs e)
{
    WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
    WorkSheet worksheet = workbook.CreateWorkSheet("Employees");

    // Write column headers
    int colCount = gvEmployees.HeaderRow.Cells.Count;
    for (int i = 0; i < colCount; i++)
    {
        string header = gvEmployees.HeaderRow.Cells[i].Text;
        worksheet.SetCellValue(0, i, header);
    }

    // Write data rows
    for (int i = 0; i < gvEmployees.Rows.Count; i++)
    {
        for (int j = 0; j < gvEmployees.Rows[i].Cells.Count; j++)
        {
            worksheet.SetCellValue(i + 1, j, gvEmployees.Rows[i].Cells[j].Text);
        }
    }

    // Auto-size each column for readability
    for (int col = 0; col < colCount; col++)
    {
        worksheet.AutoSizeColumn(col);
    }

    string filePath = Server.MapPath("~/Exports/EmployeeReport.xlsx");
    workbook.SaveAs(filePath);
}
Protected Sub btnExport_Click(sender As Object, e As EventArgs)
    Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
    Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Employees")

    ' Write column headers
    Dim colCount As Integer = gvEmployees.HeaderRow.Cells.Count
    For i As Integer = 0 To colCount - 1
        Dim header As String = gvEmployees.HeaderRow.Cells(i).Text
        worksheet.SetCellValue(0, i, header)
    Next

    ' Write data rows
    For i As Integer = 0 To gvEmployees.Rows.Count - 1
        For j As Integer = 0 To gvEmployees.Rows(i).Cells.Count - 1
            worksheet.SetCellValue(i + 1, j, gvEmployees.Rows(i).Cells(j).Text)
        Next
    Next

    ' Auto-size each column for readability
    For col As Integer = 0 To colCount - 1
        worksheet.AutoSizeColumn(col)
    Next

    Dim filePath As String = Server.MapPath("~/Exports/EmployeeReport.xlsx")
    workbook.SaveAs(filePath)
End Sub
$vbLabelText   $csharpLabel

AutoSizeColumn(col) weist IronXL an, die optimale Spaltenbreite basierend auf der Länge des Zellinhalts zu berechnen, was die Aktion Format > AutoFit Column Width in der Excel-Desktopanwendung widerspiegelt. Es ist effizienter, die Funktion in einer Schleife aufzurufen, nachdem alle Daten geschrieben wurden, als sie nach jeder Zeile aufzurufen, da der endgültige Inhalt zu diesem Zeitpunkt bereits bekannt ist.

Für zusätzliche Formatierungsoptionen – fette Kopfzeilen, Hintergrundfarben, Zahlenformate – erkunden Sie das IronXL Zellformatierungs-Tutorial. Sie können auch Zellen zusammenführen, um Berichtsüberschriften über mehrere Spalten zu erstellen.

Wie formatiert man Zellenüberschriften fett?

Verwenden Sie das IStyle-Objekt, das von worksheet["A1"].Style zurückgegeben wird (oder einen Bereich). Setzen Sie Font.Bold = true vor oder nach dem Schreiben der Werte - der Stil ist vom Zellinhalt entkoppelt.

// Bold the entire header row (columns A through D)
var headerRange = worksheet["A1:D1"];
headerRange.Style.Font.Bold = true;
headerRange.Style.BackgroundColor = "#4472C4";
headerRange.Style.Font.FontColor = "#FFFFFF";
// Bold the entire header row (columns A through D)
var headerRange = worksheet["A1:D1"];
headerRange.Style.Font.Bold = true;
headerRange.Style.BackgroundColor = "#4472C4";
headerRange.Style.Font.FontColor = "#FFFFFF";
' Bold the entire header row (columns A through D)
Dim headerRange = worksheet("A1:D1")
headerRange.Style.Font.Bold = True
headerRange.Style.BackgroundColor = "#4472C4"
headerRange.Style.Font.FontColor = "#FFFFFF"
$vbLabelText   $csharpLabel

Dieses Muster gilt einheitlich für Bereiche jeder Größe. Eine vollständige Liste der Stileigenschaften finden Sie in der IronXL Styling-API-Referenz .

Wie exportiert man Daten direkt aus einer DataTable?

Das Iterieren über gerenderte GridView-Zeilen bindet Ihren Export an den aktuellen visuellen Zustand der Steuerung, der durch Seitenerstellung, Sortierung und Sichtbarkeitseinstellungen der Spalten beeinflusst werden kann. Der Export aus dem zugrunde liegenden DataTable, das in ViewState gespeichert ist, ergibt ein deterministisches Ergebnis, unabhängig davon, wie das Raster konfiguriert ist:

protected void btnExport_Click(object sender, EventArgs e)
{
    DataTable sourceData = ViewState["EmployeeData"] as DataTable;
    if (sourceData == null)
    {
        Response.Write("No data available to export.");
        return;
    }

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

    // Column headers from DataTable schema
    for (int i = 0; i < sourceData.Columns.Count; i++)
    {
        worksheet.SetCellValue(0, i, sourceData.Columns[i].ColumnName);
    }

    // Data rows from DataRow objects
    for (int i = 0; i < sourceData.Rows.Count; i++)
    {
        for (int j = 0; j < sourceData.Columns.Count; j++)
        {
            worksheet.SetCellValue(i + 1, j, sourceData.Rows[i][j].ToString());
        }
    }

    string filePath = Server.MapPath("~/Exports/DataExport.xlsx");
    workbook.SaveAs(filePath);
}
protected void btnExport_Click(object sender, EventArgs e)
{
    DataTable sourceData = ViewState["EmployeeData"] as DataTable;
    if (sourceData == null)
    {
        Response.Write("No data available to export.");
        return;
    }

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

    // Column headers from DataTable schema
    for (int i = 0; i < sourceData.Columns.Count; i++)
    {
        worksheet.SetCellValue(0, i, sourceData.Columns[i].ColumnName);
    }

    // Data rows from DataRow objects
    for (int i = 0; i < sourceData.Rows.Count; i++)
    {
        for (int j = 0; j < sourceData.Columns.Count; j++)
        {
            worksheet.SetCellValue(i + 1, j, sourceData.Rows[i][j].ToString());
        }
    }

    string filePath = Server.MapPath("~/Exports/DataExport.xlsx");
    workbook.SaveAs(filePath);
}
Protected Sub btnExport_Click(sender As Object, e As EventArgs)
    Dim sourceData As DataTable = TryCast(ViewState("EmployeeData"), DataTable)
    If sourceData Is Nothing Then
        Response.Write("No data available to export.")
        Return
    End If

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

    ' Column headers from DataTable schema
    For i As Integer = 0 To sourceData.Columns.Count - 1
        worksheet.SetCellValue(0, i, sourceData.Columns(i).ColumnName)
    Next

    ' Data rows from DataRow objects
    For i As Integer = 0 To sourceData.Rows.Count - 1
        For j As Integer = 0 To sourceData.Columns.Count - 1
            worksheet.SetCellValue(i + 1, j, sourceData.Rows(i)(j).ToString())
        Next
    Next

    Dim filePath As String = Server.MapPath("~/Exports/DataExport.xlsx")
    workbook.SaveAs(filePath)
End Sub
$vbLabelText   $csharpLabel

Spaltennamen stammen aus DataTable.Columns[i].ColumnName, das das ursprüngliche Datenschema widerspiegelt, anstatt von Anzeigennamen-Überschreibungen, die in der GridView-Vorlage angewendet wurden. Zellwerte werden aus DataRow-Objekten unter Verwendung des Spaltenindex abgerufen, wobei jeder Wert in string umgewandelt wird, um SetCellValue zu genügen.

Dieses Muster ist besonders wertvoll, wenn das GridView-Steuerelement Paging verwendet - das Iterieren gvEmployees.Rows gibt nur die Zeilen auf der aktuell sichtbaren Seite zurück, während das Lesen aus dem vollständigen DataTable jeden Datensatz exportiert.

Was geschieht beim Export großer DataTables?

IronXL streamt Arbeitsmappendaten effizient für große Excel-Datensätze . Für Exporte, die über 100.000 Zeilen hinausgehen, sollten Sie berücksichtigen, SetCellValue-Aufrufe in einer einzigen Arbeitsblattoperation zu bündeln, anstatt einzelne Zellen in einer verschachtelten Schleife zu setzen. Sie können das Arbeitsbuch auch in einen MemoryStream schreiben und es schrittweise in den Response-Strom spülen, um zu vermeiden, dass die gesamte Datei im Server-RAM gehalten wird.

Wie gehen Sie mit Fehlern beim Export um?

Produktionsexport-Handler sollten die IronXL-Operationen in einen catch-Block einwickeln und dem Benutzer eine beschreibende Nachricht zurückgeben, wenn etwas schiefgeht. Häufige Fehlermodi umfassen ein fehlendes ~/Exports/-Verzeichnis, Dateiberechtigungsfehler und ViewState, das nach einem Sitzungs-Timeout null ist:

protected void btnExport_Click(object sender, EventArgs e)
{
    try
    {
        DataTable sourceData = ViewState["EmployeeData"] as DataTable;
        if (sourceData == null)
            throw new InvalidOperationException("Session data has expired. Please reload the page.");

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

        for (int i = 0; i < sourceData.Columns.Count; i++)
            worksheet.SetCellValue(0, i, sourceData.Columns[i].ColumnName);

        for (int i = 0; i < sourceData.Rows.Count; i++)
            for (int j = 0; j < sourceData.Columns.Count; j++)
                worksheet.SetCellValue(i + 1, j, sourceData.Rows[i][j].ToString());

        string filePath = Server.MapPath("~/Exports/SafeExport.xlsx");
        workbook.SaveAs(filePath);

        lblStatus.Text = "Export successful. File saved to server.";
    }
    catch (Exception ex)
    {
        lblStatus.Text = $"Export failed: {ex.Message}";
    }
}
protected void btnExport_Click(object sender, EventArgs e)
{
    try
    {
        DataTable sourceData = ViewState["EmployeeData"] as DataTable;
        if (sourceData == null)
            throw new InvalidOperationException("Session data has expired. Please reload the page.");

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

        for (int i = 0; i < sourceData.Columns.Count; i++)
            worksheet.SetCellValue(0, i, sourceData.Columns[i].ColumnName);

        for (int i = 0; i < sourceData.Rows.Count; i++)
            for (int j = 0; j < sourceData.Columns.Count; j++)
                worksheet.SetCellValue(i + 1, j, sourceData.Rows[i][j].ToString());

        string filePath = Server.MapPath("~/Exports/SafeExport.xlsx");
        workbook.SaveAs(filePath);

        lblStatus.Text = "Export successful. File saved to server.";
    }
    catch (Exception ex)
    {
        lblStatus.Text = $"Export failed: {ex.Message}";
    }
}
Protected Sub btnExport_Click(sender As Object, e As EventArgs)
    Try
        Dim sourceData As DataTable = TryCast(ViewState("EmployeeData"), DataTable)
        If sourceData Is Nothing Then
            Throw New InvalidOperationException("Session data has expired. Please reload the page.")
        End If

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

        For i As Integer = 0 To sourceData.Columns.Count - 1
            worksheet.SetCellValue(0, i, sourceData.Columns(i).ColumnName)
        Next

        For i As Integer = 0 To sourceData.Rows.Count - 1
            For j As Integer = 0 To sourceData.Columns.Count - 1
                worksheet.SetCellValue(i + 1, j, sourceData.Rows(i)(j).ToString())
            Next
        Next

        Dim filePath As String = Server.MapPath("~/Exports/SafeExport.xlsx")
        workbook.SaveAs(filePath)

        lblStatus.Text = "Export successful. File saved to server."
    Catch ex As Exception
        lblStatus.Text = $"Export failed: {ex.Message}"
    End Try
End Sub
$vbLabelText   $csharpLabel

Für Webanwendungen, die die Datei als direkten Browser-Download bereitstellen, anstatt sie auf die Festplatte zu speichern, verwenden Sie Response.BinaryWrite oder schreiben Sie in Response.OutputStream, nachdem Sie die Inhalts- und Dispositionsheader gesetzt haben. Stellen Sie sicher, dass das ~/Exports/-Verzeichnis vorhanden ist und die Identität des IIS-Anwendungspools Schreibberechtigungen dafür hat.

Wie kann ich die XLSX-Datei als Browser-Download versenden?

Ersetzen Sie workbook.SaveAs(filePath) durch eine Streaming-basierte Antwort:

using System.IO;

// ... inside btnExport_Click after populating the worksheet ...

byte[] fileBytes;
using (MemoryStream ms = new MemoryStream())
{
    workbook.SaveAs(ms);
    fileBytes = ms.ToArray();
}

Response.Clear();
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
Response.AddHeader("Content-Disposition", "attachment; filename=EmployeeData.xlsx");
Response.BinaryWrite(fileBytes);
Response.End();
using System.IO;

// ... inside btnExport_Click after populating the worksheet ...

byte[] fileBytes;
using (MemoryStream ms = new MemoryStream())
{
    workbook.SaveAs(ms);
    fileBytes = ms.ToArray();
}

Response.Clear();
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
Response.AddHeader("Content-Disposition", "attachment; filename=EmployeeData.xlsx");
Response.BinaryWrite(fileBytes);
Response.End();
Imports System.IO

' ... inside btnExport_Click after populating the worksheet ...

Dim fileBytes As Byte()
Using ms As New MemoryStream()
    workbook.SaveAs(ms)
    fileBytes = ms.ToArray()
End Using

Response.Clear()
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
Response.AddHeader("Content-Disposition", "attachment; filename=EmployeeData.xlsx")
Response.BinaryWrite(fileBytes)
Response.End()
$vbLabelText   $csharpLabel

Dieses Muster vermeidet das Schreiben einer temporären Datei auf die Festplatte. Der MemoryStream wird auf dem Server zugewiesen, in byte[] serialisiert und direkt an den Client gesendet. Der Response.End()-Aufruf spült die Antwort und verhindert, dass zusätzliches Seitenmarkup nach den Binärdaten angehängt wird.

Wie exportiert man mehrere Tabellenblätter oder erweiterte Arbeitsmappen?

Ein einzelner WorkBook kann mehrere Blätter enthalten, was nützlich ist, wenn Sie mehrere GridViews - oder denselben Datensatz in unterschiedlichen Granularitätsstufen - in eine Datei exportieren müssen. Rufen Sie workbook.CreateWorkSheet(name) einmal pro Registerkarte auf:

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);

WorkSheet summary = workbook.CreateWorkSheet("Summary");
WorkSheet detail  = workbook.CreateWorkSheet("Detail");

// Populate summary sheet ...
// Populate detail sheet ...

workbook.SaveAs(Server.MapPath("~/Exports/FullReport.xlsx"));
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);

WorkSheet summary = workbook.CreateWorkSheet("Summary");
WorkSheet detail  = workbook.CreateWorkSheet("Detail");

// Populate summary sheet ...
// Populate detail sheet ...

workbook.SaveAs(Server.MapPath("~/Exports/FullReport.xlsx"));
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)

Dim summary As WorkSheet = workbook.CreateWorkSheet("Summary")
Dim detail As WorkSheet = workbook.CreateWorkSheet("Detail")

' Populate summary sheet ...
' Populate detail sheet ...

workbook.SaveAs(Server.MapPath("~/Exports/FullReport.xlsx"))
$vbLabelText   $csharpLabel

IronXL unterstützt auch das Lesen vorhandener Excel-Dateien , sodass Sie eine vorgefertigte Vorlage mit Branding und Formatierung laden, Daten in bestimmte Zellen einfügen und das Ergebnis speichern können – wobei Diagramme, Bilder und Stile, die bereits in der Vorlage enthalten sind, erhalten bleiben.

Für noch reichhaltigere Ausgaben bietet IronXLExcel-Formelunterstützung, bedingte Formatierung, Diagrammerstellung und Bildeinbettung. Diese Funktionen sind im Tutorial-Bereich von IronXL dokumentiert.

Wie schneidet IronXL im Vergleich zu EPPlusund ClosedXMLab?

Feature IronXL EPPlus ClosedXML
Büroeinrichtung erforderlich Nein Nein Nein
XLSX lesen und schreiben Ja Ja Ja
XLS (ältere Version) Unterstützung Ja Nein Nein
CSV-/TSV-Export Ja Nein Teilweise
API zur Diagrammerstellung Ja Ja Beschränkt
Lizenzmodell Dauerhaft + SaaS Polyform nicht-kommerziell MIT
.NET 10-Unterstützung Ja Ja Ja

EPPlus wechselte in Version 5 zu einer kommerziellen Lizenz, wodurch IronXL zu einer natürlichen Alternative für Teams wurde, die bereits in ein kommerzielles .NET -Bibliotheks-Ökosystem investieren. ClosedXML ist weiterhin unter der MIT-Lizenz lizenziert, bietet aber nur eingeschränkte Diagrammunterstützung. Die richtige Wahl hängt von den Lizenzierungsbeschränkungen Ihres Projekts, den benötigten Excel-Funktionen und davon ab, ob Unterstützung für das ältere .xls-Format erforderlich ist.

Welche Excel-Formate unterstützt IronXL?

IronXL liest und schreibt .xlsx (Office Open XML), .xls (Legacy BIFF8), .csv und .tsv-Formate. Sie können zwischen Excel-Dateiformaten konvertieren mit einem einzigen API-Aufruf, indem Sie den ExcelFileFormat-Enum-Wert ändern, der an WorkBook.Create übergeben wird, oder indem Sie eine vorhandene Datei laden und in einem anderen Format speichern.

Was sind Ihre nächsten Schritte?

Sie verfügen nun über drei produktionsreife Muster zum Exportieren von ASP.NET GridView-Daten in Excel XLSX-Dateien mit IronXL:

  • Zeileniterations-Export -- der schnellste Weg zu einem funktionierenden Export von einem verbundenen GridView
  • Export von Kopfzeilen und Formatierungen – fügt automatische Spaltenbreitenanpassung und Fettdruck für ansprechende Berichte hinzu
  • DataTable-gesteuerter Export – umgeht das gerenderte Steuerelement vollständig für paginierte oder gefilterte Tabellen

Die nächsten logischen Schritte sind:

  1. Fügen Sie eine Browser-Download-Antwort hinzu mit MemoryStream und Response.BinaryWrite, damit Benutzer die Datei sofort ohne einen serverseitigen Speicherpfad erhalten.
  2. Anwenden von Zellenformatierungen -- fettgedruckte Kopfzeilen, Hintergrundfarbfüllungen und Zahlenformate -- mit der IronXL-Formatierungs-API.
  3. Nutzen Sie mehrseitige Arbeitsmappen, um zusammenfassende und detaillierte Daten in einer einzigen Datei zu kombinieren, die den Stakeholdern zur Verfügung gestellt wird.
  4. Lesen Sie Excel-Dateien zurück in DataTable-Objekte mithilfe der IronXL-Lese-API für Round-Trip-Import/Export-Workflows.
  5. Starten Sie eine kostenlose Testversion unter ironsoftware.com/csharp/excel/ , um alle Funktionen in Ihrem Projekt mit einer vollumfänglichen Testlizenz zu testen.

Für Teams, die Dokumentengenerierungs-Pipelines aufbauen, lässt sich IronPDF mit IronXL integrieren, um Arbeitsblätter direkt in das PDF-Format zu exportieren. Die Iron Suite bündelt IronXL mit IronPDF, IronOCR, IronBarcode und IronZIP zu einem reduzierten Gesamtpreis.

Häufig gestellte Fragen

Was ist der Hauptzweck der Verwendung von IronXL zum Exportieren von GridView nach Excel?

IronXL wird in erster Linie verwendet, um den Export von Daten aus einem ASP.NET GridView in Excel-Formate wie XLSX zu erleichtern und dabei eine hohe Leistungsfähigkeit und einfache Integration in C#-Anwendungen zu gewährleisten.

Kann IronXL beim Export aus GridView große Datensätze verarbeiten?

Ja, IronXL ist für die effiziente Verarbeitung großer Datensätze während des Exportvorgangs von GridView nach Excel optimiert und erhält dabei Geschwindigkeit und Leistung aufrecht.

Kann die Excel-Ausgabe bei der Verwendung von IronXL angepasst werden?

Mit IronXL können Sie verschiedene Aspekte der Excel-Ausgabe anpassen, z. B. Formatierung, Stil und das Einfügen zusätzlicher Daten oder Formeln in die exportierte Datei.

Wie schneidet IronXL im Vergleich zu anderen Bibliotheken für den Export von GridView nach Excel ab?

IronXL bietet im Vergleich zu anderen Bibliotheken einen unkomplizierteren und flexibleren Ansatz und unterstützt moderne Excel-Formate sowie die direkte Integration in C#-Anwendungen.

Unterstützt IronXL den Export in andere Formate als XLSX?

Ja, IronXL unterstützt den Export in verschiedene Excel-Formate, darunter XLS, CSV und TSV, und bietet somit Flexibilität für unterschiedliche Projektanforderungen.

Welche Voraussetzungen müssen für den Einsatz von IronXL in einem Projekt erfüllt sein?

Um IronXL zu verwenden, benötigen Sie eine .NET Umgebung und können IronXL über NuGet in Ihrem C#-Projekt installieren.

Kann IronXL GridView-Daten asynchron exportieren?

IronXL unterstützt asynchrone Operationen, sodass Entwickler GridView-Daten in Excel-Dateien exportieren können, ohne den Hauptanwendungsthread zu blockieren.

Wie kann ich mit IronXL beginnen, um GridView nach Excel zu exportieren?

Als Einstiegshilfe konsultieren Sie bitte die Dokumentation und die Beispiele von IronXL. Diese bieten eine schrittweise Anleitung zum Einrichten und Ausführen von Datenexporten von GridView nach Excel.

Curtis Chau
Curtis Chau
  Jetzt mit dem Ingenieurteam chatten
Technischer Autor

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

Weiterlesen

Verwandte Artikel

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

Iron-Support-Team

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