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

Datenexport nach Excel in C# mit IronXL | Keine Office-Lizenz erforderlich

Jordi Bardia
Jordi Bardia
Aktualisiert:

Der Export eines DataSets oder einer DataTable nach Excel in C# bietet eine zuverlässige Möglichkeit, strukturierte Daten aus dem Arbeitsspeicher in professionelle Tabellenkalkulationsdateien umzuwandeln – ohne dass Microsoft Office auf dem Zielrechner installiert sein muss. Ob Sie Datensätze aus einer SQL-Datenbank abrufen, ein DataSet programmatisch erstellen oder mit einem vorhandenen DataGrid arbeiten: IronXL verarbeitet den gesamten Prozess über eine übersichtliche, codebasierte API. Dieser Leitfaden behandelt alle wichtigen Szenarien – vom Export einer einzelnen Tabelle über Arbeitsmappen mit mehreren Tabellenblättern bis hin zu Live-Datenbankabfrageergebnissen – unter Verwendung von C#-Anweisungen auf oberster Ebene und .NET 10.

Installieren Sie IronXL einmal, schreiben Sie ein paar Codezeilen, und Ihre Daten befinden sich in einer XLSX-Datei – ganz ohne Office-Abhängigkeiten. Die folgenden Abschnitte behandeln Installation, grundlegende Muster, erweiterte Formatierung und Datenbankintegration so, dass Sie sie direkt in Ihre eigenen Projekte kopieren und einfügen können.

Wie installiert man IronXL für den Excel-Export?

Bevor Sie Exportcode schreiben, fügen Sie IronXL über den NuGet Paketmanager zu Ihrem Projekt hinzu. Öffnen Sie ein Terminal im Stammverzeichnis Ihres Projekts und führen Sie den .NET CLI-Befehl aus, oder verwenden Sie die Paket-Manager-Konsole in Visual Studio mit dem Befehl Install-Package:

dotnet add package IronXl.Excel
# Or in Visual Studio Package Manager Console:
# Install-Package IronXl.Excel
dotnet add package IronXl.Excel
# Or in Visual Studio Package Manager Console:
# Install-Package IronXl.Excel
SHELL

Fügen Sie nach der Installation eine using-Anweisung auf oberster Ebene hinzu, um den IronXL Namensraum zu importieren:

using IronXL;
using System.Data;
using IronXL;
using System.Data;
$vbLabelText   $csharpLabel

IronXL ist for .NET 8, .NET 9 und .NET 10 sowie ältere .NET Framework Versionen (4.6.2+) geeignet. Es ist keine Office-Installation auf irgendeinem Rechner erforderlich – weder auf Servern, Desktop-Computern noch in der Cloud. Sobald das Paket installiert ist, können Sie XLSX-, XLS- und CSV-Dateien vollständig im verwalteten Code erstellen, lesen und schreiben.

Ausführliche Installationsoptionen finden Sie im IronXL Installationshandbuch und auf der NuGet Paketseite unter Versionsverlauf.

Wie exportiert man eine einzelne Datentabelle in eine Excel-Datei?

Am häufigsten wird eine DataTable in ein einzelnes Arbeitsblatt exportiert. Die IronXL-Klassen WorkBook und WorkSheet lassen sich auf natürliche Weise auf das Excel-Objektmodell abbilden. Sie erstellen eine Arbeitsmappe, fügen ein Arbeitsblatt hinzu und durchlaufen dann die Spalten und Zeilen der DataTable.

Das folgende Beispiel erstellt eine Mitarbeiter-DataTable im Arbeitsspeicher und schreibt sie nach EmployeeData.xlsx:

using IronXL;
using System.Data;

// Build an in-memory DataTable
DataTable dt = new DataTable("Employees");
dt.Columns.Add("ID", typeof(int));
dt.Columns.Add("Name", typeof(string));
dt.Columns.Add("Department", typeof(string));

dt.Rows.Add(1, "John Smith", "Engineering");
dt.Rows.Add(2, "Sarah Jones", "Marketing");
dt.Rows.Add(3, "Mike Wilson", "Sales");

// Create a workbook and a named worksheet
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("Employees");

