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

Wie exportiert man eine DataTable nach Excel mit C# unter Verwendung von Interop vs. IronXL?

Jordi Bardia
Jordi Bardia
Veröffentlicht:

Einführung in den Datenexport in eine Excel-Datei

Der Export von Daten aus einer Datenbank oder Anwendung in eine Excel-Datei ist eine grundlegende Voraussetzung für Organisationen, die Informationen effizient analysieren, visualisieren und teilen müssen. Excel-Dateien sind weithin für ihre benutzerfreundliche Oberfläche bekannt, die es den Benutzern erleichtert, mit den Daten zu interagieren und sie zu interpretieren. Durch die Konvertierung von Datensätzen in das .XLSX-Format stellen Entwickler sicher, dass die Daten unabhängig vom technischen Hintergrund des Benutzers zugänglich und strukturiert bleiben. Dieses Verfahren erhält nicht nur die Integrität des ursprünglichen Datensatzes, sondern ermöglicht auch einen nahtlosen Datentransfer zwischen Systemen. Um dies zu ermöglichen, können Entwickler verschiedene Excel-Bibliotheken wie IronXL, EPPlus, NPOI und ClosedXML nutzen, mit denen sie Excel-Dateien programmgesteuert erstellen, lesen und bearbeiten können – ganz ohne die Notwendigkeit, Microsoft Excel auf dem Server oder Client-Rechner zu installieren. Diese Bibliotheken ermöglichen es Benutzern, professionelle Berichte und Datenexporte im Excel-Format zu erstellen und so ein breites Spektrum an geschäftlichen und analytischen Anforderungen zu erfüllen.

Was sind die wichtigsten Unterschiede zwischen Interop und IronXL?

Bevor man sich in die Programmierung vertieft, hilft das Verständnis der grundlegenden Unterschiede zwischen diesen beiden Ansätzen dabei, die richtige Wahl für jedes Projekt zu treffen. Der Vergleich umfasst die technische Architektur, die Bereitstellungsanforderungen und die praktische Entwicklungserfahrung bei der Arbeit mit DataTable-zu-Excel-Export-Szenarien.

Besonderheit Microsoft Office Interoperabilität IronXL
Büroinstallation erforderlich Ja – Microsoft Excel muss installiert sein. Nein – eigenständige Bibliothek
Serverseitige Unterstützung Nicht von Microsoft empfohlen Vollständig unterstützt
Plattformunterstützung Nur für Windows Windows, Linux, macOS, Azure
.NET Core/.NET 5+ Unterstützung Beschränkt Volle Unterstützung (.NET 6, 7, 8, 9, 10)
Ressourcenmanagement Erfordert die Bereinigung von COM-Objekten. Standardmäßige .NET-Entsorgung
Installationsmethode COM-Referenz + Office-Installation Install-Package via NuGet
Gewindemodell Einzelanschlusswohnung (STA) Threadsichere Operationen
Große Datensätze Speicherintensiver Prozess Effizienter dateibasierter Ansatz
Dateiformate XLSX, XLS, CSV XLSX, XLS, CSV, JSON, XML
Lizenzierung Erfordert eine Office-Lizenz Gewerbliche Lizenz verfügbar

Der architektonische Unterschied ist fundamental: Excel Interop automatisiert die Microsoft Excel-Anwendung selbst über COM, während IronXL Excel-Dateiformate direkt liest und schreibt, ohne einen externen Prozess zu starten. Diese Unterscheidung wirkt sich auf alles aus, von der Speichernutzung bis hin zur Komplexität der Bereitstellung.

Wie exportiert man eine DataTable nach Excel mit C# und Interop?

Der traditionelle Ansatz verwendet den Microsoft.Office.Interop.Excel -Namespace, um Excel direkt zu automatisieren. Diese Methode erfordert, dass Microsoft Excel auf dem Rechner installiert ist, auf dem der Code ausgeführt wird.

Voraussetzungen

Vor der Verwendung von Interop stellen Sie Folgendes sicher:

  1. Microsoft Excel ist auf den Entwicklungs- und Produktionsrechnern installiert.
  2. Fügen Sie in Visual Studio einen COM-Verweis auf die "Microsoft Excel-Objektbibliothek" hinzu.
  3. Fügen Sie den Namespace Microsoft.Office.Interop.Excel hinzu.

Interop-Codebeispiel

Der folgende Code veranschaulicht, wie man eine DataTable mithilfe von Microsoft Office Interop in eine Excel-Datei exportiert:

using Microsoft.Office.Interop.Excel;
using System.Data;
using System.Runtime.InteropServices;

// Create a sample DataTable with employee data
DataTable dt = new DataTable("Employees");
dt.Columns.Add("EmployeeID", typeof(int));
dt.Columns.Add("Name", typeof(string));
dt.Columns.Add("Department", typeof(string));
dt.Columns.Add("Salary", typeof(decimal));

// Fill the DataTable with sample rows
dt.Rows.Add(1, "John Smith", "Engineering", 75000);
dt.Rows.Add(2, "Sarah Johnson", "Marketing", 65000);
dt.Rows.Add(3, "Michael Chen", "Finance", 70000);
dt.Rows.Add(4, "Emily Davis", "Engineering", 80000);

// Initialize Excel Application object
Application excelApp = new Application
{
    Visible = false,
    DisplayAlerts = false
};

