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 bei 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 kompletten Prozess des Exportierens von DataGridView nach Excel in C# mit IronXL und deckt alles von der Projekteinrichtung bis hin zur erweiterten Zellformatierung ab, sodass Sie am Ende produktionsreifen Code erhalten.
Wie richtet man ein Windows Forms-Projekt für den DataGridView-Export ein?
Bei den traditionellen Ansätzen zum Exportieren von DataGridView Daten wurde auf Microsoft Interop gesetzt – man öffnete "Verweis hinzufügen", navigierte zur Registerkarte "COM", wählte die Microsoft Excel-Objektbibliothek aus und schrieb einen fehleranfälligen Code, der Marshal.ReleaseComObject aufrief, um Speicherlecks zu vermeiden. Dieses Muster erfordert die Installation von Microsoft Excel auf jedem Rechner, auf dem die Anwendung ausgeführt wird, führt bei großen Datensätzen zu langsamen Ergebnissen und erzeugt in Bereitstellungsumgebungen ohne Office-Lizenzen häufig COMException Fehler. 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 handelt sich um eine reine .NET Bibliothek, die .xlsx, .xls, .csv und .ods-Dateien ohne Microsoft Office oder eine COM-Registrierung lesen und schreiben kann. Sie installieren es über NuGet und können sofort mit dem Programmieren beginnen.
Installation von IronXL über NuGet
Erstellen Sie zunächst ein neues Windows Forms App-Projekt in Visual Studio, das auf .NET 10 abzielt. Fügen Sie der Formularoberfläche ein DataGridView-Steuerelement und ein Button-Steuerelement hinzu. Benennen Sie die Schaltfläche btnExport und geben Sie ihr die Bezeichnung "Exportieren nach Excel". Öffnen Sie anschließend die NuGet Paket-Manager-Konsole und führen Sie folgenden Befehl aus:
Install-Package IronXL.Excel
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 Namensräume umfassen alle IronXL Typen, die Sie zum Lesen und Schreiben von Excel-Arbeitsmappen benötigen, sowie die Standardtypen System.Data für die Arbeit mit DataTable-Objekten, die Ihre DataGridView-Objekte mit der Exportpipeline verbinden.
Wie lädt man Beispieldaten in ein DataGridView-Steuerelement?
Bevor Sie die Exportlogik erstellen, füllen Sie Ihr DataGridView mit repräsentativen Daten. Das Ereignis Form1_Load ist der richtige Ort, um ein DataTable als Datenquelle zu binden. In einer realen Anwendung würden Sie eine Datenbank abfragen oder einen Dienst aufrufen; hier veranschaulicht ein fest codiertes 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. Die Tabelle DataTable enthält vier typisierte Spalten – Integer, String, Decimal und Integer –, die IronXL beim Schreiben in die Excel-Arbeitsmappe beibehält. 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 Befehl DataGridView erzeugt automatisch eine Spaltenkopfzeile aus den Spaltennamen DataTable. 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 Produktiveinsatz 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 austauschen können, ohne die Exportlogik zu verändern.
Wie exportiert man DataGridView-Daten in eine Excel-Datei?
Die Kernlogik für den Export wird innerhalb des Button-Click-Handlers ausgeführt. IronXL stellt eine LoadFromDataTable Methode auf WorkSheet bereit, die die Spalten-zu-Zellen-Zuordnung automatisch übernimmt. Die sauberste Methode extrahiert ein DataTable aus dem DataGridView und übergibt es direkt. Das Open XML SDK, das dem .xlsx Format zugrunde liegt, ist von Microsoft dokumentiert und bestätigt, warum reine .NET Lösungen wie IronXL Interop bei der programmatischen Generierung überlegen sind.
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 Aufruf LoadFromDataTable(dt, true) benötigt den Aufruf DataTable und ein boolesches Flag, das IronXL anweist, die Spaltennamen als erste Excel-Zeile zu schreiben – diese werden zu Ihren Kopfzeilenzellen. Die Arbeitsmappe wird auf dem Desktop des Benutzers unter Verwendung von Environment.SpecialFolder.Desktop anstatt eines fest codierten Pfads gespeichert, wodurch der Code benutzerübergreifend portierbar ist.
Die null Prü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 Zeichenkette "DBNull", sodass die Ausgabe sauber bleibt.
Weitere Details zum Einlesen von Daten aus Excel-Dateien in ein DataGridView finden Sie in der IronXL DataTable-Dokumentation . Dort wird auch die umgekehrte Operation sowie die Konvertierung von Excel-Dateien in DataSets für Arbeitsmappen mit mehreren Tabellenblättern beschrieben.
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 erhält einen blauen Hintergrund (#4472C4) mit weißem Text, 12-Punkt-Fettschrift und zentrierter Ausrichtung - ein Standardstil für Geschäftstabellen. Die Datenzeilen wechseln sich in jeder geraden Zeile zwischen Weiß und Hellgrau ab (#D6DCE5), was es den Benutzern erleichtert, breite Tabellen zu lesen, ohne die Position zu verlieren. Die Spalte "Preis" verwendet das in Excel integrierte Währungsformat ($#,##0.00), sodass die Werte in der Tabelle mit Dollarzeichen und zwei Dezimalstellen angezeigt werden, ohne die zugrunde liegenden numerischen Daten zu verändern. AutoSizeColumn passt jede Spalte an ihren längsten Wert an, sodass kein Inhalt abgeschnitten wird.
Dieses Muster lässt sich noch erweitern durch Zellrahmenstile , bedingte Formatierung und Datenvalidierungsregeln . 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 einzelnen Zellen merklich langsamer. Zwei Optimierungen verbessern die Leistung deutlich. Verwenden Sie zunächst LoadFromDataTable anstelle von SetCellValue-Aufrufen pro Zelle. Zweitens, wenn Ihre Datenquelle eine DataTable ist, übergeben Sie sie 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 sorgt die Ausführung des Exports in einem Hintergrundthread für eine reaktionsfähige Benutzeroberfläche. Kapseln Sie die Exportlogik in Task.Run und rufen Sie den MessageBox.Show-Aufruf mithilfe von Invoke wieder im UI-Thread auf. IronXL ist threadsicher für Schreibvorgänge auf separaten WorkBook Instanzen, sodass Sie bei Bedarf mehrere Exporte gleichzeitig ausfü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 nutzen und migrieren möchten, ist die API von IronXL so gut abgestimmt, dass die meisten WorkBook- und WorkSheet-Operationen direkt übersetzt werden können. Der IronXL Migrationsleitfaden behandelt gängige Interop-Muster und deren IronXL Äquivalente.
Was sind Ihre nächsten Schritte?
Der Export von DataGridView Daten nach Excel mit IronXL erfordert lediglich die Installation eines NuGet Pakets und ein paar Codezeilen. Dadurch wird der fehleranfällige COM-Interop-Ansatz durch eine saubere, wartungsfreundliche Lösung ersetzt, 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:
- Excel-Dateien von Grund auf in C# erstellen – Arbeitsmappen programmatisch ohne Datenquelle erstellen
- Excel-Dateien in eine DataTable einlesen – die umgekehrte Operation zum Importieren von Excel-Daten zurück in Ihre Anwendung
- Bedingte Formatierung anwenden – Zellen automatisch anhand ihrer Werte hervorheben
- Diagrammdaten in Excel festlegen -- Diagramme in exportierte Arbeitsmappen einbetten
- Excel-Dateien mit einem Passwort schützen – exportierte Berichte vor der Weitergabe sichern
- Export ins CSV-Format -- wenn Empfänger das Flatfile-Format 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.