// Write column headers in row 0
for (int col = 0; col < dt.Columns.Count; col++)
{
    worksheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
}

// Write data rows starting at row 1
for (int row = 0; row < dt.Rows.Count; row++)
{
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        worksheet.SetCellValue(row + 1, col, dt.Rows[row][col].ToString());
    }
}

workbook.SaveAs("EmployeeData.xlsx");
using IronXL;
using System.Data;

// Build an in-memory DataTable
DataTable dt = new DataTable("Employees");
dt.Columns.Add("ID", typeof(int));
dt.Columns.Add("Name", typeof(string));
dt.Columns.Add("Department", typeof(string));

dt.Rows.Add(1, "John Smith", "Engineering");
dt.Rows.Add(2, "Sarah Jones", "Marketing");
dt.Rows.Add(3, "Mike Wilson", "Sales");

// Create a workbook and a named worksheet
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("Employees");

// Write column headers in row 0
for (int col = 0; col < dt.Columns.Count; col++)
{
    worksheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
}

// Write data rows starting at row 1
for (int row = 0; row < dt.Rows.Count; row++)
{
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        worksheet.SetCellValue(row + 1, col, dt.Rows[row][col].ToString());
    }
}

workbook.SaveAs("EmployeeData.xlsx");
$vbLabelText   $csharpLabel

Ausgabe

So exportieren Sie ein Dataset nach Excel in .NET: Eine vollständige Anleitung mit IronXL: Bild 1 – Ausgabe für den Export einer einfachen DataTable nach Excel in .NET

SetCellValue akzeptiert int, double, string und bool -- sodass Sie native Excel-Zelltypen ohne zusätzliche Typumwandlung erhalten. Das Schleifenmuster funktioniert für Tabellen jeder Größe, da IronXL direkt in den Speicher schreibt und erst dann auf die Festplatte schreibt, wenn SaveAs aufgerufen wird. Dadurch bleibt der Prozess auch bei Tausenden von Zeilen effizient.

Für einen umfassenderen Überblick über Lese- und Schreibtechniken behandelt das IronXL C#-Tutorial die gesamte Bandbreite der Dateioperationen zusammen mit diesem Exportmuster.

Wie exportiert man einen Datensatz in mehrere Excel-Arbeitsblätter?

Wenn ein DataSet mehrere zusammengehörige Tabellen enthält – wie z. B. Produkte und Bestellungen –, können Sie jede DataTable einem eigenen Arbeitsblatt innerhalb einer Arbeitsmappe zuordnen. Dadurch können die Empfänger alle zugehörigen Daten in einer einzigen Datei einsehen, ohne mehrere Dokumente öffnen zu müssen.

Die untenstehende Schleife iteriert ds.Tables und erstellt für jede Tabelle ein eigenes Tabellenblatt:

using IronXL;
using System.Data;

// Build a DataSet with two related tables
DataSet ds = new DataSet("CompanyData");

DataTable dtProducts = new DataTable("Products");
dtProducts.Columns.Add("ProductID", typeof(int));
dtProducts.Columns.Add("ProductName", typeof(string));
dtProducts.Columns.Add("Price", typeof(decimal));
dtProducts.Rows.Add(101, "Widget A", 29.99m);
dtProducts.Rows.Add(102, "Widget B", 49.99m);
ds.Tables.Add(dtProducts);

DataTable dtOrders = new DataTable("Orders");
dtOrders.Columns.Add("OrderID", typeof(int));
dtOrders.Columns.Add("Customer", typeof(string));
dtOrders.Columns.Add("Total", typeof(decimal));
dtOrders.Rows.Add(1001, "Acme Corp", 599.90m);
dtOrders.Rows.Add(1002, "Tech Inc", 299.95m);
ds.Tables.Add(dtOrders);

// Create one workbook and iterate each DataTable
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);

foreach (DataTable table in ds.Tables)
{
    WorkSheet sheet = workbook.CreateWorkSheet(table.TableName);

    // Write headers
    for (int col = 0; col < table.Columns.Count; col++)
    {
        sheet.SetCellValue(0, col, table.Columns[col].ColumnName);
    }

    // Write rows
    for (int row = 0; row < table.Rows.Count; row++)
    {
        for (int col = 0; col < table.Columns.Count; col++)
        {
            sheet.SetCellValue(row + 1, col, table.Rows[row][col].ToString());
        }
    }
}