// Create new Workbook and get the active Worksheet
Workbook workbook = excelApp.Workbooks.Add();
Worksheet worksheet = (Worksheet)workbook.ActiveSheet;

try
{
    // Write column headers to the first row
    for (int i = 0; i < dt.Columns.Count; i++)
    {
        worksheet.Cells[1, i + 1] = dt.Columns[i].ColumnName;
    }
    // Write data rows starting from row 2
    for (int i = 0; i < dt.Rows.Count; i++)
    {
        for (int j = 0; j < dt.Columns.Count; j++)
        {
            worksheet.Cells[i + 2, j + 1] = dt.Rows[i][j].ToString();
        }
    }
    // Define file path and save the Excel file
    string filePath = @"C:\Reports\EmployeeReport_Interop.xlsx";
    workbook.SaveAs(filePath);
    Console.WriteLine("Excel file created successfully using Interop.");
}
catch (Exception ex)
{
    Console.WriteLine("Error exporting data to Excel: " + ex.Message);
}
finally
{
    // Close workbook and quit Excel application
    workbook.Close();
    excelApp.Quit();
    // Critical: Release COM objects to prevent memory leaks
    Marshal.ReleaseComObject(worksheet);
    Marshal.ReleaseComObject(workbook);
    Marshal.ReleaseComObject(excelApp);
}
using Microsoft.Office.Interop.Excel;
using System.Data;
using System.Runtime.InteropServices;

// Create a sample DataTable with employee data
DataTable dt = new DataTable("Employees");
dt.Columns.Add("EmployeeID", typeof(int));
dt.Columns.Add("Name", typeof(string));
dt.Columns.Add("Department", typeof(string));
dt.Columns.Add("Salary", typeof(decimal));

// Fill the DataTable with sample rows
dt.Rows.Add(1, "John Smith", "Engineering", 75000);
dt.Rows.Add(2, "Sarah Johnson", "Marketing", 65000);
dt.Rows.Add(3, "Michael Chen", "Finance", 70000);
dt.Rows.Add(4, "Emily Davis", "Engineering", 80000);

// Initialize Excel Application object
Application excelApp = new Application
{
    Visible = false,
    DisplayAlerts = false
};

// Create new Workbook and get the active Worksheet
Workbook workbook = excelApp.Workbooks.Add();
Worksheet worksheet = (Worksheet)workbook.ActiveSheet;

try
{
    // Write column headers to the first row
    for (int i = 0; i < dt.Columns.Count; i++)
    {
        worksheet.Cells[1, i + 1] = dt.Columns[i].ColumnName;
    }
    // Write data rows starting from row 2
    for (int i = 0; i < dt.Rows.Count; i++)
    {
        for (int j = 0; j < dt.Columns.Count; j++)
        {
            worksheet.Cells[i + 2, j + 1] = dt.Rows[i][j].ToString();
        }
    }
    // Define file path and save the Excel file
    string filePath = @"C:\Reports\EmployeeReport_Interop.xlsx";
    workbook.SaveAs(filePath);
    Console.WriteLine("Excel file created successfully using Interop.");
}
catch (Exception ex)
{
    Console.WriteLine("Error exporting data to Excel: " + ex.Message);
}
finally
{
    // Close workbook and quit Excel application
    workbook.Close();
    excelApp.Quit();
    // Critical: Release COM objects to prevent memory leaks
    Marshal.ReleaseComObject(worksheet);
    Marshal.ReleaseComObject(workbook);
    Marshal.ReleaseComObject(excelApp);
}
$vbLabelText   $csharpLabel

Dieser Code demonstriert den kompletten Workflow zum Exportieren einer DataTable in eine Excel-Datei mithilfe von Microsoft Interop. Zunächst wird eine neue DataTable namens dt mit Mitarbeiterinformationen erstellt – vier Spalten für die in Geschäftsanwendungen üblichen Datentypen ID, Name, Abteilung und Gehalt.

Das Application Objekt repräsentiert den Excel-Prozess selbst. Durch die Einstellung Visible = false wird verhindert, dass die Excel-Anwendung während der Verarbeitung auf dem Bildschirm erscheint, was für Hintergrundvorgänge unerlässlich ist. Die Einstellung DisplayAlerts = false unterdrückt Dialogfelder, die andernfalls automatisierte Arbeitsabläufe beim Ausführen des Exports unterbrechen würden.

Die Objekte Workbook und Worksheet entsprechen direkt der Dateistruktur von Excel. Eine Arbeitsmappe ist die Excel-Datei selbst (im Format .XLSX oder .XLS), während Arbeitsblätter die einzelnen Registerkarten innerhalb dieser Datei sind. Der Code verwendet workbook.ActiveSheet , um eine Referenz auf das Standardarbeitsblatt zu erhalten, das mit jeder neuen Arbeitsmappe erstellt wird.

Wie exportiert man eine DataTable mit IronXL nach Excel?

IronXL bietet eine moderne Alternative, die ohne Office-Installation funktioniert. Die Bibliothek kann Excel-Dateien direkt lesen und schreiben und eignet sich daher für Serverumgebungen, Cloud-Bereitstellungen und plattformübergreifende Anwendungen.

Voraussetzungen

Installieren Sie IronXL über die NuGet-Paket-Manager-Konsole:

Install-Package IronXL.Excel
Install-Package IronXL.Excel
SHELL

Oder verwenden Sie die .NET-CLI:

dotnet add package IronXL.Excel
dotnet add package IronXL.Excel
SHELL

