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)?

Jordi Bardia
Jordi Bardia
Aktualisiert:

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

Sie können ein ASP.NET GridView in eine Excel XLSX-Datei in C# exportieren, indem Sie IronXL installieren, eine WorkBook erstellen, über die GridView-Zeilen iterieren, jeden Zellenwert an die entsprechende Position im Arbeitsblatt schreiben und die Arbeitsmappe auf der Festplatte oder im HTTP-Antwortstream 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-Unternehmensprojekten. 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 dem serverseitigen GridView Steuerelement und einer ordnungsgemäß strukturierten .xlsx Datei zu schließen, ohne Office Interop-Abhängigkeiten einzuführen, die in Webserver-Umgebungen zu Problemen führen.

Dieser Leitfaden führt Sie durch drei zunehmend umfangreichere Exportmuster: einen minimalen zeilenweisen Export, einen Export mit Kopfzeile und Daten sowie 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 IronXLin einem ASP.NET -Projekt?

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

Install-Package IronXL
dotnet add package IronXL
Install-Package IronXL
dotnet add package IronXL
SHELL

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

Nach der Installation des Pakets 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;
$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 lautet IronXL (nicht IronXl.Excel, das ist ein veralteter Alias). Nach der Installation wird die Assembly IronXL.dll automatisch referenziert. Sie können die installierte Version überprüfen, indem Sie im Projektmappen-Explorer den Knoten "Pakete" prüfen oder dotnet list package aus dem Projektverzeichnis ausführen.

Funktioniert IronXLin 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 Core-Projekten ersetzen Sie Server.MapPath durch IWebHostEnvironment.WebRootPath oder Path.Combine(Directory.GetCurrentDirectory(), "Exports") beim Erstellen serverseitiger Dateipfade.

Wie exportiert man ein GridView in eine Excel-Datei?

Das einfachste Exportmuster durchläuft jede gerenderte Zeile in GridView und kopiert den Text jeder Zelle in die entsprechende Zelle des Excel-Arbeitsblatts. Fügen Sie im ASPX-Markup ein <asp:GridView ID="gvEmployees" runat="server" AutoGenerateColumns="true" /> Steuerelement und eine <asp:Button ID="btnExport" runat="server" Text="Export to Excel" OnClick="btnExport_Click" /> Schaltfläche hinzu. Das Attribut runat="server" ermöglicht den Zugriff auf beide Steuerelemente im Code-Behind.

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

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

Warum IronXLanstelle 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. IronXLliest und schreibt .xlsx Dateien direkt als Open XML-Pakete -- kein COM, kein Office, kein Marshal.ReleaseComObject Boilerplate. 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 Dateispeicherdialog anzeigt, anstatt die Bytes direkt im Datenstrom 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 Arbeitsmappen-Bytes in den Antwortstream schreiben.

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

Das Basisbeispiel schreibt Header, die aus HeaderRow.Cells extrahiert werden. Ein Export für die Produktion sollte jedoch auch die Spaltenbreite automatisch anpassen, damit die Daten ohne manuelle Anpassungen in Excel 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);
}
$vbLabelText   $csharpLabel

AutoSizeColumn(col) weist IronXLan, die optimale Spaltenbreite anhand der Zellinhaltslänge zu berechnen, analog zur Funktion "Format > Spaltenbreite automatisch anpassen" in der Excel-Desktopanwendung. 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.

Weitere Gestaltungsmöglichkeiten – wie fette Überschriften, Hintergrundfarben und Zahlenformate – finden Sie im IronXL Tutorial zur Zellengestaltung . Sie können auch Zellen zusammenführen , um Berichtstitel zu erstellen, die sich über mehrere Spalten erstrecken.

Wie formatiert man Zellenüberschriften fett?

Verwenden Sie das von IStyle zurückgegebene Objekt worksheet["A1"].Style (oder einen Bereich). Setzen Sie Font.Bold = true vor oder nach dem Schreiben von Werten -- der Stil ist vom Zelleninhalt 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";
$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?

Durch das Iterieren über die gerenderten GridView Zeilen wird Ihr Export an den aktuellen visuellen Zustand des Steuerelements gebunden, der durch Paging-, Sortier- und Spaltensichtbarkeitseinstellungen beeinflusst werden kann. Der Export aus dem zugrunde liegenden DataTable, der in ViewState gespeichert ist, liefert unabhängig von der Konfiguration des Grids ein deterministisches Ergebnis:

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