workbook.SaveAs("CompanyReport.xlsx");
using IronXL;
using System.Data;

// Build a DataSet with two related tables
DataSet ds = new DataSet("CompanyData");

DataTable dtProducts = new DataTable("Products");
dtProducts.Columns.Add("ProductID", typeof(int));
dtProducts.Columns.Add("ProductName", typeof(string));
dtProducts.Columns.Add("Price", typeof(decimal));
dtProducts.Rows.Add(101, "Widget A", 29.99m);
dtProducts.Rows.Add(102, "Widget B", 49.99m);
ds.Tables.Add(dtProducts);

DataTable dtOrders = new DataTable("Orders");
dtOrders.Columns.Add("OrderID", typeof(int));
dtOrders.Columns.Add("Customer", typeof(string));
dtOrders.Columns.Add("Total", typeof(decimal));
dtOrders.Rows.Add(1001, "Acme Corp", 599.90m);
dtOrders.Rows.Add(1002, "Tech Inc", 299.95m);
ds.Tables.Add(dtOrders);

// Create one workbook and iterate each DataTable
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);

foreach (DataTable table in ds.Tables)
{
    WorkSheet sheet = workbook.CreateWorkSheet(table.TableName);

    // Write headers
    for (int col = 0; col < table.Columns.Count; col++)
    {
        sheet.SetCellValue(0, col, table.Columns[col].ColumnName);
    }

    // Write rows
    for (int row = 0; row < table.Rows.Count; row++)
    {
        for (int col = 0; col < table.Columns.Count; col++)
        {
            sheet.SetCellValue(row + 1, col, table.Rows[row][col].ToString());
        }
    }
}

workbook.SaveAs("CompanyReport.xlsx");
$vbLabelText   $csharpLabel

Ausgabe

So exportieren Sie Datensätze nach Excel ( .NET): Eine vollständige Anleitung mit IronXL: Bild 2 – Generierte Excel-Datei mit den exportierten Datensätzen als separate Arbeitsblätter

Jedes Arbeitsblatt ist nach der Quell-DataTable benannt, was die Navigation in Excel vereinfacht. Da WorkBook.Create die Arbeitsmappe im Speicher allokiert, können Sie in der Schleife immer wieder Arbeitsblätter hinzufügen, ohne die Datei erneut öffnen zu müssen – IronXL erstellt die gesamte XLSX-Struktur, bevor sie auf die Festplatte geschrieben wird.

Die IronXL WorkBook-Dokumentation listet alle für das WorkBook-Objekt verfügbaren Methoden auf, einschließlich der Neuanordnung von Blättern, des Passwortschutzes und des Speicherns in anderen Formaten als XLSX.

Wie fügt man Excel-Exporten eine Kopfzeilenformatierung hinzu?

Einfache Datenexporte sind zwar funktional, aber durch das Hinzufügen von fettgedruckten Überschriften und Spaltenbreiten wird der Output sofort im Geschäftskontext nutzbar. IronXL stellt Zell- und Bereichsstyling über das Style-Objekt bereit, das an jeden WorkSheet-Bereich angehängt ist.

Der folgende Codeausschnitt formatiert die Kopfzeile fett und passt die Spaltenbreite nach dem Schreiben der Daten automatisch an:

using IronXL;
using System.Data;

DataTable dt = new DataTable("Sales");
dt.Columns.Add("Region", typeof(string));
dt.Columns.Add("Q1", typeof(decimal));
dt.Columns.Add("Q2", typeof(decimal));
dt.Columns.Add("Q3", typeof(decimal));
dt.Columns.Add("Q4", typeof(decimal));

dt.Rows.Add("Neinrth", 120000m, 135000m, 142000m, 158000m);
dt.Rows.Add("South", 98000m, 104000m, 112000m, 121000m);
dt.Rows.Add("East",  87000m, 93000m,  99000m,  108000m);
dt.Rows.Add("West",  145000m, 152000m, 161000m, 174000m);

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Sales");