Es ist keine zusätzliche Software, Office-Installation oder Systemkonfiguration erforderlich. Die Bibliothek funktioniert sofort nach der Installation unter Windows, Linux und macOS. Bei Azure-Bereitstellungen läuft IronXL in App Services, Functions und Containerinstanzen ohne spezielle Konfiguration. Die Bibliothek unterstützt .NET Framework 4.6.2+ und alle modernen .NET-Versionen, einschließlich .NET 6, 7, 8, 9 und 10.

IronXL-Codebeispiel

Der folgende Code zeigt, wie man eine DataTable mithilfe der IronXL-Bibliothek in Excel konvertiert:

using IronXL;
using System.Data;

// Create a sample DataTable
DataTable dt = new DataTable("Employees");
dt.Columns.Add("EmployeeID", typeof(int));
dt.Columns.Add("Name", typeof(string));
dt.Columns.Add("Department", typeof(string));
dt.Columns.Add("Salary", typeof(decimal));

// Fill DataTable with rows of data
dt.Rows.Add(1, "John Smith", "Engineering", 75000);
dt.Rows.Add(2, "Sarah Johnson", "Marketing", 65000);
dt.Rows.Add(3, "Michael Chen", "Finance", 70000);
dt.Rows.Add(4, "Emily Davis", "Engineering", 80000);

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

// Write column names to the first row as headers
for (int i = 0; i < dt.Columns.Count; i++)
{
    sheet.SetCellValue(0, i, dt.Columns[i].ColumnName);
}

// Export DataTable rows to Excel cells
for (int i = 0; i < dt.Rows.Count; i++)
{
    for (int j = 0; j < dt.Columns.Count; j++)
    {
        sheet.SetCellValue(i + 1, j, dt.Rows[i][j]);
    }
}

// Save to file path as xlsx format
string filePath = @"C:\Reports\EmployeeReport_IronXL.xlsx";
workbook.SaveAs(filePath);
Console.WriteLine("Excel file created successfully using IronXL.");
using IronXL;
using System.Data;

// Create a sample DataTable
DataTable dt = new DataTable("Employees");
dt.Columns.Add("EmployeeID", typeof(int));
dt.Columns.Add("Name", typeof(string));
dt.Columns.Add("Department", typeof(string));
dt.Columns.Add("Salary", typeof(decimal));

// Fill DataTable with rows of data
dt.Rows.Add(1, "John Smith", "Engineering", 75000);
dt.Rows.Add(2, "Sarah Johnson", "Marketing", 65000);
dt.Rows.Add(3, "Michael Chen", "Finance", 70000);
dt.Rows.Add(4, "Emily Davis", "Engineering", 80000);

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

// Write column names to the first row as headers
for (int i = 0; i < dt.Columns.Count; i++)
{
    sheet.SetCellValue(0, i, dt.Columns[i].ColumnName);
}

// Export DataTable rows to Excel cells
for (int i = 0; i < dt.Rows.Count; i++)
{
    for (int j = 0; j < dt.Columns.Count; j++)
    {
        sheet.SetCellValue(i + 1, j, dt.Rows[i][j]);
    }
}

// Save to file path as xlsx format
string filePath = @"C:\Reports\EmployeeReport_IronXL.xlsx";
workbook.SaveAs(filePath);
Console.WriteLine("Excel file created successfully using IronXL.");
$vbLabelText   $csharpLabel

Der IronXL-Ansatz folgt einer ähnlichen logischen Struktur, jedoch mit einer übersichtlicheren Syntax und ohne COM-Komplexität. Diese Excel-Bibliothek ermöglicht es Entwicklern, Tabellenkalkulationsdateien ohne Abhängigkeit von Microsoft Office zu erstellen, zu lesen und zu schreiben. Die Methode WorkBook.Create initialisiert eine neue Arbeitsmappe im angegebenen Format – ExcelFileFormat.XLSX erzeugt moderne Office Open XML-Dateien, die mit Excel 2007 und späteren Versionen kompatibel sind, während die Bibliothek auch das XLS-Format für ältere Systeme unterstützt.

Ausgabe

Wie exportiert man eine DataTable nach Excel mit C# unter Verwendung von Interop vs. IronXL? Bild 1 – Excel-Ausgabe

Wie exportiert man eine DataTable nach Excel mit C# unter Verwendung von Interop vs. IronXL? Bild 2 – Konsolenausgabe

Die Methode CreateWorkSheet fügt der Arbeitsmappe ein neues Arbeitsblatt mit dem angegebenen Tabellennamen hinzu. Im Gegensatz zu Interop, wo man zuerst mit dem Anwendungsobjekt arbeitet, arbeitet IronXL direkt mit Dateistrukturen. Der Name des Tabellenblatts wird auf der Registerkarte am unteren Rand von Excel angezeigt, wenn Benutzer die Datei öffnen.

Die Zellenbefüllung erfolgt über SetCellValue , die Zeilenindex, Spaltenindex und den zu schreibenden Wert akzeptiert. Im Gegensatz zur 1-basierten Indizierung von Excel Interop verwendet IronXL 0-basierte Indizes gemäß den Standardkonventionen des .NET Frameworks – Zeile 0 ist die erste Zeile, Spalte 0 die erste Spalte. Diese Konsistenz mit anderen .NET-Sammlungen und DataTable Spalten reduziert die kognitive Belastung und beseitigt Off-by-One-Fehler, die häufig bei der Konvertierung zwischen Indexierungssystemen auftreten.

