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 befü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.
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:
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.
Der traditionelle OleDB-Ansatz behandelt eine Excel-Datei wie eine Datenbank. Sie erstellen ein OleDBConnection mithilfe des Microsoft.ACE.OLEDB.12.0-Providers (oder des älteren Microsoft.Jet.OLEDB.4.0 für .xls-Dateien) und führen dann SQL-CREATE TABLE und INSERT INTO-Befehle gegen 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.
OleDB wurde zur Standardwahl für die Excel-Automatisierung, da es bereits Teil des .NET Framework war. Entwickler kannten bereits ADO.NET, daher fühlte es sich natürlich an, OleDBConnection, OleDBCommand und OleDBDataAdapter zu verwenden, um nach Excel zu schreiben. Es war kein Drittanbieter-Paket erforderlich, und die SQL-ähnliche Syntax für CREATE TABLE und INSERT INTO machte die Intention für jeden, der mit Datenbankprogrammierung vertraut ist, 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.ExecuteNeinnQuery();
// 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.ExecuteNeinnQuery();
}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 UsingDieser 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.
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.
Der Microsoft.ACE.OLEDB.12.0-Provider muss separat auf jedem Computer installiert werden, der Ihre Anwendung ausführt. 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.
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 System.Data.OleDB-Namespace auf Nicht-Windows-Betriebssystemen ein PlatformNeintSupportedException auslöst, wird jeder Codepfad, der OleDB verwendet, vollständig von der Ausführung auf diesen Plattformen blockiert.
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.
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.
Der OleDB-Treiber für Excel unterstützt INSERT und eingeschränkte UPDATE-Operationen, aber das Löschen von Zeilen mit DELETE FROM wird 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.
IronXL ersetzt die gesamte OleDB-Pipeline durch ein direktes Objektmodell. Es gibt keine Verbindungszeichenfolgen, keine SQL-Befehle und keine Treibervoraussetzungen. Sie erstellen ein WorkBook, fügen ein 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");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")WorkBook.Create(ExcelFileFormat.XLSX) erstellt ein neues Arbeitsbuch im Speicher -- es muss keine Datei zuvor existieren. CreateWorkSheet("Products") fügt einen benannten Tab hinzu. Die verschachtelten Schleifen spiegeln die Zeilen- und Spaltenanzahl der DataTable exakt wider und schreiben einen Wert pro Zelle. SaveAs() schreibt das Arbeitsbuch als vollständig gültige XLSX-Datei auf die Festplatte.
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.
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");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")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.
Bei Datensätzen mit Tausenden von Zeilen spielt die Performance eine wichtige Rolle. IronXL schreibt alle Zellwerte im Speicher, bevor ein einzelner Schreibvorgang auf die Festplatte mit SaveAs() durchgeführt wird, was weit effizienter ist als das OleDB-Muster, das ein ExecuteNeinnQuery() pro Zeile vorsieht. 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.
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ären Inhalt 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
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")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.
| 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 |
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 bewahrt native 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");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")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.
Die Migration von OleDB zu IronXL dauert in der Regel weniger Zeit als ein einzelner Sprint. Die strukturellen Veränderungen sind:
using System.Data.OleDB-Referenzen und NuGet-Referenzen zu jedem ACE-Treiber-Wrapper-Paket.OleDBConnection-Initialisierungsblock durch WorkBook.Create(ExcelFileFormat.XLSX).CREATE TABLE-Befehl durch workbook.CreateWorkSheet("SheetName").INSERT INTO-Schleife durch verschachtelte SetCellValue()-Aufrufe, einen pro Zelle.connection.Close() durch workbook.SaveAs("output.xlsx").Sie können auch workbook.SaveAs() mit einer .xls-Erweiterung aufrufen, um Dateien im alten Format zu erstellen, falls Downstream-Konsumenten noch nicht auf Excel 2007 oder später aktualisiert haben. Die Anleitung zum Konvertieren von Tabellenkalkulationsdateitypen listet alle unterstützten Ausgabeformate auf.
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";Imports IronXL
IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"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.
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 Kernworkflow -- WorkBook.Create(), CreateWorkSheet(), SetCellValue() in einer Schleife, dann SaveAs() -- skaliert von einem Drei-Zeilen-Beispiel auf Datensätze 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 Einführungsanleitung für IronXL und die Funktionsübersicht sind empfehlenswerte Lektüre, um den vollen Umfang der von der IronXL-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.
Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender Handbücher.
IronXL ist ein Teil der IRONSUITE
10 .NET-API-Produkte für Ihre Bürodokumente
Das Excel-API, das Sie brauchen, ohne den Office Interop Aufwand.