// Write and style headers
for (int col = 0; col < dt.Columns.Count; col++)
{
    sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
    sheet["A1:E1"].Style.Font.Bold = true;
    sheet["A1:E1"].Style.Font.Height = 12;
}

// Write data rows
for (int row = 0; row < dt.Rows.Count; row++)
{
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        sheet.SetCellValue(row + 1, col, dt.Rows[row][col]);
    }
}

workbook.SaveAs("SalesReport.xlsx");
using IronXL;
using System.Data;

DataTable dt = new DataTable("Sales");
dt.Columns.Add("Region", typeof(string));
dt.Columns.Add("Q1", typeof(decimal));
dt.Columns.Add("Q2", typeof(decimal));
dt.Columns.Add("Q3", typeof(decimal));
dt.Columns.Add("Q4", typeof(decimal));

dt.Rows.Add("Neinrth", 120000m, 135000m, 142000m, 158000m);
dt.Rows.Add("South", 98000m, 104000m, 112000m, 121000m);
dt.Rows.Add("East",  87000m, 93000m,  99000m,  108000m);
dt.Rows.Add("West",  145000m, 152000m, 161000m, 174000m);

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Sales");

// Write and style headers
for (int col = 0; col < dt.Columns.Count; col++)
{
    sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
    sheet["A1:E1"].Style.Font.Bold = true;
    sheet["A1:E1"].Style.Font.Height = 12;
}

// Write data rows
for (int row = 0; row < dt.Rows.Count; row++)
{
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        sheet.SetCellValue(row + 1, col, dt.Rows[row][col]);
    }
}

workbook.SaveAs("SalesReport.xlsx");
$vbLabelText   $csharpLabel

Die Eigenschaft Style.Font.Bold gilt für den gesamten Headerbereich in einer einzigen Anweisung. IronXL unterstützt außerdem Hintergrundfarben (Style.BackgroundColor), Rahmenstile (Style.Border), Zahlenformate (Style.NumberFormat.FormatCode) und horizontale Ausrichtung (Style.HorizontalAlignment). Eine vollständige Übersicht über die Formatierungsrichtlinien finden Sie im IronXL Leitfaden zur Zellformatierung .

Wie exportiert man Datenbankabfrageergebnisse nach Excel?

Die Verbindung zu einer SQL-Datenbank und der direkte Export der Ergebnisse nach Excel deckt einen wichtigen Anwendungsfall in der Praxis ab – geplante Berichte, Daten-Snapshots und administrative Exporte. Bei diesem Ansatz wird ein DataSet mit SqlDataAdapter gefüllt und die resultierende DataTable anschließend einem IronXL Arbeitsblatt zugeordnet.

using IronXL;
using System.Data;
using System.Data.SqlClient;

string connectionString = "Server=localhost;Database=SalesDB;Integrated Security=True;";
string query = "SELECT CustomerID, CompanyName, ContactName, Country FROM Customers";

// Fill DataSet from SQL query
DataSet ds = new DataSet();
using (SqlConnection connection = new SqlConnection(connectionString))
{
    SqlDataAdapter adapter = new SqlDataAdapter(query, connection);
    adapter.Fill(ds, "Customers");
}

DataTable dt = ds.Tables["Customers"]!;

// Create workbook and export
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("CustomerData");

// Bold header row
for (int col = 0; col < dt.Columns.Count; col++)
{
    worksheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
}
worksheet["A1:D1"].Style.Font.Bold = true;

// Write rows, handling DBNull values safely
for (int row = 0; row < dt.Rows.Count; row++)
{
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        object cellValue = dt.Rows[row][col];
        worksheet.SetCellValue(row + 1, col,
            cellValue == DBNull.Value ? "" : cellValue.ToString()!);
    }
}

workbook.SaveAs("CustomerExport.xlsx");
Console.WriteLine("Export complete.");
using IronXL;
using System.Data;
using System.Data.SqlClient;

string connectionString = "Server=localhost;Database=SalesDB;Integrated Security=True;";
string query = "SELECT CustomerID, CompanyName, ContactName, Country FROM Customers";