Die Methode übernimmt die Typkonvertierung automatisch und intelligent. Integer-, String-, Dezimal- und DateTime-Werte werden mit der entsprechenden Excel-Zellformatierung geschrieben. Ein Dezimalwert erscheint als Zahl, die in Formeln verwendet werden kann, während Datumswerte im Format TT/MM/JJJJ oder anderen regionalen Formaten formatiert werden können. Die Bibliothek verarbeitet Nullwerte und fehlende Daten korrekt, ohne Ausnahmen auszulösen.

Beachten Sie das völlige Fehlen von Aufräumcode. IronXL-Objekte sind standardmäßige .NET-verwaltete Objekte, die vom Garbage Collector automatisch verarbeitet werden. Es besteht kein Risiko von verwaisten Prozessen, es muss keine COM-Referenzzählung verwaltet werden und es gibt keine Speicherlecks durch unsachgemäße Entsorgungsmuster. Allein diese Vereinfachung beseitigt eine ganze Kategorie von Fehlern, die Excel-Interop-Lösungen plagen.

Weitere Details zu den Excel-Erstellungsfunktionen von IronXL finden Sie in der Dokumentation zur Tabellenerstellung .

Wie kann man eine wiederverwendbare Exportmethode erstellen?

In Produktionsanwendungen wird häufig eine wiederverwendbare Methode benötigt, die beliebige DataTable in eine Excel-Datei exportieren kann. Das folgende Codebeispiel zeigt eine Hilfsklasse, die die Exportlogik kapselt und von Ereignisbehandlern wie Schaltflächenklicks mit object sender aufgerufen werden kann.

Wiederverwendbarer IronXL Exporthelfer

using IronXL;
using System.Data;
using System.IO;
using System;
public class ExcelExporter
{
    /// <summary>
    /// Export a DataTable to Excel file at the specified path
    /// </summary>
    public static bool ExportToExcel(DataTable dt, string filePath)
    {
        if (dt == null || dt.Rows.Count == 0)
            return false;
        try
        {
            // Create new workbook and worksheet
            WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
            WorkSheet sheet = workbook.CreateWorkSheet(dt.TableName ?? "Sheet1");
            // Write column names as headers in the first row
            for (int i = 0; i < dt.Columns.Count; i++)
            {
                var cell = sheet.GetCellAt(0, i);
                cell.Value = dt.Columns[i].ColumnName;
                cell.Style.Font.Bold = true;
            }
            // Fill cells with data values from each row
            for (int i = 0; i < dt.Rows.Count; i++)
            {
                for (int j = 0; j < dt.Columns.Count; j++)
                {
                    var value = dt.Rows[i][j];
                    // Handle missing or null values
                    if (value == DBNull.Value || value == null)
                        sheet.SetCellValue(i + 1, j, "");
                    else
                        sheet.SetCellValue(i + 1, j, value);
                }
            }
            // Validate file path and save
            FileInfo fileInfo = new FileInfo(filePath);
            if (!fileInfo.Directory.Exists)
                fileInfo.Directory.Create();
            workbook.SaveAs(filePath);
            return true;
        }
        catch (Exception ex)
        {
            Console.WriteLine("Export failed: " + ex.Message);
            return false;
        }
    }
    /// <summary>
    /// Query a DataTable and export filtered results
    /// </summary>
    public static DataTable FilterAndExport(DataTable dt, string filterExpression, string filePath)
    {
        if (dt == null)
            return dt;
        // Create filtered view and export
        DataRow[] filteredRows = dt.Select(filterExpression);
        DataTable filteredTable = dt.Clone();
        foreach (DataRow row in filteredRows)
        {
            filteredTable.ImportRow(row);
        }
        ExportToExcel(filteredTable, filePath);
        return filteredTable;
    }
    /// <summary>
    /// Export DataTable to CSV file as an alternative format
    /// </summary>
    public static string ExportToCsv(DataTable dt)
    {
        StringBuilder sb = new StringBuilder();
        // Write column headers
        string[] columnNames = dt.Columns.Cast<DataColumn>().Select(column => column.ColumnName).ToArray();
        sb.AppendLine(string.Join(",", columnNames));
        // Write data rows
        foreach (DataRow row in dt.Rows)
        {
            string[] values = row.ItemArray.Select(field => field?.ToString() ?? "").ToArray();
            sb.AppendLine(string.Join(",", values));
        }
        return sb.ToString();
    }
}
// Usage example in Windows Forms or WPF event handler
public void ExportButton_Click(object sender, EventArgs e)
{
    DataTable dt = GetEmployeeData(); // Your data source
    string filePath = @"C:\Reports\Export.xlsx";
    bool success = ExcelExporter.ExportToExcel(dt, filePath);
    if (success)
        Console.WriteLine("Export completed successfully");
}
using IronXL;
using System.Data;
using System.IO;
using System;
public class ExcelExporter
{
    /// <summary>
    /// Export a DataTable to Excel file at the specified path
    /// </summary>
    public static bool ExportToExcel(DataTable dt, string filePath)
    {
        if (dt == null || dt.Rows.Count == 0)
            return false;
        try
        {
            // Create new workbook and worksheet
            WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
            WorkSheet sheet = workbook.CreateWorkSheet(dt.TableName ?? "Sheet1");
            // Write column names as headers in the first row
            for (int i = 0; i < dt.Columns.Count; i++)
            {
                var cell = sheet.GetCellAt(0, i);
                cell.Value = dt.Columns[i].ColumnName;
                cell.Style.Font.Bold = true;
            }
            // Fill cells with data values from each row
            for (int i = 0; i < dt.Rows.Count; i++)
            {
                for (int j = 0; j < dt.Columns.Count; j++)
                {
                    var value = dt.Rows[i][j];
                    // Handle missing or null values
                    if (value == DBNull.Value || value == null)
                        sheet.SetCellValue(i + 1, j, "");
                    else
                        sheet.SetCellValue(i + 1, j, value);
                }
            }
            // Validate file path and save
            FileInfo fileInfo = new FileInfo(filePath);
            if (!fileInfo.Directory.Exists)
                fileInfo.Directory.Create();
            workbook.SaveAs(filePath);
            return true;
        }
        catch (Exception ex)
        {
            Console.WriteLine("Export failed: " + ex.Message);
            return false;
        }
    }
    /// <summary>
    /// Query a DataTable and export filtered results
    /// </summary>
    public static DataTable FilterAndExport(DataTable dt, string filterExpression, string filePath)
    {
        if (dt == null)
            return dt;
        // Create filtered view and export
        DataRow[] filteredRows = dt.Select(filterExpression);
        DataTable filteredTable = dt.Clone();
        foreach (DataRow row in filteredRows)
        {
            filteredTable.ImportRow(row);
        }
        ExportToExcel(filteredTable, filePath);
        return filteredTable;
    }
    /// <summary>
    /// Export DataTable to CSV file as an alternative format
    /// </summary>
    public static string ExportToCsv(DataTable dt)
    {
        StringBuilder sb = new StringBuilder();
        // Write column headers
        string[] columnNames = dt.Columns.Cast<DataColumn>().Select(column => column.ColumnName).ToArray();
        sb.AppendLine(string.Join(",", columnNames));
        // Write data rows
        foreach (DataRow row in dt.Rows)
        {
            string[] values = row.ItemArray.Select(field => field?.ToString() ?? "").ToArray();
            sb.AppendLine(string.Join(",", values));
        }
        return sb.ToString();
    }
}
// Usage example in Windows Forms or WPF event handler
public void ExportButton_Click(object sender, EventArgs e)
{
    DataTable dt = GetEmployeeData(); // Your data source
    string filePath = @"C:\Reports\Export.xlsx";
    bool success = ExcelExporter.ExportToExcel(dt, filePath);
    if (success)
        Console.WriteLine("Export completed successfully");
}
$vbLabelText   $csharpLabel

