C# DataGridView-Export nach Excel: Vollständige Anleitung mit Formatierung | IronXL

Das Exportieren von DataGridView-Daten in eine Excel-Datei ist eine der häufigsten Aufgaben in der Windows Forms-Entwicklung. Beim Erstellen von Geschäftsanwendungen, die tabellarische Daten anzeigen – seien es Verkaufsberichte, Lagerbestandsaufzeichnungen oder Kundenlisten – erwarten die Benutzer, dass sie auf eine Schaltfläche klicken und eine ordnungsgemäß formatierte Excel-Datei erhalten, die sie weitergeben oder weiter analysieren können. Die Herausforderung besteht darin, dies sauber zu bewerkstelligen, ohne auf eine Microsoft Excel-Installation auf jedem Endbenutzerrechner angewiesen zu sein und ohne sich mit COM-Interop-Bereinigungscode herumschlagen zu müssen, der Speicherlecks verursacht oder stillschweigend Fehler verursacht. Dieser Leitfaden führt Sie durch den gesamten Prozess des Exports von DataGridView nach Excel in C# mit IronXL, von der Projekt-Setup bis hin zur erweiterten Zellformatierung, damit Sie mit produktionsbereitem Code enden.
Wie richtet man ein Windows Forms-Projekt für den DataGridView-Export ein?
Traditionelle Ansätze zum Exportieren von DataGridView-Daten basierten auf Microsoft Interop - Sie müssen unter 'Verweis hinzufügen' die COM-Registerkarte öffnen, die Microsoft Excel Objektbibliothek auswählen und fragilen Code schreiben, der Marshal.ReleaseComObject aufruft, um Speicherlecks zu vermeiden. Dieses Muster erfordert die Installation von Microsoft Excel auf jedem Computer, auf dem die Anwendung läuft, arbeitet langsam mit großen Datensätzen und erzeugt oft COMException-Fehler in Bereitstellungsumgebungen, die keine Office-Lizenzen haben. In den eigenen Richtlinien von Microsoft zur Office-Automatisierung werden ausdrücklich Drittanbieterbibliotheken für serverseitige und automatisierte Szenarien empfohlen.
IronXL beseitigt all diese Abhängigkeiten. Es ist eine reine .NET-Bibliothek, die .xlsx-, .xls-, .csv- und .ods-Dateien ohne Microsoft Office oder jede COM-Registrierung liest und schreibt. Sie installieren es über NuGet und können sofort mit dem Programmieren beginnen.
Installation von IronXL über NuGet
Beginnen Sie mit der Erstellung eines neuen Windows Forms App-Projekts in Visual Studio, das auf .NET 10 abzielt. Fügen Sie ein DataGridView-Steuerelement und ein Button auf die Formularoberfläche hinzu. Nennen Sie die Schaltfläche btnExport und geben Sie ihr das Label "Export to Excel". Öffnen Sie anschließend die NuGet Paket-Manager-Konsole und führen Sie folgenden Befehl aus:
Install-Package IronXL.Excel
Fügen Sie die erforderlichen Namensräume am Anfang Ihrer Formulardatei hinzu:
using IronXL;
using System.Data;
using IronXL;
using System.Data;
Imports IronXL
Imports System.Data
Diese beiden Namespaces decken alle IronXL-Typen ab, die Sie für das Lesen und Schreiben von Excel-Arbeitsmappen benötigen, sowie die Standard-System.Data-Typen zur Arbeit mit DataTable-Objekten, die Ihre DataGridView mit der Export-Pipeline verbinden.
Wie lädt man Beispieldaten in ein DataGridView-Steuerelement?
Bevor Sie die Exportlogik erstellen, füllen Sie Ihren DataGridView mit repräsentativen Daten. Das Form1_Load-Ereignis ist der richtige Ort, um einen DataTable als Datenquelle zu binden. In einer echten Anwendung würden Sie eine Datenbank abfragen oder einen Dienst aufrufen; hier verdeutlicht ein fest codierter DataTable die Struktur deutlich. Die Übersicht zum DataGridView-Steuerelement in Microsoft Docs bietet zusätzlichen Kontext dazu, wie das Steuerelement Datenquellen verwaltet.
Binden einer DataTable an ein DataGridView
void Form1_Load(object sender, EventArgs e)
{
DataTable dt = new DataTable();
dt.Columns.Add("ProductID", typeof(int));
dt.Columns.Add("ProductName", typeof(string));
dt.Columns.Add("Price", typeof(decimal));
dt.Columns.Add("Stock", typeof(int));
dt.Rows.Add(1, "Laptop", 999.99m, 50);
dt.Rows.Add(2, "Mouse", 29.99m, 200);
dt.Rows.Add(3, "Keyboard", 79.99m, 150);
dt.Rows.Add(4, "Monitor", 349.99m, 75);
dt.Rows.Add(5, "Webcam", 89.99m, 120);
dataGridView1.DataSource = dt;
}
void Form1_Load(object sender, EventArgs e)
{
DataTable dt = new DataTable();
dt.Columns.Add("ProductID", typeof(int));
dt.Columns.Add("ProductName", typeof(string));
dt.Columns.Add("Price", typeof(decimal));
dt.Columns.Add("Stock", typeof(int));
dt.Rows.Add(1, "Laptop", 999.99m, 50);
dt.Rows.Add(2, "Mouse", 29.99m, 200);
dt.Rows.Add(3, "Keyboard", 79.99m, 150);
dt.Rows.Add(4, "Monitor", 349.99m, 75);
dt.Rows.Add(5, "Webcam", 89.99m, 120);
dataGridView1.DataSource = dt;
}
Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
Dim dt As New DataTable()
dt.Columns.Add("ProductID", GetType(Integer))
dt.Columns.Add("ProductName", GetType(String))
dt.Columns.Add("Price", GetType(Decimal))
dt.Columns.Add("Stock", GetType(Integer))
dt.Rows.Add(1, "Laptop", 999.99D, 50)
dt.Rows.Add(2, "Mouse", 29.99D, 200)
dt.Rows.Add(3, "Keyboard", 79.99D, 150)
dt.Rows.Add(4, "Monitor", 349.99D, 75)
dt.Rows.Add(5, "Webcam", 89.99D, 120)
dataGridView1.DataSource = dt
End Sub
Dieser Code verwendet den Top-Level-Anweisungsstil für die Signatur des Ereignishandlers. Der DataTable hat vier typisierte Spalten - Integer, String, Dezimal und Integer -, die IronXL beim Schreiben in die Excel-Arbeitsmappe bewahrt. Typisierte Spalten sind wichtig, da IronXL numerische Spalten als numerische Zellen und nicht als Text schreibt. Dadurch können Benutzer Werte in Excel sortieren und summieren, ohne sie neu formatieren zu müssen.