// Fill DataSet from SQL query
DataSet ds = new DataSet();
using (SqlConnection connection = new SqlConnection(connectionString))
{
    SqlDataAdapter adapter = new SqlDataAdapter(query, connection);
    adapter.Fill(ds, "Customers");
}

DataTable dt = ds.Tables["Customers"]!;

// Create workbook and export
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("CustomerData");

// Bold header row
for (int col = 0; col < dt.Columns.Count; col++)
{
    worksheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
}
worksheet["A1:D1"].Style.Font.Bold = true;

// Write rows, handling DBNull values safely
for (int row = 0; row < dt.Rows.Count; row++)
{
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        object cellValue = dt.Rows[row][col];
        worksheet.SetCellValue(row + 1, col,
            cellValue == DBNull.Value ? "" : cellValue.ToString()!);
    }
}

workbook.SaveAs("CustomerExport.xlsx");
Console.WriteLine("Export complete.");
$vbLabelText   $csharpLabel

Wichtige Punkte für den Datenbankexport

Der Nullschutz (cellValue == DBNull.Value ? "" : cellValue.ToString()) prevents exceptions when the database returns NULL Werte -- ein häufiges Vorkommen bei optionalen Spalten. Durch die Fettdruckformatierung in der Kopfzeile können die Empfänger des Berichts die Überschriften sofort von den eigentlichen Daten unterscheiden.

Weitere Beispiele für das Zurücklesen von Daten aus Excel in C#-Objekte finden Sie im IronXL DataTable-Export-Tutorial, das zeigt, wie dieser Arbeitsablauf umgekehrt werden kann.

Wie vergleichen Sie IronXL mit anderen Excel-Exportmethoden?

Bevor man sich für eine Bibliothek entscheidet, ist es hilfreich zu verstehen, wie die wichtigsten Optionen im Vergleich zueinander in den Bereichen abschneiden, die für DataSet-Export-Szenarien am wichtigsten sind.

Vergleich der Excel-Exportbibliotheken for .NET -DataSet-Szenarien
Ansatz Büro erforderlich XLSX-Unterstützung Styling-API Mehrblatt Leistung (große Datenmengen)
IronXL Nein Ja Vollständige Ja Hoch
Microsoft Office Interop Ja Ja Vollständige Ja Niedrig
EPPlus Nein Ja Teilweise Ja Hoch
ClosedXML Nein Ja Teilweise Ja Medium
CSV (manuell) Nein Nein Keine Nein Sehr hoch

Microsoft Office Interop funktioniert nur auf Windows-Rechnern, auf denen Office installiert ist, wodurch es für Serverbereitstellungen und Cloud-Funktionen ausscheidet. IronXL, EPPlus und ClosedXML unterstützen alle die serverseitige Generierung – der entscheidende Unterschied liegt im Umfang der Styling-API und des Lizenzmodells. Die Lizenzierung von IronXL umfasst die kommerzielle Nutzung und deckt alle .NET Zielframeworks mit einem einzigen Paket ab.

Für Benchmarks und Vergleiche von Drittanbietern bieten die Microsoft-Dokumentation zu Excel-Dateiformaten und die EPPlus-Projektseite zusätzlichen Kontext, um die richtige Wahl für Ihr Projekt zu treffen.

Wie verarbeitet man große Datensätze ohne Speicherprobleme?

Beim Export von DataTables mit Zehntausenden von Zeilen ist eine vorhersehbare Speichernutzung wichtig. Das unten stehende Muster streamt Daten aus einem IDataReader, anstatt das gesamte Ergebnis-Set zuerst in eine DataTable zu laden. Dadurch wird der doppelte Speicherbedarf vermieden, der durch das gleichzeitige Halten des Lesepuffers und der DataTable entsteht.

using IronXL;
using System.Data;
using System.Data.SqlClient;

string connectionString = "Server=localhost;Database=InventoryDB;Integrated Security=True;";
string query = "SELECT ProductID, SKU, Description, StockLevel, UnitCost FROM Products";

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Inventory");

using SqlConnection conn = new SqlConnection(connectionString);
conn.Open();