Diese Hilfsklasse demonstriert mehrere produktionsreife Muster. Die Methode ExportToExcel akzeptiert eine beliebige DataTable und einen Dateipfad als Zeichenkette und gibt false zurück, wenn der Export fehlschlägt oder die Tabelle leer ist. Die Methode geht elegant mit fehlenden Werten um, indem sie vor dem Schreiben in die Zellen auf DBNull.Value prüft.

Die Methode FilterAndExport zeigt, wie man eine DataTable mithilfe von Filterausdrücken vor dem Export abfragt – nützlich, wenn Benutzer nur bestimmte Datensätze exportieren müssen. Die Methode gibt die gefilterte DataTable zurück, sodass der aufrufende Code sie für die weitere Verarbeitung verwenden kann.

Die ExportToCsv Methode verwendet einen StringBuilder , um effizient eine CSV-Ausgabe als Alternative zum Excel-Format zu erstellen. IronXL unterstützt zwar den CSV-Export nativ, dieses Beispiel zeigt jedoch aus Lehrgründen die manuelle Vorgehensweise.

Das Beispiel des Ereignishandlers zeigt, wie diese Methoden in Windows Forms- oder WPF-Anwendungen integriert werden, bei denen object sender und EventArgs Standardparameter sind. Einige Entwickler, die mit ClosedXML vertraut sind, erkennen möglicherweise ähnliche Muster bei der Verwendung new XLWorkbook() , aber die API von IronXL bietet eine gleichwertige Funktionalität mit zusätzlicher Formatunterstützung.

Wie gehen beide Ansätze mit der Zellformatierung um?

Professionelle Excel-Exporte erfordern oft Formatierungen: fettgedruckte Überschriften, farbige Zellen, Rahmen und Zahlenformate. Beide Bibliotheken unterstützen Styling, die Implementierung unterscheidet sich jedoch deutlich.

Formatierung mit Interop

