Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. Iron Software
  2. IronXL Blog
  3. IronXL verwenden
  4. Datentabelle mit OLED exportieren
IRONXL VERWENDEN

Datentabelle nach Excel exportieren (C#) mit OleDb vs. IronXL

Jordi Bardia
Jordi Bardia
Aktualisiert:

Mit der richtigen Bibliothek ist der Export einer DataTable in eine Excel-Datei in C# – ohne Office-Abhängigkeiten – unkompliziert. Sie rufen WorkBook.Create() auf, schreiben Header von dataTable.Columns, durchlaufen dataTable.Rows, um Zellen zu füllen, und speichern dann mit workbook.SaveAs("output.xlsx"). Das Ergebnis ist eine vollständig formatierte XLSX-Datei, die auf jeder Plattform funktioniert, einschließlich .NET 10, Linux-Containern und Azure Serverless Functions.

Dieser Leitfaden vergleicht den herkömmlichen OleDB-Ansatz mit der modernen IronXL Methode for .NET . Sie werden sehen, warum der OleDB-Treiber Bereitstellungs- und Kompatibilitätsprobleme verursacht und wie Sie ihn durch sauberen, wartungsfreundlichen Code ersetzen können, der Spaltenüberschriften, Datentypen, Zellformatierung und große Datensätze ohne SQL-Syntax oder Installationen von Treibern, die nur unter Windows verfügbar sind, verarbeitet.

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

Bevor Sie Exportcode schreiben, fügen Sie IronXL zu Ihrem Projekt hinzu. Öffnen Sie die Paketmanager-Konsole in Visual Studio und führen Sie den Befehl aus:

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

IronXL ist nicht von Microsoft Office, der Access-Datenbank-Engine oder einer COM-Interop-Schicht abhängig. Sobald das Paket installiert ist, können Sie denselben Code unter Windows, Linux, macOS, Docker, Azure und AWS ausführen, ohne eine einzige Zeile ändern zu müssen.

Warum OleDB die Installation eines Treibers erfordert

Der traditionelle OleDB-Ansatz behandelt eine Excel-Datei wie eine Datenbank. Sie erstellen eine OleDBConnection-Verbindung mit dem Microsoft.ACE.OLEDB.12.0-Provider (oder dem älteren Microsoft.Jet.OLEDB.4.0 für .xls-Dateien) und führen dann die SQL-Befehle CREATE TABLE und INSERT INTO für die Tabelle aus. Dies funktioniert auf Entwicklerrechnern, auf denen Microsoft Office oder die eigenständige Access Database Engine bereits installiert ist. Allerdings ist dieser Treiber in Produktionsumgebungen – insbesondere in Cloud-Funktionen, Docker-Containern und Serverfarmen, auf denen .NET 10 ohne grafische Oberfläche läuft – selten verfügbar, und seine Installation erfordert erhöhte Berechtigungen sowie eine passende Bit-Architektur zwischen Treiber und Prozess.

Warum verwenden Entwickler immer noch OleDB für Excel-Exporte?

OleDB wurde zur Standardwahl für die Excel-Automatisierung, da es bereits Teil des .NET Framework war. Da die Entwickler ADO .NET bereits kannten, fühlte es sich natürlich an, OleDBConnection, OleDBCommand und OleDBDataAdapter wiederzuverwenden, um in Excel zu schreiben. Es war kein Drittanbieterpaket erforderlich, und die SQL-ähnliche Syntax für CREATE TABLE und INSERT INTO machte die Absicht für jeden, der mit Datenbankprogrammierung vertraut war, offensichtlich.

Hier ist das traditionelle Muster für den Export einer DataTable mit OleDB:

using System.Data;
using System.Data.OleDB;

// Build a sample DataTable
DataTable dataTable = new DataTable("Products");
dataTable.Columns.Add("ProductID", typeof(int));
dataTable.Columns.Add("ProductName", typeof(string));
dataTable.Columns.Add("Price", typeof(decimal));
dataTable.Rows.Add(1, "Widget", 29.99m);
dataTable.Rows.Add(2, "Gadget", 49.99m);
dataTable.Rows.Add(3, "Gizmo", 19.99m);

// OleDB connection string -- file must already exist on disk
string filename = @"C:\Output\Products.xlsx";
string connectionString =
    $"Provider=Microsoft.ACE.OLEDB.12.0;Data Source={filename};" +
    "Extended Properties='Excel 12.0 Xml;HDR=YES'";

using OleDBConnection connection = new(connectionString);
connection.Open();

// Create the sheet structure with SQL DDL
string create = "CREATE TABLE [Sheet1$] (ProductID INT, ProductName CHAR(255), Price DOUBLE)";
using (var createCmd = new OleDBCommand(create, connection))
    createCmd.ExecuteNonQuery();

// Insert rows one at a time
string insert = "INSERT INTO [Sheet1$] (ProductID, ProductName, Price) VALUES (?, ?, ?)";
using OleDBCommand insertCmd = new(insert, connection);
insertCmd.Parameters.Add(new OleDBParameter("ProductID", OleDBType.Integer));
insertCmd.Parameters.Add(new OleDBParameter("ProductName", OleDBType.VarChar, 255));
insertCmd.Parameters.Add(new OleDBParameter("Price", OleDBType.Double));

foreach (DataRow row in dataTable.Rows)
{
    insertCmd.Parameters[0].Value = row["ProductID"];
    insertCmd.Parameters[1].Value = row["ProductName"];
    insertCmd.Parameters[2].Value = row["Price"];
    insertCmd.ExecuteNonQuery();
}
using System.Data;
using System.Data.OleDB;

// Build a sample DataTable
DataTable dataTable = new DataTable("Products");
dataTable.Columns.Add("ProductID", typeof(int));
dataTable.Columns.Add("ProductName", typeof(string));
dataTable.Columns.Add("Price", typeof(decimal));
dataTable.Rows.Add(1, "Widget", 29.99m);
dataTable.Rows.Add(2, "Gadget", 49.99m);
dataTable.Rows.Add(3, "Gizmo", 19.99m);

// OleDB connection string -- file must already exist on disk
string filename = @"C:\Output\Products.xlsx";
string connectionString =
    $"Provider=Microsoft.ACE.OLEDB.12.0;Data Source={filename};" +
    "Extended Properties='Excel 12.0 Xml;HDR=YES'";

using OleDBConnection connection = new(connectionString);
connection.Open();

// Create the sheet structure with SQL DDL
string create = "CREATE TABLE [Sheet1$] (ProductID INT, ProductName CHAR(255), Price DOUBLE)";
using (var createCmd = new OleDBCommand(create, connection))
    createCmd.ExecuteNonQuery();

// Insert rows one at a time
string insert = "INSERT INTO [Sheet1$] (ProductID, ProductName, Price) VALUES (?, ?, ?)";
using OleDBCommand insertCmd = new(insert, connection);
insertCmd.Parameters.Add(new OleDBParameter("ProductID", OleDBType.Integer));
insertCmd.Parameters.Add(new OleDBParameter("ProductName", OleDBType.VarChar, 255));
insertCmd.Parameters.Add(new OleDBParameter("Price", OleDBType.Double));

foreach (DataRow row in dataTable.Rows)
{
    insertCmd.Parameters[0].Value = row["ProductID"];
    insertCmd.Parameters[1].Value = row["ProductName"];
    insertCmd.Parameters[2].Value = row["Price"];
    insertCmd.ExecuteNonQuery();
}
Imports System.Data
Imports System.Data.OleDb

' Build a sample DataTable
Dim dataTable As New DataTable("Products")
dataTable.Columns.Add("ProductID", GetType(Integer))
dataTable.Columns.Add("ProductName", GetType(String))
dataTable.Columns.Add("Price", GetType(Decimal))
dataTable.Rows.Add(1, "Widget", 29.99D)
dataTable.Rows.Add(2, "Gadget", 49.99D)
dataTable.Rows.Add(3, "Gizmo", 19.99D)

' OleDB connection string -- file must already exist on disk
Dim filename As String = "C:\Output\Products.xlsx"
Dim connectionString As String = $"Provider=Microsoft.ACE.OLEDB.12.0;Data Source={filename};" &
                                 "Extended Properties='Excel 12.0 Xml;HDR=YES'"

Using connection As New OleDbConnection(connectionString)
    connection.Open()

    ' Create the sheet structure with SQL DDL
    Dim create As String = "CREATE TABLE [Sheet1$] (ProductID INT, ProductName CHAR(255), Price DOUBLE)"
    Using createCmd As New OleDbCommand(create, connection)
        createCmd.ExecuteNonQuery()
    End Using

    ' Insert rows one at a time
    Dim insert As String = "INSERT INTO [Sheet1$] (ProductID, ProductName, Price) VALUES (?, ?, ?)"
    Using insertCmd As New OleDbCommand(insert, connection)
        insertCmd.Parameters.Add(New OleDbParameter("ProductID", OleDbType.Integer))
        insertCmd.Parameters.Add(New OleDbParameter("ProductName", OleDbType.VarChar, 255))
        insertCmd.Parameters.Add(New OleDbParameter("Price", OleDbType.Double))

        For Each row As DataRow In dataTable.Rows
            insertCmd.Parameters(0).Value = row("ProductID")
            insertCmd.Parameters(1).Value = row("ProductName")
            insertCmd.Parameters(2).Value = row("Price")
            insertCmd.ExecuteNonQuery()
        Next
    End Using
End Using
$vbLabelText   $csharpLabel

Dieser Code fügt jede DataRow als separaten Datenbankzugriff ein. Bei großen Datensätzen wird diese Schleife zum Flaschenhals, da OleDB keinen Mechanismus zum stapelweisen Einfügen bietet. Jede Zeile löst einen vollständigen SQL-Parse-, Parameterbindungs- und Schreibzyklus aus, bevor mit der nächsten Zeile fortgefahren wird.

Was sind die wichtigsten Einschränkungen von OleDB für den Excel-Export?

Wenn Sie verstehen, warum OleDB seine Grenzen hat, können Sie die Migration gegenüber Ihrem Team besser rechtfertigen und den richtigen Ersatz auswählen.

Treiberabhängigkeiten und Bitkonflikte

Der Provider Microsoft.ACE.OLEDB.12.0 muss auf jedem Rechner, auf dem Ihre Anwendung ausgeführt wird, separat installiert werden. Wenn Ihr Prozess 64-Bit-fähig ist, aber nur die 32-Bit-Access-Datenbank-Engine verfügbar ist – eine häufige Konfiguration bei der Installation von Microsoft Office 32-Bit neben einer 64-Bit .NET Laufzeitumgebung – löst die Verbindung zur Laufzeit eine Ausnahme aus. Microsoft dokumentiert diese Bit-Beschränkungen und empfiehlt, die Bit-Architektur von Treiber und aufrufendem Prozess anzupassen. Dies ist jedoch in Shared-Hosting- oder Containerumgebungen oft nicht praktikabel.

Keine plattformübergreifende Unterstützung

OleDB ist eine Technologie, die nur unter Windows funktioniert. .NET 10 unterstützt Linux und macOS nativ, und moderne Architekturen führen Anwendungsworkloads zunehmend in Docker-Containern auf Linux-Knoten aus. Da der Namespace System.Data.OleDB auf Nicht-Windows-Betriebssystemen einen PlatformNotSupportedException auslöst, ist die Ausführung jeglicher Codepfade, die OleDB verwenden, auf diesen Plattformen vollständig blockiert.

Keine Zellformatierungsfunktionen

OleDB behandelt die Tabellenkalkulation wie eine flache Datenbanktabelle. Sie können Rohwerte einfügen, haben aber keine Möglichkeit, Schriftarten, Hintergrundfarben, Rahmen, Zahlenformate oder Spaltenbreiten festzulegen. Wenn Ihr Export einen professionell aussehenden Bericht mit Kopfzeilenformatierung, Währungsformatierung oder bedingter Farbgebung erfordert, kann OleDB dies nicht liefern. Sie bräuchten einen zweiten Durchlauf mit einer anderen Bibliothek oder dem Excel Interop COM-Objekt, das eine eigene Office-Abhängigkeit hinzufügt.

Die Excel-Datei muss bereits existieren.

OleDB kann keine neue Excel-Arbeitsmappe von Grund auf erstellen. Die Datei muss bereits im Zielpfad vorhanden sein, bevor Sie die Verbindung öffnen. Dies erfordert entweder eine vordefinierte Vorlagendatei oder einen separaten Schritt zur Erstellung der Arbeitsmappe mithilfe einer anderen Bibliothek, was die Komplexität des Bereitstellungspakets unnötig erhöht.

LÖSCHVORGÄNGE werden nicht unterstützt.

Der OleDB-Treiber für Excel unterstützt INSERT und eingeschränkte UPDATE Operationen, jedoch wird das Löschen von Zeilen mit DELETE FROM nicht unterstützt. Jeder Datenmanipulations-Workflow, der das Entfernen von Zeilen nach dem Export erfordert, muss auf eine manuelle Dateimanipulation oder eine vollständige Neuerstellung der Datei zurückgreifen, was beides über die OleDB-Schnittstelle nicht unkompliziert ist.

Wie exportiert man eine DataTable mit IronXL nach Excel?

IronXL ersetzt die gesamte OleDB-Pipeline durch ein direktes Objektmodell. Es gibt keine Verbindungszeichenfolgen, keine SQL-Befehle und keine Treibervoraussetzungen. Sie erstellen einen WorkBook, fügen einen WorkSheet hinzu und rufen für jede Zelle SetCellValue() auf:

using IronXL;
using System.Data;

// Build the same DataTable
DataTable dataTable = new DataTable("Products");
dataTable.Columns.Add("ProductID", typeof(int));
dataTable.Columns.Add("ProductName", typeof(string));
dataTable.Columns.Add("Price", typeof(decimal));
dataTable.Rows.Add(1, "Widget", 29.99m);
dataTable.Rows.Add(2, "Gadget", 49.99m);
dataTable.Rows.Add(3, "Gizmo", 19.99m);

// Create a new workbook and worksheet -- no template file needed
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("Products");

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

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

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

// Build the same DataTable
DataTable dataTable = new DataTable("Products");
dataTable.Columns.Add("ProductID", typeof(int));
dataTable.Columns.Add("ProductName", typeof(string));
dataTable.Columns.Add("Price", typeof(decimal));
dataTable.Rows.Add(1, "Widget", 29.99m);
dataTable.Rows.Add(2, "Gadget", 49.99m);
dataTable.Rows.Add(3, "Gizmo", 19.99m);

// Create a new workbook and worksheet -- no template file needed
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("Products");

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

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

workbook.SaveAs("Products.xlsx");
Imports IronXL
Imports System.Data

' Build the same DataTable
Dim dataTable As New DataTable("Products")
dataTable.Columns.Add("ProductID", GetType(Integer))
dataTable.Columns.Add("ProductName", GetType(String))
dataTable.Columns.Add("Price", GetType(Decimal))
dataTable.Rows.Add(1, "Widget", 29.99D)
dataTable.Rows.Add(2, "Gadget", 49.99D)
dataTable.Rows.Add(3, "Gizmo", 19.99D)

' Create a new workbook and worksheet -- no template file needed
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Products")

' Write column headers into the first row
For col As Integer = 0 To dataTable.Columns.Count - 1
    worksheet.SetCellValue(0, col, dataTable.Columns(col).ColumnName)
Next

' Write data rows
For row As Integer = 0 To dataTable.Rows.Count - 1
    For col As Integer = 0 To dataTable.Columns.Count - 1
        worksheet.SetCellValue(row + 1, col, dataTable.Rows(row)(col).ToString())
    Next
Next

workbook.SaveAs("Products.xlsx")
$vbLabelText   $csharpLabel

WorkBook.Create(ExcelFileFormat.XLSX) erstellt eine neue Arbeitsmappe im Speicher - es muss keine Datei vorher existieren. CreateWorkSheet("Products") fügt einen benannten Tabulator an. Die verschachtelten Schleifen spiegeln die Zeilen- und Spaltenanzahl der DataTable exakt wider und schreiben einen Wert pro Zelle. SaveAs() speichert die Arbeitsmappe als vollständig gültige XLSX-Datei auf der Festplatte.

Ausgabe

So exportieren Sie eine DataTable nach Excel mit C# unter Verwendung von OleDB vs. IronXL: Bild 1 - Excel-Ausgabe

Für einen detaillierteren Einblick in die verfügbaren Optionen bietet die Anleitung zum Exportieren von DataSets und DataTables zusätzliche Informationen zu Überladungen und Batch-Exportmustern.

Wie fügt man beim Exportieren einer DataTable Zellformatierungen hinzu?

Eine der häufigsten Anforderungen nach einem Basisexport ist die Formatierung der Kopfzeile, um sie von den Datenzeilen zu unterscheiden. IronXL bietet eine vollständige Styling-API, die OleDB nicht bieten kann:

using IronXL;
using IronXl.Styles;
using System.Data;

DataTable dataTable = new DataTable("Products");
dataTable.Columns.Add("ProductID", typeof(int));
dataTable.Columns.Add("ProductName", typeof(string));
dataTable.Columns.Add("Price", typeof(decimal));
dataTable.Rows.Add(1, "Widget", 29.99m);
dataTable.Rows.Add(2, "Gadget", 49.99m);
dataTable.Rows.Add(3, "Gizmo", 19.99m);

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

// Write and style the header row
for (int col = 0; col < dataTable.Columns.Count; col++)
{
    var headerCell = worksheet[$"{(char)('A' + col)}1"];
    headerCell.Value = dataTable.Columns[col].ColumnName;
    headerCell.Style.Font.Bold = true;
    headerCell.Style.BackgroundColor = "#4472C4";
    headerCell.Style.Font.FontColor = "#FFFFFF";
}

// Write data rows with price column formatted as currency
for (int row = 0; row < dataTable.Rows.Count; row++)
{
    for (int col = 0; col < dataTable.Columns.Count; col++)
    {
        var cell = worksheet[$"{(char)('A' + col)}{row + 2}"];
        cell.Value = dataTable.Rows[row][col].ToString();

        // Apply currency format to the Price column
        if (dataTable.Columns[col].ColumnName == "Price")
            cell.FormatString = "$#,##0.00";
    }
}

// Auto-size columns so content is not clipped
worksheet.AutoSizeColumn(0);
worksheet.AutoSizeColumn(1);
worksheet.AutoSizeColumn(2);

workbook.SaveAs("ProductsStyled.xlsx");
using IronXL;
using IronXl.Styles;
using System.Data;

DataTable dataTable = new DataTable("Products");
dataTable.Columns.Add("ProductID", typeof(int));
dataTable.Columns.Add("ProductName", typeof(string));
dataTable.Columns.Add("Price", typeof(decimal));
dataTable.Rows.Add(1, "Widget", 29.99m);
dataTable.Rows.Add(2, "Gadget", 49.99m);
dataTable.Rows.Add(3, "Gizmo", 19.99m);

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

// Write and style the header row
for (int col = 0; col < dataTable.Columns.Count; col++)
{
    var headerCell = worksheet[$"{(char)('A' + col)}1"];
    headerCell.Value = dataTable.Columns[col].ColumnName;
    headerCell.Style.Font.Bold = true;
    headerCell.Style.BackgroundColor = "#4472C4";
    headerCell.Style.Font.FontColor = "#FFFFFF";
}

// Write data rows with price column formatted as currency
for (int row = 0; row < dataTable.Rows.Count; row++)
{
    for (int col = 0; col < dataTable.Columns.Count; col++)
    {
        var cell = worksheet[$"{(char)('A' + col)}{row + 2}"];
        cell.Value = dataTable.Rows[row][col].ToString();

        // Apply currency format to the Price column
        if (dataTable.Columns[col].ColumnName == "Price")
            cell.FormatString = "$#,##0.00";
    }
}

// Auto-size columns so content is not clipped
worksheet.AutoSizeColumn(0);
worksheet.AutoSizeColumn(1);
worksheet.AutoSizeColumn(2);

workbook.SaveAs("ProductsStyled.xlsx");
Imports IronXL
Imports IronXl.Styles
Imports System.Data

Dim dataTable As New DataTable("Products")
dataTable.Columns.Add("ProductID", GetType(Integer))
dataTable.Columns.Add("ProductName", GetType(String))
dataTable.Columns.Add("Price", GetType(Decimal))
dataTable.Rows.Add(1, "Widget", 29.99D)
dataTable.Rows.Add(2, "Gadget", 49.99D)
dataTable.Rows.Add(3, "Gizmo", 19.99D)

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

' Write and style the header row
For col As Integer = 0 To dataTable.Columns.Count - 1
    Dim headerCell = worksheet($"{ChrW(AscW("A"c) + col)}1")
    headerCell.Value = dataTable.Columns(col).ColumnName
    headerCell.Style.Font.Bold = True
    headerCell.Style.BackgroundColor = "#4472C4"
    headerCell.Style.Font.FontColor = "#FFFFFF"
Next

' Write data rows with price column formatted as currency
For row As Integer = 0 To dataTable.Rows.Count - 1
    For col As Integer = 0 To dataTable.Columns.Count - 1
        Dim cell = worksheet($"{ChrW(AscW("A"c) + col)}{row + 2}")
        cell.Value = dataTable.Rows(row)(col).ToString()

        ' Apply currency format to the Price column
        If dataTable.Columns(col).ColumnName = "Price" Then
            cell.FormatString = "$#,##0.00"
        End If
    Next
Next

' Auto-size columns so content is not clipped
worksheet.AutoSizeColumn(0)
worksheet.AutoSizeColumn(1)
worksheet.AutoSizeColumn(2)

workbook.SaveAs("ProductsStyled.xlsx")
$vbLabelText   $csharpLabel

Dadurch entsteht eine Datei mit einer blauen Kopfzeile, weißem Kopfzeilentext und Preiswerten, die mit einem Dollarzeichen und zwei Dezimalstellen angezeigt werden. Die Anleitung zur Schriftgröße der Zellen sowie die Hinweise zu Rahmen und Ausrichtung erläutern alle verfügbaren Gestaltungsoptionen.

Umgang mit großen DataTable-Exporten

Bei Datensätzen mit Tausenden von Zeilen spielt die Performance eine wichtige Rolle. IronXL schreibt alle Zellenwerte in den Speicher, bevor ein einzelner Festplattenzugriff an der Stelle SaveAs() erfolgt. Dies ist wesentlich effizienter als das OleDB-Muster mit einem ExecuteNonQuery() pro Zeile. Wenn Sie sehr große Tabellen exportieren müssen, bietet Ihnen der Leitfaden "DataTable am schnellsten nach Excel exportieren" speichereffiziente Streaming-Techniken.

Sie können die Exportlogik auch mit Formeln, Bereichen und benannten Tabellen gruppieren. Die Anleitungen zum Erstellen von Tabellenkalkulationen und zum Schreiben von Excel in .NET bieten vollständige Muster für die Erstellung von mehrseitigen Arbeitsmappen aus DataTables.

Wie exportiert man eine DataTable in ASP.NET nach Excel?

Bei einer Webanwendung wird die Arbeitsmappe typischerweise direkt an den Browser gestreamt, anstatt sie auf der Festplatte zu speichern. IronXL unterstützt dies mit workbook.ToByteArray(), das den Binärinhalt zurückgibt, den Sie in eine HTTP-Antwort schreiben können:

// In an ASP.NET controller action
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("Report");

// Assume dataTable is populated from your data source
for (int col = 0; col < dataTable.Columns.Count; col++)
    worksheet.SetCellValue(0, col, dataTable.Columns[col].ColumnName);

for (int row = 0; row < dataTable.Rows.Count; row++)
    for (int col = 0; col < dataTable.Columns.Count; col++)
        worksheet.SetCellValue(row + 1, col, dataTable.Rows[row][col].ToString());

byte[] fileBytes = workbook.ToByteArray();
return File(fileBytes, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "Report.xlsx");
// In an ASP.NET controller action
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("Report");

// Assume dataTable is populated from your data source
for (int col = 0; col < dataTable.Columns.Count; col++)
    worksheet.SetCellValue(0, col, dataTable.Columns[col].ColumnName);

for (int row = 0; row < dataTable.Rows.Count; row++)
    for (int col = 0; col < dataTable.Columns.Count; col++)
        worksheet.SetCellValue(row + 1, col, dataTable.Rows[row][col].ToString());

byte[] fileBytes = workbook.ToByteArray();
return File(fileBytes, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "Report.xlsx");
' In an ASP.NET controller action
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Report")

' Assume dataTable is populated from your data source
For col As Integer = 0 To dataTable.Columns.Count - 1
    worksheet.SetCellValue(0, col, dataTable.Columns(col).ColumnName)
Next

For row As Integer = 0 To dataTable.Rows.Count - 1
    For col As Integer = 0 To dataTable.Columns.Count - 1
        worksheet.SetCellValue(row + 1, col, dataTable.Rows(row)(col).ToString())
    Next
Next

Dim fileBytes As Byte() = workbook.ToByteArray()
Return File(fileBytes, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "Report.xlsx")
$vbLabelText   $csharpLabel

Das Tutorial "ASP.NET export DataTable to Excel" führt Sie durch die vollständige Controller- und View-Verkabelung für eine ASP.NET Anwendung. Der Leitfaden "DataTable zu Excel C#" behandelt zusätzliche Szenarien, darunter den Export mehrerer Tabellenblätter und die Unterstützung von DataSets.

OleDB vs. IronXL im Vergleich auf einen Blick

Funktionsvergleich zwischen OleDB und IronXL für den DataTable-zu-Excel-Export in C#
Fähigkeit OleDB IronXL
Treiberinstallation erforderlich Ja (ACE.OLEDB oder Jet) Nein
Plattformübergreifend (.NET 10 / Linux) Nein Ja
Erstellen Sie eine neue Arbeitsmappe von Grund auf. Nein Ja
Zellformatierung und -gestaltung Nein Ja
Formelunterstützung Nein Ja
Batch-Einfügeleistung Zeile für Zeile (langsam) Im Arbeitsspeicher (schnell)
DELETE-Zeilenunterstützung Nein Ja
Docker-/Container-Unterstützung Nein Ja

Wie gehen Sie beim Export mit Spaltendatentypen um?

Wenn eine DataTable-Spalte numerische Werte oder Datumswerte enthält und diese als Zeichenketten geschrieben werden, behandelt Excel die Zelle als Text, wodurch Sortierung, Filterung und Formelbezüge deaktiviert werden. IronXL erhält die nativen Typen, wenn Sie den Wert direkt übergeben, anstatt .ToString() aufzurufen:

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

DataTable table = new DataTable();
table.Columns.Add("ID", typeof(int));
table.Columns.Add("Amount", typeof(decimal));
table.Columns.Add("Date", typeof(DateTime));
table.Rows.Add(1, 1500.75m, new DateTime(2025, 6, 15));
table.Rows.Add(2, 3200.00m, new DateTime(2025, 7, 4));

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

// Write typed values -- no .ToString() conversion
for (int row = 0; row < table.Rows.Count; row++)
{
    worksheet.SetCellValue(row + 1, 0, (int)table.Rows[row]["ID"]);
    worksheet.SetCellValue(row + 1, 1, (double)(decimal)table.Rows[row]["Amount"]);
    worksheet[$"C{row + 2}"].Value = (DateTime)table.Rows[row]["Date"];
    worksheet[$"C{row + 2}"].FormatString = "yyyy-MM-dd";
}

workbook.SaveAs("TypedData.xlsx");
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("TypedData");

DataTable table = new DataTable();
table.Columns.Add("ID", typeof(int));
table.Columns.Add("Amount", typeof(decimal));
table.Columns.Add("Date", typeof(DateTime));
table.Rows.Add(1, 1500.75m, new DateTime(2025, 6, 15));
table.Rows.Add(2, 3200.00m, new DateTime(2025, 7, 4));

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

// Write typed values -- no .ToString() conversion
for (int row = 0; row < table.Rows.Count; row++)
{
    worksheet.SetCellValue(row + 1, 0, (int)table.Rows[row]["ID"]);
    worksheet.SetCellValue(row + 1, 1, (double)(decimal)table.Rows[row]["Amount"]);
    worksheet[$"C{row + 2}"].Value = (DateTime)table.Rows[row]["Date"];
    worksheet[$"C{row + 2}"].FormatString = "yyyy-MM-dd";
}

workbook.SaveAs("TypedData.xlsx");
Imports System
Imports System.Data

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

Dim table As New DataTable()
table.Columns.Add("ID", GetType(Integer))
table.Columns.Add("Amount", GetType(Decimal))
table.Columns.Add("Date", GetType(DateTime))
table.Rows.Add(1, 1500.75D, New DateTime(2025, 6, 15))
table.Rows.Add(2, 3200.00D, New DateTime(2025, 7, 4))

' Write headers
For col As Integer = 0 To table.Columns.Count - 1
    worksheet.SetCellValue(0, col, table.Columns(col).ColumnName)
Next

' Write typed values -- no .ToString() conversion
For row As Integer = 0 To table.Rows.Count - 1
    worksheet.SetCellValue(row + 1, 0, CInt(table.Rows(row)("ID")))
    worksheet.SetCellValue(row + 1, 1, CDbl(CDec(table.Rows(row)("Amount"))))
    worksheet($"C{row + 2}").Value = CType(table.Rows(row)("Date"), DateTime)
    worksheet($"C{row + 2}").FormatString = "yyyy-MM-dd"
Next

workbook.SaveAs("TypedData.xlsx")
$vbLabelText   $csharpLabel

Excel kann nun die Spalte "Betrag" numerisch sortieren und die Spalte "Datum" mithilfe von Datumsauswahlfeldern filtern. Weitere Informationen zu Datenformatmustern finden Sie im Leitfaden zum Datenformat von Setzellen . Falls Sie die exportierten Daten wieder einlesen müssen, beschreibt das Tutorial "Excel zu DataTable" die umgekehrte Operation.

Migration des vorhandenen OleDB-Exportcodes

Die Migration von OleDB zu IronXL dauert in der Regel weniger Zeit als ein einzelner Sprint. Die strukturellen Veränderungen sind:

  1. Entfernen Sie alle using System.Data.OleDB-Verweise und NuGet Verweise auf beliebige ACE-Treiber-Wrapper-Pakete.
  2. Ersetzen Sie den Initialisierungsblock OleDBConnection durch WorkBook.Create(ExcelFileFormat.XLSX).
  3. Ersetzen Sie den Befehl CREATE TABLE durch workbook.CreateWorkSheet("SheetName").
  4. Ersetzen Sie die INSERT INTO Schleife durch verschachtelte SetCellValue() Aufrufe, einen pro Zelle.
  5. Ersetzen Sie connection.Close() durch workbook.SaveAs("output.xlsx").

Alternativ können Sie workbook.SaveAs() mit der Erweiterung .xls aufrufen, um Dateien im Legacy-Format zu erzeugen, falls die nachgelagerten Anwender noch nicht auf Excel 2007 oder eine neuere Version aktualisiert haben. Die Anleitung zum Konvertieren von Tabellenkalkulationsdateitypen listet alle unterstützten Ausgabeformate auf.

Wie testet und lizenziert man IronXL?

IronXL kann im Rahmen der Entwicklung mit einer Testlizenz kostenlos genutzt werden. Sie wenden den Schlüssel im Code vor dem ersten IronXL -Aufruf an:

IronXl.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";
IronXl.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";
Imports IronXl

IronXl.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"
$vbLabelText   $csharpLabel

Der Leitfaden zur Lizenzschlüsselanwendung erläutert alle Platzierungsoptionen, einschließlich Konfigurationsdateien und Umgebungsvariablen. Für Cloud-Bereitstellungen beschreiben die Docker- und Linux- Einführungsseiten die plattformspezifischen Einrichtungsschritte.

Microsoft dokumentiert die bekannten Einschränkungen der Access Database Engine für OleDB-Szenarien, und NuGet hostet das IronXL Paket mit vollständiger Versionshistorie und Downloadstatistiken. Die offizielle Open XML SDK-Dokumentation erläutert die zugrunde liegende XLSX-Spezifikation, die IronXL implementiert.

Was sind Ihre nächsten Schritte?

Sie verfügen nun über ein funktionierendes Muster zum Exportieren einer DataTable in eine XLSX-Datei ohne OleDB-Treiber, ohne SQL-Syntax und ohne Plattformbeschränkungen. Der Kern-Workflow -- WorkBook.Create(), CreateWorkSheet(), SetCellValue() in einer Schleife, dann SaveAs() -- skaliert von einer Stichprobe von drei Zeilen bis hin zu Datensätzen mit Hunderttausenden von Zeilen.

Ersetzen Sie zunächst Ihren bestehenden OleDB-Export durch das oben gezeigte IronXL Grundmuster und fügen Sie anschließend, sobald der Datenexport verifiziert ist, mithilfe der Styling-API Formatierungen hinzu. Die Kurzanleitung für IronXL und die Funktionsübersicht sind gute nächste Lektüren, um den vollen Umfang der von der Bibliothek unterstützten Funktionen zu verstehen. Wenn Sie im Rahmen derselben Pipeline mit CSV-Dateien arbeiten, zeigt Ihnen der C# DataTable to CSV-Leitfaden, wie Sie aus demselben DataTable-Objekt eine durch Kommas getrennte Ausgabe erzeugen.

Häufig gestellte Fragen

Welche Einschränkungen gibt es bei der Verwendung von OleDb zum Exportieren von DataTables nach Excel in C#?

Die Verwendung von OleDb zum Exportieren von DataTables nach Excel in C# kann aufgrund seiner veralteten Architektur frustrierend sein. Entwickler stoßen häufig auf Einschränkungen wie Kompatibilitätsprobleme, geringere Performance und komplexere Fehlerbehandlung, wodurch moderne Alternativen wie IronXL attraktiver werden.

Wie verbessert IronXL den Prozess des Exportierens von DataTables nach Excel?

IronXL bietet einen modernen Ansatz für den Export von DataTables nach Excel und zeichnet sich durch höhere Leistung, breitere Kompatibilität und vereinfachten Code aus. Es beseitigt typische Probleme mit OleDb und erleichtert .NET -Entwicklern die Verwaltung von Excel-Exporten.

Warum sollte ich für DataTable-Exporte von OleDb auf IronXL umsteigen?

Der Wechsel zu IronXL für DataTable-Exporte bietet mehrere Vorteile, darunter eine verbesserte Performance, eine einfachere Implementierung und eine verbesserte Kompatibilität mit modernen .NET Anwendungen, wodurch der Zeit- und Arbeitsaufwand für die Entwicklung reduziert wird.

Kann IronXL große DataTable-Exporte effizienter verarbeiten als OleDb?

Ja, IronXL ist so konzipiert, dass es große DataTable-Exporte effizient verarbeiten kann und im Vergleich zu OleDb schnellere Verarbeitungszeiten und einen geringeren Speicherverbrauch bietet. Dadurch eignet es sich ideal für Anwendungen, die mit umfangreichen Datensätzen arbeiten.

Ist IronXL mit den neuesten Versionen von C# und .NET kompatibel?

IronXL ist vollständig kompatibel mit den neuesten Versionen von C# und .NET und gewährleistet so eine nahtlose Integration in moderne Anwendungen. Gleichzeitig werden fortlaufende Updates bereitgestellt, um neue Funktionen und Verbesserungen zu unterstützen.

Welche Vorteile bieten moderne Alternativen wie IronXL gegenüber dem herkömmlichen OleDB?

Moderne Alternativen wie IronXL bieten Vorteile wie verbesserte Leistung, einfachere Fehlerbehandlung, bessere Kompatibilität mit verschiedenen Excel-Formaten und vereinfachten Code, was die Produktivität der Entwickler erheblich steigern kann.

Wie handhabt IronXL das Fehlermanagement im Vergleich zu OleDb?

IronXL bietet ein vereinfachtes Fehlermanagement mit klarer Ausnahmebehandlung, wodurch die Komplexität und die potenziellen Probleme im Zusammenhang mit OleDb reduziert werden und es Entwicklern somit erleichtert wird, ihre Anwendungen zu debuggen und zu warten.

Was sind die gängigen Anwendungsfälle für den Export von DataTables nach Excel in UI-basierten .NET Anwendungen?

In UI-basierten .NET Anwendungen wird der Export von DataTables nach Excel häufig für die Erstellung von Berichten, Datenanalysen und benutzerfreundlichen Datenmanipulationen verwendet, die oft durch Ereignisbehandler mithilfe von Objektsendermustern ausgelöst werden.

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