using SqlCommand cmd = new SqlCommand(query, conn);
using SqlDataReader reader = cmd.ExecuteReader();

// Write schema-derived headers
for (int col = 0; col < reader.FieldCount; col++)
{
    sheet.SetCellValue(0, col, reader.GetName(col));
}

// Stream rows directly into IronXL without buffering a DataTable
int excelRow = 1;
while (reader.Read())
{
    for (int col = 0; col < reader.FieldCount; col++)
    {
        sheet.SetCellValue(excelRow, col,
            reader.IsDBNull(col) ? "" : reader.GetValue(col).ToString()!);
    }
    excelRow++;
}

workbook.SaveAs("InventoryExport.xlsx");
Console.WriteLine($"Exported {excelRow - 1} rows.");
using IronXL;
using System.Data;
using System.Data.SqlClient;

string connectionString = "Server=localhost;Database=InventoryDB;Integrated Security=True;";
string query = "SELECT ProductID, SKU, Description, StockLevel, UnitCost FROM Products";

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Inventory");

using SqlConnection conn = new SqlConnection(connectionString);
conn.Open();

using SqlCommand cmd = new SqlCommand(query, conn);
using SqlDataReader reader = cmd.ExecuteReader();

// Write schema-derived headers
for (int col = 0; col < reader.FieldCount; col++)
{
    sheet.SetCellValue(0, col, reader.GetName(col));
}

// Stream rows directly into IronXL without buffering a DataTable
int excelRow = 1;
while (reader.Read())
{
    for (int col = 0; col < reader.FieldCount; col++)
    {
        sheet.SetCellValue(excelRow, col,
            reader.IsDBNull(col) ? "" : reader.GetValue(col).ToString()!);
    }
    excelRow++;
}

workbook.SaveAs("InventoryExport.xlsx");
Console.WriteLine($"Exported {excelRow - 1} rows.");
$vbLabelText   $csharpLabel

Dieses Vorgehen empfiehlt sich, wenn das Ergebnis-Set mehr als 50.000 Zeilen umfassen kann oder wenn die Anwendung in einem speicherbeschränkten Dienst ausgeführt wird. Die IronXL Leistungsdokumentation enthält weitere Optionen zur Optimierung von Speicher und Durchsatz für Exporte mit hohem Datenvolumen.

Stapelspeicherung im CSV-Format für sehr große Exporte

Bei Exporten mit mehr als 500.000 Zeilen, bei denen der Speicherplatz extrem knapp ist, sollten Sie erwägen, die Ausgabe auf mehrere Arbeitsmappen aufzuteilen oder stattdessen im CSV-Format zu exportieren:

using IronXL;

// IronXL can save any workbook as CSV
workbook.SaveAs("LargeExport.csv");
using IronXL;

// IronXL can save any workbook as CSV
workbook.SaveAs("LargeExport.csv");
$vbLabelText   $csharpLabel

CSV verliert zwar die Formatierung und die Unterstützung für mehrere Tabellenblätter, bleibt aber für nachgelagerte ETL-Prozesse, die rohe, durch Trennzeichen getrennte Daten verarbeiten, gültig.

Wie speichert man Excel-Dateien in verschiedenen Formaten und an verschiedenen Orten?

IronXL unterstützt das Speichern unter Dateipfad, MemoryStream und byte[] -- was für ASP.NET Anwendungen wichtig ist, die Excel als Download-Antwort zurückgeben.

using IronXL;
using System.IO;

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Report");
sheet.SetCellValue(0, 0, "Generated Report");

// Save to file path
workbook.SaveAs("Report.xlsx");

// Save as XLS (legacy format)
workbook.SaveAs("Report.xls");

// Save to MemoryStream for HTTP response
using MemoryStream ms = new MemoryStream();
workbook.SaveAs(ms);
byte[] fileBytes = ms.ToArray();
// fileBytes can be returned from an ASP.NET controller action
using IronXL;
using System.IO;

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Report");
sheet.SetCellValue(0, 0, "Generated Report");

// Save to file path
workbook.SaveAs("Report.xlsx");

// Save as XLS (legacy format)
workbook.SaveAs("Report.xls");