using Microsoft.Office.Interop.Excel;
using System.Data;
using System.Runtime.InteropServices;
DataTable dt = new DataTable("Sales");
dt.Columns.Add("Product", typeof(string));
dt.Columns.Add("Revenue", typeof(decimal));
dt.Rows.Add("Widget A", 15000.50m);
dt.Rows.Add("Widget B", 22500.75m);
Application excelApp = new Application();
Workbook workbook = excelApp.Workbooks.Add();
Worksheet worksheet = (Worksheet)workbook.ActiveSheet;
// Write column headers with formatting to first row
for (int i = 0; i < dt.Columns.Count; i++)
{
    Range headerCell = worksheet.Cells[1, i + 1];
    headerCell.Value = dt.Columns[i].ColumnName;
    headerCell.Font.Bold = true;
    headerCell.Interior.Color = System.Drawing.ColorTranslator.ToOle(System.Drawing.Color.LightBlue);
    headerCell.Borders.LineStyle = XlLineStyle.xlContinuous;
}
// Write data values to cells
for (int i = 0; i < dt.Rows.Count; i++)
{
    for (int j = 0; j < dt.Columns.Count; j++)
    {
        worksheet.Cells[i + 2, j + 1] = dt.Rows[i][j];
    }
}
string filePath = @"C:\Reports\FormattedReport_Interop.xlsx";
workbook.SaveAs(filePath);
workbook.Close();
excelApp.Quit();
Marshal.ReleaseComObject(worksheet);
Marshal.ReleaseComObject(workbook);
Marshal.ReleaseComObject(excelApp);
using Microsoft.Office.Interop.Excel;
using System.Data;
using System.Runtime.InteropServices;
DataTable dt = new DataTable("Sales");
dt.Columns.Add("Product", typeof(string));
dt.Columns.Add("Revenue", typeof(decimal));
dt.Rows.Add("Widget A", 15000.50m);
dt.Rows.Add("Widget B", 22500.75m);
Application excelApp = new Application();
Workbook workbook = excelApp.Workbooks.Add();
Worksheet worksheet = (Worksheet)workbook.ActiveSheet;
// Write column headers with formatting to first row
for (int i = 0; i < dt.Columns.Count; i++)
{
    Range headerCell = worksheet.Cells[1, i + 1];
    headerCell.Value = dt.Columns[i].ColumnName;
    headerCell.Font.Bold = true;
    headerCell.Interior.Color = System.Drawing.ColorTranslator.ToOle(System.Drawing.Color.LightBlue);
    headerCell.Borders.LineStyle = XlLineStyle.xlContinuous;
}
// Write data values to cells
for (int i = 0; i < dt.Rows.Count; i++)
{
    for (int j = 0; j < dt.Columns.Count; j++)
    {
        worksheet.Cells[i + 2, j + 1] = dt.Rows[i][j];
    }
}
string filePath = @"C:\Reports\FormattedReport_Interop.xlsx";
workbook.SaveAs(filePath);
workbook.Close();
excelApp.Quit();
Marshal.ReleaseComObject(worksheet);
Marshal.ReleaseComObject(workbook);
Marshal.ReleaseComObject(excelApp);
$vbLabelText   $csharpLabel

Der Interop-Formatierungscode greift auf einzelne Range Objekte zu und legt Eigenschaften wie Font.Bold , Interior.Color und Borders.LineStyle fest. Jeder Zugriff auf eine Eigenschaft ist ein COM-Interprozessaufruf, was zusätzlichen Aufwand verursacht und die Wahrscheinlichkeit von Ausnahmen erhöht, falls Excel nicht mehr reagiert.

Formatierung mit IronXL

using IronXL;
using IronXL.Styles;
using System.Data;
DataTable dt = new DataTable("Sales");
dt.Columns.Add("Product", typeof(string));
dt.Columns.Add("Revenue", typeof(decimal));
dt.Rows.Add("Widget A", 15000.50m);
dt.Rows.Add("Widget B", 22500.75m);
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Sales");
// Write column headers with formatting to first row
for (int i = 0; i < dt.Columns.Count; i++)
{
    sheet.SetCellValue(0, i, dt.Columns[i].ColumnName);
    var cell = sheet.GetCellAt(0, i);
    cell.Value = dt.Columns[i].ColumnName;
    cell.Style.Font.Bold = true;
    cell.Style.SetBackgroundColor("#ADD8E6");
    cell.Style.BottomBorder.SetColor("#000000");
    cell.Style.BottomBorder.Type = BorderType.Thin;
}
// Write data rows with values from DataTable
for (int i = 0; i < dt.Rows.Count; i++)
{
    for (int j = 0; j < dt.Columns.Count; j++)
    {
        sheet.SetCellValue(i + 1, j, dt.Rows[i][j]);
    }
}
string filePath = @"C:\Reports\FormattedReport_IronXL.xlsx";
workbook.SaveAs(filePath);
using IronXL;
using IronXL.Styles;
using System.Data;
DataTable dt = new DataTable("Sales");
dt.Columns.Add("Product", typeof(string));
dt.Columns.Add("Revenue", typeof(decimal));
dt.Rows.Add("Widget A", 15000.50m);
dt.Rows.Add("Widget B", 22500.75m);
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Sales");
// Write column headers with formatting to first row
for (int i = 0; i < dt.Columns.Count; i++)
{
    sheet.SetCellValue(0, i, dt.Columns[i].ColumnName);
    var cell = sheet.GetCellAt(0, i);
    cell.Value = dt.Columns[i].ColumnName;
    cell.Style.Font.Bold = true;
    cell.Style.SetBackgroundColor("#ADD8E6");
    cell.Style.BottomBorder.SetColor("#000000");
    cell.Style.BottomBorder.Type = BorderType.Thin;
}
// Write data rows with values from DataTable
for (int i = 0; i < dt.Rows.Count; i++)
{
    for (int j = 0; j < dt.Columns.Count; j++)
    {
        sheet.SetCellValue(i + 1, j, dt.Rows[i][j]);
    }
}
string filePath = @"C:\Reports\FormattedReport_IronXL.xlsx";
workbook.SaveAs(filePath);
$vbLabelText   $csharpLabel