Der DataGridView rendert automatisch eine Spaltenkopfzeile aus den DataTable-Spaltennamen. Beim Exportieren möchten Sie, dass die Kopfzeile in der Excel-Datei erhalten bleibt. Das bedeutet, dass Ihr Exportcode die Kopfzeilen getrennt von den Datenzeilen verarbeiten muss – genau darum geht es im nächsten Abschnitt.
Für den Produktionseinsatz gilt dasselbe Muster, unabhängig davon, ob der DataTable aus Entity Framework, Dapper, ADO.NET oder einer anderen Datenzugriffsschicht stammt. Die DataGridView-Bindung ist vom Exportcode entkoppelt, sodass Sie die Datenquelle ändern können, ohne die Exportlogik anzufassen.
Wie exportiert man DataGridView-Daten in eine Excel-Datei?
Die Kernlogik für den Export wird innerhalb des Button-Click-Handlers ausgeführt. IronXL bietet eine LoadFromDataTable-Methode auf WorkSheet, die das Spalten-zu-Zelle-Mapping automatisch handhabt. Der sauberste Ansatz extrahiert einen DataTable aus dem DataGridView und übergibt ihn direkt weiter. Das Open XML SDK, das dem .xlsx-Format zugrunde liegt, wird von Microsoft dokumentiert und bestätigt, warum reine .NET-Lösungen wie IronXL Interop bei der programmgesteuerten Erstellung übertreffen.
Export-Handler per Knopfdruck
void btnExport_Click(object sender, EventArgs e)
{
try
{
DataTable dt = new DataTable();
foreach (DataGridViewColumn column in dataGridView1.Columns)
dt.Columns.Add(column.HeaderText);
foreach (DataGridViewRow row in dataGridView1.Rows)
{
if (row.IsNewRow) continue;
DataRow dataRow = dt.NewRow();
for (int i = 0; i < dataGridView1.Columns.Count; i++)
dataRow[i] = row.Cells[i].Value ?? DBNull.Value;
dt.Rows.Add(dataRow);
}
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.DefaultWorkSheet;
worksheet.Name = "Product Data";
worksheet.LoadFromDataTable(dt, true);
string outputPath = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.Desktop),
"DataGridViewExport.xlsx"
);
workbook.SaveAs(outputPath);
MessageBox.Show($"Exported successfully to:\n{outputPath}", "Export Complete",
MessageBoxButtons.OK, MessageBoxIcon.Information);
}
catch (Exception ex)
{
MessageBox.Show($"Export failed: {ex.Message}", "Error",
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
void btnExport_Click(object sender, EventArgs e)
{
try
{
DataTable dt = new DataTable();
foreach (DataGridViewColumn column in dataGridView1.Columns)
dt.Columns.Add(column.HeaderText);
foreach (DataGridViewRow row in dataGridView1.Rows)
{
if (row.IsNewRow) continue;
DataRow dataRow = dt.NewRow();
for (int i = 0; i < dataGridView1.Columns.Count; i++)
dataRow[i] = row.Cells[i].Value ?? DBNull.Value;
dt.Rows.Add(dataRow);
}
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.DefaultWorkSheet;
worksheet.Name = "Product Data";
worksheet.LoadFromDataTable(dt, true);
string outputPath = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.Desktop),
"DataGridViewExport.xlsx"
);
workbook.SaveAs(outputPath);
MessageBox.Show($"Exported successfully to:\n{outputPath}", "Export Complete",
MessageBoxButtons.OK, MessageBoxIcon.Information);
}
catch (Exception ex)
{
MessageBox.Show($"Export failed: {ex.Message}", "Error",
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
Imports System
Imports System.Data
Imports System.IO
Imports System.Windows.Forms
Public Sub btnExport_Click(sender As Object, e As EventArgs)
Try
Dim dt As New DataTable()
For Each column As DataGridViewColumn In dataGridView1.Columns
dt.Columns.Add(column.HeaderText)
Next
For Each row As DataGridViewRow In dataGridView1.Rows
If row.IsNewRow Then Continue For
Dim dataRow As DataRow = dt.NewRow()
For i As Integer = 0 To dataGridView1.Columns.Count - 1
dataRow(i) = If(row.Cells(i).Value, DBNull.Value)
Next
dt.Rows.Add(dataRow)
Next
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.DefaultWorkSheet
worksheet.Name = "Product Data"
worksheet.LoadFromDataTable(dt, True)
Dim outputPath As String = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.Desktop),
"DataGridViewExport.xlsx"
)
workbook.SaveAs(outputPath)
MessageBox.Show($"Exported successfully to:{Environment.NewLine}{outputPath}", "Export Complete",
MessageBoxButtons.OK, MessageBoxIcon.Information)
Catch ex As Exception
MessageBox.Show($"Export failed: {ex.Message}", "Error",
MessageBoxButtons.OK, MessageBoxIcon.Error)
End Try
End Sub

Der LoadFromDataTable(dt, true)-Aufruf nimmt den DataTable und ein boolesches Flag, das IronXL anweist, die Spaltennamen als erste Excel-Zeile zu schreiben - diese werden zu Ihren Kopfzellen. Die Arbeitsmappe wird mithilfe von Environment.SpecialFolder.Desktop auf dem Desktop des Benutzers gespeichert, anstatt eines fest codierten Pfads, was den Code portabel über Benutzerkonten hinweg macht.
Die null-Überprüfung (?? DBNull.Value) prevents a NullReferenceException, wenn eine Zelle keinen Wert enthält. Dies ist wichtig für reale Daten, bei denen optionale Felder leer sein können. IronXL schreibt DBNull als leere Zelle anstatt der Zeichenfolge "DBNull", damit die Ausgabe sauber bleibt.
Für weitere Details zum Zurücklesen von Daten aus Excel-Dateien in ein DataGridView, siehe die IronXL DataTable-Dokumentation, die den Umkehrvorgang abdeckt und wie Sie Excel in DataSet konvertieren für Arbeitsmappen mit mehreren Blättern.
Wie wendet man Professional Formatierung auf die exportierte Excel-Datei an?
Einfache Daten in einer Excel-Datei sind zwar funktional, aber eine professionell formatierte Ausgabe – fettgedruckte Überschriften, an den Inhalt angepasste Spaltenbreiten, abwechselnde Zeilenhintergrundfarben – macht den Unterschied zwischen einem Tool, dem die Benutzer vertrauen, und einem, das sie exportieren und sofort wieder manuell formatieren. IronXL stellt eine umfangreiche API zur Zellformatierung bereit, die Schriftarten, Farben, Rahmen, Zahlenformate und Ausrichtung abdeckt. Die OOXML-Spezifikation für Tabellenstile definiert das zugrunde liegende Format, das IronXL schreibt, und gibt Ihnen die Gewissheit, dass die Ausgabe in jeder kompatiblen Anwendung korrekt geöffnet wird.
Anwenden von Kopfzeilenstilen und Abwechseln von Zeilenfarben
void ExportWithFormatting(object sender, EventArgs e)
{
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.DefaultWorkSheet;
worksheet.Name = "Formatted Export";
string[] headers = { "ID", "Product Name", "Price", "Stock" };
// Write and style header row
for (int col = 0; col < headers.Length; col++)
{
char colLetter = (char)('A' + col);
string cellAddress = $"{colLetter}1";
worksheet.SetCellValue(0, col, headers[col]);
worksheet[cellAddress].Style.Font.Bold = true;
worksheet[cellAddress].Style.Font.Height = 12;
worksheet[cellAddress].Style.SetBackgroundColor("#4472C4");
worksheet[cellAddress].Style.Font.Color = "#FFFFFF";
worksheet[cellAddress].Style.HorizontalAlignment =
IronXL.Styles.HorizontalAlignment.Center;
}
// Write data rows with alternating background colors
int rowIndex = 1;
foreach (DataGridViewRow row in dataGridView1.Rows)
{
if (row.IsNewRow) continue;
for (int col = 0; col < dataGridView1.Columns.Count; col++)
{
worksheet.SetCellValue(rowIndex, col,
row.Cells[col].Value?.ToString() ?? string.Empty);
}
if (rowIndex % 2 == 0)
{
string rangeAddress = $"A{rowIndex + 1}:D{rowIndex + 1}";
worksheet[rangeAddress].Style.SetBackgroundColor("#D6DCE5");
}
rowIndex++;
}
// Format the Price column as currency
worksheet["C2:C100"].Style.Format = "$#,##0.00";
// Auto-fit column widths
worksheet.AutoSizeColumn(0);
worksheet.AutoSizeColumn(1);
worksheet.AutoSizeColumn(2);
worksheet.AutoSizeColumn(3);
string outputPath = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.Desktop),
"FormattedExport.xlsx"
);
workbook.SaveAs(outputPath);
MessageBox.Show("Formatted export complete.", "Done",
MessageBoxButtons.OK, MessageBoxIcon.Information);
}
void ExportWithFormatting(object sender, EventArgs e)
{
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.DefaultWorkSheet;
worksheet.Name = "Formatted Export";
string[] headers = { "ID", "Product Name", "Price", "Stock" };
// Write and style header row
for (int col = 0; col < headers.Length; col++)
{
char colLetter = (char)('A' + col);
string cellAddress = $"{colLetter}1";
worksheet.SetCellValue(0, col, headers[col]);
worksheet[cellAddress].Style.Font.Bold = true;
worksheet[cellAddress].Style.Font.Height = 12;
worksheet[cellAddress].Style.SetBackgroundColor("#4472C4");
worksheet[cellAddress].Style.Font.Color = "#FFFFFF";
worksheet[cellAddress].Style.HorizontalAlignment =
IronXL.Styles.HorizontalAlignment.Center;
}
// Write data rows with alternating background colors
int rowIndex = 1;
foreach (DataGridViewRow row in dataGridView1.Rows)
{
if (row.IsNewRow) continue;
for (int col = 0; col < dataGridView1.Columns.Count; col++)
{
worksheet.SetCellValue(rowIndex, col,
row.Cells[col].Value?.ToString() ?? string.Empty);
}
if (rowIndex % 2 == 0)
{
string rangeAddress = $"A{rowIndex + 1}:D{rowIndex + 1}";
worksheet[rangeAddress].Style.SetBackgroundColor("#D6DCE5");
}
rowIndex++;
}
// Format the Price column as currency
worksheet["C2:C100"].Style.Format = "$#,##0.00";
// Auto-fit column widths
worksheet.AutoSizeColumn(0);
worksheet.AutoSizeColumn(1);
worksheet.AutoSizeColumn(2);
worksheet.AutoSizeColumn(3);
string outputPath = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.Desktop),
"FormattedExport.xlsx"
);
workbook.SaveAs(outputPath);
MessageBox.Show("Formatted export complete.", "Done",
MessageBoxButtons.OK, MessageBoxIcon.Information);
}
Option Strict On
Sub ExportWithFormatting(sender As Object, e As EventArgs)
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.DefaultWorkSheet
worksheet.Name = "Formatted Export"
Dim headers As String() = {"ID", "Product Name", "Price", "Stock"}
' Write and style header row
For col As Integer = 0 To headers.Length - 1
Dim colLetter As Char = ChrW(AscW("A"c) + col)
Dim cellAddress As String = $"{colLetter}1"
worksheet.SetCellValue(0, col, headers(col))
worksheet(cellAddress).Style.Font.Bold = True
worksheet(cellAddress).Style.Font.Height = 12
worksheet(cellAddress).Style.SetBackgroundColor("#4472C4")
worksheet(cellAddress).Style.Font.Color = "#FFFFFF"
worksheet(cellAddress).Style.HorizontalAlignment = IronXL.Styles.HorizontalAlignment.Center
Next
' Write data rows with alternating background colors
Dim rowIndex As Integer = 1
For Each row As DataGridViewRow In dataGridView1.Rows
If row.IsNewRow Then Continue For
For col As Integer = 0 To dataGridView1.Columns.Count - 1
worksheet.SetCellValue(rowIndex, col, If(row.Cells(col).Value?.ToString(), String.Empty))
Next
If rowIndex Mod 2 = 0 Then
Dim rangeAddress As String = $"A{rowIndex + 1}:D{rowIndex + 1}"
worksheet(rangeAddress).Style.SetBackgroundColor("#D6DCE5")
End If
rowIndex += 1
Next
' Format the Price column as currency
worksheet("C2:C100").Style.Format = "$#,##0.00"
' Auto-fit column widths
worksheet.AutoSizeColumn(0)
worksheet.AutoSizeColumn(1)
worksheet.AutoSizeColumn(2)
worksheet.AutoSizeColumn(3)
Dim outputPath As String = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Desktop), "FormattedExport.xlsx")
workbook.SaveAs(outputPath)
MessageBox.Show("Formatted export complete.", "Done", MessageBoxButtons.OK, MessageBoxIcon.Information)
End Sub