// Save to MemoryStream for HTTP response
using MemoryStream ms = new MemoryStream();
workbook.SaveAs(ms);
byte[] fileBytes = ms.ToArray();
// fileBytes can be returned from an ASP.NET controller action
$vbLabelText   $csharpLabel

Für ASP.NET Core geben Sie File(fileBytes, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "Report.xlsx") von Ihrer Controller-Aktion zurück, um einen Browser-Download auszulösen. Der IronXL ASP.NET Excel-Leitfaden zeigt das vollständige Controller-Integrationsmuster.

Für alternative .NET Excel-Bibliotheken dient das Open XML SDK als Open-Source-Grundlage, auf der viele Bibliotheken aufbauen.

Unterstützte Ausgabeformate

IronXL speichert ohne zusätzliche Abhängigkeiten in den folgenden Formaten:

  • XLSX – OpenXML-Format, kompatibel mit Excel 2007 und höher
  • XLS – Älteres Binärformat, kompatibel mit Excel 97-2003
  • CSV – Kommagetrennte Werte, universell unterstützt
  • TSV -- Tabulatorgetrennte Werte
  • JSON -- Export strukturierter Daten

Das Format kann durch Ändern der Dateierweiterung im Pfad SaveAs oder durch Verwendung der überladenen Methode, die einen Enumerationswert ExcelFileFormat akzeptiert, gewechselt werden.

Wie kann man überprüfen, ob die exportierte Excel-Datei korrekt ist?

Nach dem Export können Sie die Datei mit IronXL wieder einlesen, um die Zeilenanzahl zu überprüfen, Stichproben von Werten durchzuführen oder automatisierte Assertions in einem Testprojekt auszuführen:

using IronXL;

WorkBook loaded = WorkBook.Load("EmployeeData.xlsx");
WorkSheet sheet = loaded.WorkSheets[0];

// Verify row count (header row + data rows)
int totalRows = sheet.Rows.Count();
Console.WriteLine($"Rows in file: {totalRows}");

// Spot-check specific cell values
string header = sheet["A1"].StringValue;
string firstEmployee = sheet["A2"].StringValue;

Console.WriteLine($"Header: {header}, First row: {firstEmployee}");
using IronXL;

WorkBook loaded = WorkBook.Load("EmployeeData.xlsx");
WorkSheet sheet = loaded.WorkSheets[0];

// Verify row count (header row + data rows)
int totalRows = sheet.Rows.Count();
Console.WriteLine($"Rows in file: {totalRows}");

// Spot-check specific cell values
string header = sheet["A1"].StringValue;
string firstEmployee = sheet["A2"].StringValue;

Console.WriteLine($"Header: {header}, First row: {firstEmployee}");
$vbLabelText   $csharpLabel

Dieses Verifizierungsmuster ist besonders nützlich in Integrationstest-Suites, in denen die Korrektheit des Exports bestätigt werden muss, bevor Dateien an externe Systeme gesendet werden. Das IronXL Lese-Tutorial zeigt die gesamte Bandbreite der Leseoperationen, die nach dem Laden einer Datei verfügbar sind.

Weiterführende Informationen zu DataSet- und DataTable-Mustern in .NET finden Sie in der Microsoft DataSet-Dokumentation , die das ADO .NET -Objektmodell ausführlich behandelt.

Was sind Ihre nächsten Schritte?