Die Styling-API von IronXL verwendet eine flüssige, intuitive Syntax, die .NET-Entwicklern vertraut sein wird. Die Style Eigenschaft ermöglicht den Zugriff auf Schrifteinstellungen, Hintergrundfarben und Rahmen über ein übersichtliches Objektmodell. Die Farbwerte akzeptieren Standard-Hexadezimalcodes wie #ADD8E6 (Hellblau), wodurch es einfach ist, das Corporate Branding oder Designvorgaben ohne Umrechnung zwischen Farbsystemen zu erfüllen.

Ausgabe

Wie exportiert man eine DataTable nach Excel mit C# unter Verwendung von Interop vs. IronXL? Bild 3 – Formatierung mit IronXL-Ausgabe

Die Zellzugriffssyntax sheet[row, col] ermöglicht den direkten Zugriff auf einzelne Zellen, ohne zusätzliche Objekte oder Bereichsreferenzen zu erstellen. Dieser Ansatz reduziert die Code-Länge und eliminiert die bei COM-basierten APIs erforderlichen Prozeduren. Das Festlegen mehrerer Stileigenschaften für dieselbe Zelle ist unkompliziert – jede Eigenschaftszuweisung ändert das Erscheinungsbild der Zelle direkt.

Die Rahmenkonfiguration verdeutlicht das praxisorientierte Design von IronXL. Anstatt sich mit Aufzählungswerten auseinanderzusetzen, die Nachschlagevorgänge in der Dokumentation erfordern, verwenden Entwickler BorderType.Thin für Standardrahmen oder BorderType.Thick für hervorgehobene Begrenzungen. Die SetColor Methode akzeptiert Hex-Farbcodes für die Rahmenfärbung und gewährleistet so die Konsistenz mit der Hintergrundfarbspezifikation.

Für umfassende Formatierungsoptionen, einschließlich Zahlenformaten, bedingter Formatierung und fortgeschrittener Gestaltungstechniken, erkunden Sie die Dokumentation zur Zellformatierung und den Leitfaden zur Rahmenausrichtung .

Bewährte Verfahren für den Export

Um einen reibungslosen und zuverlässigen Datenexport nach Excel zu gewährleisten, ist es wichtig, während des gesamten Entwicklungsprozesses bewährte Verfahren zu befolgen. Um die Dateiverwaltung einfach und vorhersehbar zu gestalten, verwenden Sie für die exportierte Excel-Datei stets einen einheitlichen Dateipfad und eine einheitliche Namenskonvention. Implementieren Sie eine robuste Fehlerbehandlung, indem Sie Ausnahmen abfangen – beispielsweise mit catch (Exception ex) – und false zurückgeben oder eine aussagekräftige Rückmeldung geben, wenn beim Export ein Fehler auftritt. Für große Datensätze empfiehlt sich die Verwendung des OpenXML SDK, das eine leistungsstarke und speichereffiziente Möglichkeit bietet, Daten in Excel-Dateien zu schreiben, ohne den Aufwand einer Automatisierung von Microsoft Excel. Bibliotheken wie ClosedXML vereinfachen den Exportprozess zusätzlich und bieten intuitive APIs, die dazu beitragen, dass Ihr Code effizient funktioniert und leicht zu warten ist. Durch die Einhaltung dieser Best Practices können Entwickler Exportroutinen erstellen, die sowohl zuverlässig als auch skalierbar sind und unabhängig von der Größe oder Komplexität des Datensatzes genaue Daten in Excel-Dateien liefern.

Wann sollte man welche Vorgehensweise wählen?

Die richtige Wahl hängt von den spezifischen Anforderungen des Projekts, der Einsatzumgebung und den langfristigen Wartungsüberlegungen ab, wenn Sie DataTable-Daten in Excel-Dateien exportieren müssen.

Wählen Sie Microsoft Office Excel Interop, wenn:

  • Arbeiten mit Legacy-Systemen, auf denen Office bereits installiert ist und die von Interop abhängig sind
  • Benötigt werden fortgeschrittene Excel-Funktionen wie Makros, Pivot-Tabellen oder Diagrammautomatisierung, die das vollständige Excel-Anwendungsobjektmodell erfordern.
  • Entwicklung von Desktop-Anwendungen, bei denen Microsoft Excel installiert ist und die Anwendung interaktiv ausgeführt wird Die Bereitstellungsumgebung ist vollständig kontrolliert, basiert ausschließlich auf Windows, und Office-Lizenzen sind bereits verfügbar.
  • Automatisierung bestehender Excel-Vorlagen mit komplexen eingebetteten Formeln oder VBA-Code

Wählen Sie IronXL, wenn:

  • Entwicklung von Webanwendungen, REST-APIs oder Hintergrunddiensten, die Excel-Dateiexporte generieren
  • Bereitstellung in Cloud-Umgebungen wie Azure App Services, AWS Lambda oder Docker-Containern
  • Erfordert plattformübergreifende Unterstützung für Windows-, Linux- oder macOS-Bereitstellungen
  • Arbeiten mit .NET Framework 4.6.2+ oder neueren .NET-Versionen, bei denen die Interop-Unterstützung eingeschränkt ist.
  • Bedarf an zuverlässigem, planbarem Ressourcenmanagement ohne COM-Bereinigungsprobleme
  • Vermeidung von Office-Lizenzabhängigkeiten auf Produktionsservern
  • Entwicklung von mandantenfähigen Anwendungen, bei denen die Generierung isolierter Excel-Dateien unerlässlich ist
  • Effiziente Verarbeitung großer Datensätze ohne den Overhead der COM-Interprozesskommunikation
  • Export in mehrere Formate erforderlich, darunter XLSX, XLS, CSV-Datei, JSON und XML