Die Spaltennamen stammen aus DataTable.Columns[i].ColumnName, was das ursprüngliche Datenschema widerspiegelt und nicht die im GridView-Template angewendeten Anzeigenamenüberschreibungen. Die Zellenwerte werden aus DataRow Objekten mithilfe des Spaltenindex abgerufen, wobei jeder Wert in string umgewandelt wird, um SetCellValue zu erfüllen.

Dieses Muster ist besonders wertvoll, wenn GridView Paging verwendet -- die Iteration von 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 . Bei Exporten mit mehr als 100.000 Zeilen empfiehlt es sich, SetCellValue-Aufrufe in einem einzigen Arbeitsblattvorgang zu bündeln, anstatt einzelne Zellen in einer verschachtelten Schleife zu bearbeiten. Alternativ können Sie die Arbeitsmappe in einen MemoryStream-Stream schreiben und diesen inkrementell in den Response-Stream übertragen, um zu vermeiden, dass die gesamte Datei im Arbeitsspeicher des Servers gehalten wird.

Wie gehen Sie mit Fehlern beim Export um?

Die Export-Handler für die Produktion sollten die IronXLOperationen in einen catch-Block einbetten und dem Benutzer eine beschreibende Meldung zurückgeben, wenn etwas schiefgeht. Häufige Fehlerursachen sind ein fehlendes Verzeichnis ~/Exports/, Dateiberechtigungsfehler und der Wert ViewState, der 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}";
    }
}
$vbLabelText   $csharpLabel

Für Webanwendungen, die die Datei als direkten Browser-Download bereitstellen, anstatt sie auf der Festplatte zu speichern, verwenden Sie Response.BinaryWrite oder schreiben Sie nach dem Festlegen der Content-Type- und Disposition-Header in Response.OutputStream. Stellen Sie sicher, dass das Verzeichnis ~/Exports/ existiert und die Identität des IIS-Anwendungspools über Schreibberechtigungen dafür verfügt.

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

Ersetzen Sie workbook.SaveAs(filePath) durch eine streambasierte 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();
$vbLabelText   $csharpLabel

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

Wie exportiert man mehrere Tabellenblätter oder erweiterte Arbeitsmappen?

Ein einzelnes WorkBook kann mehrere Tabellenblätter enthalten. Dies ist nützlich, wenn Sie mehrere GridViews – oder denselben Datensatz mit unterschiedlicher Granularität – in eine Datei exportieren müssen. Rufen Sie workbook.CreateWorkSheet(name) einmal für jedes Tabellenblatt 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"));
$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 umfangreichere Ergebnisse bietet IronXLUnterstützung für Excel-Formeln , bedingte Formatierung, Diagrammerstellung und Bildeinbettung . Diese Funktionen sind im Tutorial-Bereich von IronXL dokumentiert.

Wie schneidet IronXLim 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 IronXLzu 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 Lizenzbeschränkungen Ihres Projekts, den benötigten Excel-Funktionen und der Frage ab, ob die Unterstützung des älteren .xls-Formats erforderlich ist.

Welche Excel-Formate unterstützt IronXL?

IronXL liest und schreibt die Formate .xlsx (Office Open XML), .xls (Legacy BIFF8), .csv und .tsv. Sie können zwischen verschiedenen Excel-Dateiformaten mit einem einzigen API-Aufruf konvertieren , indem Sie den an WorkBook.Create übergebenen Enumerationswert ExcelFileFormat ändern 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:

  • Zeileniterationsexport -- der schnellste Weg zu einem funktionierenden Export aus einer gebundenen 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 mit MemoryStream und Response.BinaryWrite hinzu, damit die Benutzer die Datei sofort ohne serverseitigen Speicherpfad erhalten.
  2. Zellenformatierung anwenden – fette Überschriften, Hintergrundfarben und Zahlenformate – mithilfe 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 mithilfe der IronXL-Read-API für Roundtrip-Import/Export-Workflows wieder in DataTable-Objekte ein.
  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 IronXLintegrieren, um Arbeitsblätter direkt in das PDF-Format zu exportieren. Die Iron Suite bündelt IronXLmit 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.

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

We're online 24 hours, 5 days a week.
Chat
Email
Call Me