Der Formatierungscode wendet verschiedene Techniken an. Die Kopfzeile hat einen blauen Hintergrund (#4472C4) mit weißem Text, 12-Punkt-Fettschrift und zentrierter Ausrichtung - ein Standardgeschäfts-Tabellenkalkulationsstil. Datenzeilen wechseln sich zwischen Weiß und Hellgrau (#D6DCE5) in jeder geraden Zeile, was es den Benutzern erleichtert, über breite Tabellen hinweg zu lesen, ohne den Platz zu verlieren. Die Preisspalte verwendet das eingebaute Währungsformat von Excel ($#,##0.00), sodass Werte mit Dollarzeichen und zwei Dezimalstellen in der Tabelle angezeigt werden, ohne die zugrunde liegenden numerischen Daten zu ändern. AutoSizeColumn passt jede Spalte an ihren längsten Wert an, damit kein Inhalt abgeschnitten wird.
Sie können dieses Muster weiter mit Zellrahmenstilierung, bedingter Formatierung und Datenvalidierungsregeln erweitern. Für Berichte, die einer Unternehmensvorlage entsprechen müssen, können Sie auch das Seitenlayout und den Druckbereich so einstellen, dass die exportierte Datei ohne weitere Anpassungen druckfertig ist.
Wie geht man mit großen Datensätzen und der Leistungsoptimierung um?
Wenn ein DataGridView an Tausende von Zeilen gebunden ist, wird das Durchlaufen der Zelle für Zelle bemerkbar langsam. Zwei Optimierungen verbessern die Leistung deutlich. Verwenden Sie zuerst LoadFromDataTable anstelle von SetCellValue-Aufrufen pro Zelle. Zweitens, wenn Ihre Datenquelle ein DataTable ist, übergeben Sie ihn direkt an IronXL, anstatt Werte über die DataGridView-Zeilen zu extrahieren.
void ExportLargeDataset(DataTable sourceTable)
{
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.DefaultWorkSheet;
// Direct DataTable load -- fastest path for large data
worksheet.LoadFromDataTable(sourceTable, true);
// Apply header styling after load
int colCount = sourceTable.Columns.Count;
for (int col = 0; col < colCount; col++)
{
char colLetter = (char)('A' + col);
worksheet[$"{colLetter}1"].Style.Font.Bold = true;
worksheet[$"{colLetter}1"].Style.SetBackgroundColor("#4472C4");
worksheet[$"{colLetter}1"].Style.Font.Color = "#FFFFFF";
}
workbook.SaveAs(Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.Desktop),
"LargeExport.xlsx"
));
}
void ExportLargeDataset(DataTable sourceTable)
{
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.DefaultWorkSheet;
// Direct DataTable load -- fastest path for large data
worksheet.LoadFromDataTable(sourceTable, true);
// Apply header styling after load
int colCount = sourceTable.Columns.Count;
for (int col = 0; col < colCount; col++)
{
char colLetter = (char)('A' + col);
worksheet[$"{colLetter}1"].Style.Font.Bold = true;
worksheet[$"{colLetter}1"].Style.SetBackgroundColor("#4472C4");
worksheet[$"{colLetter}1"].Style.Font.Color = "#FFFFFF";
}
workbook.SaveAs(Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.Desktop),
"LargeExport.xlsx"
));
}
Option Strict On
Sub ExportLargeDataset(sourceTable As DataTable)
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.DefaultWorkSheet
' Direct DataTable load -- fastest path for large data
worksheet.LoadFromDataTable(sourceTable, True)
' Apply header styling after load
Dim colCount As Integer = sourceTable.Columns.Count
For col As Integer = 0 To colCount - 1
Dim colLetter As Char = ChrW(AscW("A"c) + col)
worksheet($"{colLetter}1").Style.Font.Bold = True
worksheet($"{colLetter}1").Style.SetBackgroundColor("#4472C4")
worksheet($"{colLetter}1").Style.Font.Color = "#FFFFFF"
Next
workbook.SaveAs(Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.Desktop),
"LargeExport.xlsx"
))
End Sub
Bei Datensätzen mit mehr als 10.000 Zeilen hält das Ausführen des Exports in einem Hintergrundthread die Benutzeroberfläche reaktionsfähig. Wickeln Sie die Exportlogik in Task.Run und marshallen Sie den MessageBox.Show-Aufruf mit Invoke auf den UI-Thread zurück. IronXL ist threadsicher für Schreibvorgänge auf separaten WorkBook-Instanzen, sodass Sie bei Bedarf mehrere Exporte gleichzeitig durchführen können.
Zusätzliche Leistungsressourcen: Leitfaden zur Leistung beim Excel-Export
Wie vergleicht man IronXL mit Microsoft Interop beim DataGridView-Export?
Viele Entwickler beginnen mit Microsoft Excel Interop, da es mit Office ausgeliefert wird und keine zusätzlichen Pakete benötigt. Interop verursacht jedoch reale Kosten, die sich in Produktionsumgebungen schnell bemerkbar machen. Die wichtigsten Unterschiede sind in der folgenden Tabelle zusammengefasst:
| Fähigkeit | IronXL | Microsoft Interop |
|---|---|---|
| Erfordert die Installation von Microsoft Excel. | Nein | Ja |
| Funktioniert in Server-/Cloud-Umgebungen | Ja | Nein (wird von Microsoft nicht unterstützt) |
| Bereinigung der COM-Objekte erforderlich | Nein | Ja (Marshal.ReleaseComObject) |
| Leistung bei großen Datensätzen | Schnell (reines .NET) | Langsam (COM-Marshalling-Overhead) |
| Installationsmethode | NuGet | COM-Referenz / Office-Installation |
| Unterstützte .NET -Versionen | .NET 4.6.2 -- .NET 10 | Nur .NET Framework (eingeschränkt) |
| XLSX-, CSV- und ODS-Unterstützung | Ja | Nur XLSX/XLS über Excel |
In der eigenen Dokumentation von Microsoft wird vor der Verwendung von Office Interop auf Servern oder in Dienstkonten gewarnt, da Stabilitäts- und Lizenzprobleme bestehen. IronXL funktioniert einwandfrei in Azure App Service, Windows Service-Hosts, Docker-Containern und jeder anderen Headless-Umgebung, in der die Ausführung einer Desktop-Anwendung wie Excel nicht möglich ist.
Für Teams, die bereits Interop verwenden und migrieren möchten, stimmt IronXLs API genügend überein, sodass die meisten WorkBook- und WorkSheet-Vorgänge direkt übersetzt werden. Der IronXL Migrationsleitfaden behandelt gängige Interop-Muster und deren IronXL Äquivalente.
Was sind Ihre nächsten Schritte?
Das Exportieren von DataGridView-Daten nach Excel mit IronXL erfordert nur eine NuGet-Paketinstallation und ein paar Zeilen Code und ersetzt den fragilen COM-Interop-Ansatz durch eine saubere, wartbare Lösung, die in jeder Bereitstellungsumgebung funktioniert. Die hier behandelten Techniken – grundlegender Export, formatierte Ausgabe, Optimierung großer Datensätze und eine Vergleichstabelle – bieten Ihnen alles, was Sie benötigen, um diese Funktion in einer produktiven Windows Forms-Anwendung bereitzustellen.
Erkunden Sie von hier aus diese verwandten Funktionen:
- Erstellen von Excel-Dateien von Grund auf in C# – Arbeitsbücher programmatisch ohne Datenquelle erstellen
- Lesen von Excel-Dateien in eine DataTable – die Umkehrung für den Import von Excel-Daten zurück in Ihre Anwendung
- Bedingte Formatierung anwenden – Zellen automatisch anhand ihrer Werte hervorheben
- Diagrammdaten in Excel festlegen – Einbetten von Diagrammen in exportierte Arbeitsbücher
- Excel-Dateien mit einem Passwort schützen – exportierte Berichte vor der Weitergabe sichern
- Export in CSV-Format - wenn Empfänger ein flaches Dateiformat anstelle von
.xlsxbenötigen
Starten Sie eine kostenlose IronXL Testversion , um den vollen Funktionsumfang in Ihrem Projekt zu testen, oder informieren Sie sich über die IronXL -Lizenzoptionen, wenn Sie für den Produktiveinsatz bereit sind.
Häufig gestellte Fragen
Wie kann ich DataGridView-Daten in C# nach Excel exportieren?
Installieren Sie IronXL über NuGet, extrahieren Sie eine DataTable aus Ihrem DataGridView, erstellen Sie ein WorkBook und ein WorkSheet, rufen Sie worksheet.LoadFromDataTable(dt, true) auf und speichern Sie anschließend mit workbook.SaveAs.
Welche Formatierungsoptionen sind beim Export von DataGridView nach Excel verfügbar?
IronXL unterstützt Fettdruck, Hintergrundfarben, Schriftfarben, horizontale Ausrichtung, Zahlenformate (z. B. Währungen), automatische Spaltenbreitenanpassung, Rahmenstile und bedingte Formatierung.
Muss Microsoft Excel installiert sein, um DataGridView-Daten zu exportieren?
Nein. IronXL ist eine reine .NET Bibliothek, die Excel-Dateien generiert, ohne dass Microsoft Office oder eine COM-Registrierung auf dem Rechner erforderlich ist.
Kann ich beim Exportieren von DataGridView nach Excel Kopfzeilen gestalten?
Ja. Nachdem die Kopfzeile geschrieben wurde, greifen Sie über die Adresse auf jede Kopfzeilenzelle zu und legen Sie die Eigenschaften Style.Font.Bold, Style.SetBackgroundColor und Style.Font.Color fest.
Wie wende ich wechselnde Zeilenfarben in Excel an, wenn ich aus DataGridView exportiere?
Verfolgen Sie den Zeilenindex beim Durchlaufen der DataGridView-Zeilen und wenden Sie für gerade Zeilen einen Bereichsstil mit worksheet[rangeAddress].Style.SetBackgroundColor und der von Ihnen gewählten Hex-Farbe an.
Wie gehe ich mit großen Datensätzen beim Exportieren von DataGridView nach Excel um?
Übergeben Sie die zugrundeliegende DataTable direkt an worksheet.LoadFromDataTable, anstatt die Zellen einzeln zu durchlaufen. Bei sehr großen Datensätzen führen Sie den Export in einem Hintergrundthread mit Task.Run aus.
Wie schneidet IronXL im Vergleich zu Microsoft Excel Interop beim DataGridView-Export ab?
IronXL benötigt kein Microsoft Excel, funktioniert in Server- und Cloud-Umgebungen, benötigt keinen COM-Bereinigungscode und arbeitet bei großen Datensätzen deutlich schneller.