Sie verfügen nun über Arbeitsmuster für jedes wichtige DataSet-zu-Excel-Exportszenario in C# – von einer einzelnen DataTable bis hin zu Arbeitsmappen mit mehreren Tabellenblättern, datenbankgesteuerten Exporten, formatierten Kopfzeilen und dem Streaming großer Datenmengen. So gehen Sie je nach Ihrem Ziel vor:

  • Testen Sie IronXL kostenlos -- Beginnen Sie mit einer kostenlosen Testlizenz und führen Sie die oben genannten Beispiele mit Ihren eigenen Daten durch, bevor Sie IronXL in der Produktion einsetzen.
  • Lesen Sie die vollständige API-Referenz -- Die IronXL Objektreferenz umfasst alle Methoden für WorkBook, WorkSheet und Zellbereiche.
  • Entdecken Sie verwandte Export-Tutorials -- Der Leitfaden "C# DataTable zu Excel" behandelt den umgekehrten Arbeitsablauf – das Einlesen von Excel-Daten zurück in DataTable-Objekte.
  • Formatierungsoptionen prüfen -- Die IronXL -Dokumentation zur Zellformatierung zeigt Zahlenformate, Rahmen, Hintergrundfarben und Ausrichtungsoptionen.
  • Lizenzierung prüfen -- Für Produktionsumgebungen können Sie auf der IronXL -Lizenzierungsseite zwischen den Optionen Entwickler, Organisation und lizenzgebührenfrei wählen.
  • Vergleich mit anderen Iron Software Tools - Falls Ihr Projekt auch die PDF-Generierung oder OCR erfordert, können Sie mit der Iron Software Produktpalette mehrere Bibliotheken zu einem reduzierten Preis bündeln.

Aufbauend auf den hier vorgestellten Mustern können Sie die Automatisierung geplanter Aufgaben, ASP.NET Core -Download-Endpunkte und Multi-Format-Ausgabepipelines vollständig in verwaltetem C# integrieren – ohne Office, ohne COM und ohne Laufzeitabhängigkeiten über das NuGet Paket hinaus.

Häufig gestellte Fragen

Wie kann ich in C# ein DataSet nach Excel exportieren?

Sie können ein DataSet in C# mit Hilfe der IronXL Bibliothek nach Excel exportieren. Diese bietet eine Code-First-API zum Erstellen, Bearbeiten und Manipulieren von Excel-Dateien, ohne dass Microsoft Office erforderlich ist.

Muss ich Microsoft Office installiert haben, um IronXL zu verwenden?

Nein, IronXL benötigt kein auf dem Rechner installiertes Microsoft Office zum Exportieren oder Bearbeiten von Excel-Dateien.

Welche Datentypen kann ich mit IronXL exportieren?

Mit IronXL können Sie strukturierte Daten wie DataTables und DataSets in Excel-Dateien exportieren, ebenso wie Daten aus SqlDataReader und anderen ADO .NET Quellen.

Kann IronXL die Erstellung und Bearbeitung von Excel-Dateien verarbeiten?

Ja, IronXL bietet die Möglichkeit, Excel-Dateien programmatisch in C# zu erstellen, zu bearbeiten und zu manipulieren.

Ist IronXL für serverseitige und Cloud-Anwendungen geeignet?

Ja, IronXL eignet sich ideal für serverseitige Anwendungen und Cloud-Funktionen, die Excel-Dateien ohne Office-Installation generieren müssen.

Welche Vorteile bietet die Verwendung von IronXL zum Exportieren von Datensätzen?

IronXL übernimmt die Erstellung und Bearbeitung von Excel-Dateien ohne externe Abhängigkeiten wie Microsoft Office, unterstützt die Formate XLSX, XLS und CSV und funktioniert auf allen .NET Zielframeworks.

Kann IronXL in ASP.NET Core verwendet werden, um einen Excel-Download zurückzugeben?

Ja, IronXL kann Arbeitsmappen in einem MemoryStream speichern, und das resultierende Byte-Array kann von einer ASP.NET Core -Controller-Aktion als Datei-Download zurückgegeben werden.

Unterstützt IronXL große Datensätze?

Ja, IronXL kann Daten direkt aus SqlDataReader streamen, ohne eine vollständige DataTable zwischenzuspeichern, wodurch der Speicherverbrauch auch bei großen Ergebnismengen vorhersehbar bleibt.

Welche Excel-Formate unterstützt IronXL zum Speichern?

IronXL unterstützt das Speichern in den Formaten XLSX, XLS, CSV, TSV und JSON ohne zusätzliche Abhängigkeiten.

Kann ich beim Export nach Excel Formatierungen wie fettgedruckte Überschriften anwenden?

Ja, IronXL bietet eine Style-API für Zellbereiche mit Optionen für Fettdruck, Hintergrundfarben, Rahmen, Zahlenformate und Ausrichtung.

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