Die IronXL-Tutorials bieten zusätzliche Beispiele für häufige Anwendungsfälle, darunter das Lesen vorhandener Excel-Dateien , das Arbeiten mit Formeln und das Verwalten mehrerer Arbeitsblätter . Die Bibliothek unterstützt auch die Arbeit mit DataSet-Objekten, wenn Sie mehrere zusammengehörige Tabellen in verschiedene Tabellenblätter exportieren müssen.

Abschluss

Der Export einer DataTable in eine Excel-Datei ist eine grundlegende Voraussetzung für .NET-Anwendungen, die Geschäftsdaten verarbeiten. Egal ob Sie Daten aus einer Datenbankabfrage exportieren, Berichte aus einem DataSet erstellen oder DataTable-Spalten in formatierte Excel-Tabellen konvertieren müssen – die Wahl der richtigen Bibliothek ist entscheidend.

Während Microsoft Office Excel Interop Entwicklern jahrelang gute Dienste geleistet hat, machen die Abhängigkeit von der Office-Installation, die COM-Komplexität, nicht unterstützte Serverszenarien und die Herausforderungen im Ressourcenmanagement es für die moderne Anwendungsentwicklung zunehmend unpraktisch. Häufige Probleme sind beispielsweise mit COM-Bereinigungscode gefüllte catch (Exception ex) und Workarounds für fehlende Referenzen.

IronXL bietet eine sauberere und zuverlässigere Alternative, die diese Einschränkungen direkt angeht. Mit einfacher Install-Package über NuGet, plattformübergreifender Unterstützung für Windows, Linux und macOS sowie unkomplizierten APIs, die den Konventionen des .NET Frameworks folgen, beseitigt es die Bereitstellungsprobleme und Fallstricke der Ressourcenverwaltung, die Excel Interop-Lösungen plagen. Die Codebeispiele in diesem Artikel zeigen, dass die Durchführung der gleichen DataTable-zu-Excel-Exportaufgabe einen ähnlichen Entwicklungsaufwand erfordert – IronXL liefert jedoch Ergebnisse ohne den operativen Aufwand und die Wartungsbelastung.

Sind Sie bereit, die Excel-Dateierstellung in .NET-Projekten zu vereinfachen? Starten Sie eine kostenlose Testversion von IronXL und erleben Sie den Unterschied in Ihrem Entwicklungs-Workflow. Für den Einsatz in der Produktion und die Teamlizenzierung sollten Sie die Lizenzierungsoptionen erkunden, die den Bedürfnissen Ihrer Organisation entsprechen.

Häufig gestellte Fragen

Was ist der Hauptvorteil von IronXL gegenüber Excel Interop beim Exportieren von DataTables in C#?

IronXL bietet eine einfachere und effizientere Möglichkeit, DataTables in C# nach Excel zu exportieren, ohne dass Excel auf dem Server installiert sein muss.

Kann IronXL große DataTables beim Export nach Excel verarbeiten?

Ja, IronXL ist auf Leistung optimiert und kann große DataTables verarbeiten, wodurch ein schneller und zuverlässiger Export in Excel-Dateien gewährleistet wird.

Muss ich Microsoft Excel installieren, um IronXL zum Datenexport zu verwenden?

Nein, IronXL benötigt keine Installation von Microsoft Excel und ist daher ideal für serverseitige Anwendungen geeignet.

Wie vereinfacht IronXL den Prozess des Exportierens von DataTables im Vergleich zu Interop?

IronXL vereinfacht den Prozess, indem es die komplexe Einrichtung und die mit Interop verbundenen Abhängigkeiten eliminiert und eine unkomplizierte API zum Exportieren von DataTables bereitstellt.

Ist IronXL mit .NET Core für den Export von DataTables nach Excel kompatibel?

Ja, IronXL ist vollständig kompatibel mit .NET Core und ermöglicht Ihnen den Export von DataTables nach Excel in plattformübergreifenden Anwendungen.

In welche Dateiformate kann IronXL DataTables exportieren?

IronXL kann DataTables in verschiedene Excel-Dateiformate exportieren, darunter XLSX, XLS und CSV.

Unterstützt IronXL das Styling und die Formatierung von Excel-Tabellen?

Ja, IronXL unterstützt erweiterte Styling- und Formatierungsoptionen, mit denen Sie aus DataTables ansprechende Excel-Tabellen erstellen können.

Kann ich IronXL verwenden, um Excel-bezogene Aufgaben in C# zu automatisieren?

Ja, IronXL kann zur Automatisierung einer breiten Palette von Excel-bezogenen Aufgaben verwendet werden, vom Exportieren von DataTables bis hin zu komplexen Datenanalyseoperationen.

Gibt es für Entwickler, die neu bei IronXL sind, eine Lernkurve?

IronXL ist intuitiv und leicht zu erlernen, mit umfangreicher Dokumentation und Beispielen, die Entwicklern den Einstieg erleichtern.

Welche Lizenzoptionen gibt es für die Nutzung von IronXL in einem kommerziellen Projekt?

IronXL bietet verschiedene Lizenzoptionen für unterschiedliche Projektanforderungen an, darunter Dauerlizenzen und Abonnementlizenzen für die kommerzielle Nutzung.

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