Zum Fußzeileninhalt springen
IRONXL VERWENDEN

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

C# DataGridView-Export nach Excel mit Formatierung: Der vollständige Leitfaden: Bild 1 - C# DataGridView-Export nach Excel mit Formatierung

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.

Starten Sie jetzt mit IronXL.
green arrow pointer

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
$vbLabelText   $csharpLabel

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
$vbLabelText   $csharpLabel

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.

C# DataGridView-Export nach Excel mit Formatierung: Der vollständige Leitfaden: Bild 2 - UI für das Formular

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
$vbLabelText   $csharpLabel

C# DataGridView-Export nach Excel mit Formatierung: Der vollständige Leitfaden: Bild 3 - Generierte Excel-Datei

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
$vbLabelText   $csharpLabel

C# DataGridView-Export nach Excel mit Formatierung: Der vollständige Leitfaden: Bild 4 - Ausgabe für die generierte formatierte Excel-Datei

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
$vbLabelText   $csharpLabel

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:

IronXL vs. Microsoft Excel Interop für DataGridView-Export
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:

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.

Curtis Chau
Technischer Autor

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 ...

Weiterlesen

Iron-Support-Team

Wir sind 24 Stunden am Tag, 5 Tage die Woche online.
Chat
E-Mail
Rufen Sie mich an