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

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

Jordi Bardia
Jordi Bardia
Aktualisiert:

C# DataGridView-Export nach Excel mit Formatierung: Die vollständige Anleitung: Bild 1 - C# DataGridView-Export nach Excel mit Formatierung

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.

Starten Sie jetzt mit IronXL.
green arrow pointer

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
SHELL

Fügen Sie die erforderlichen Namensräume am Anfang Ihrer Formulardatei hinzu:

using IronXL;
using System.Data;
using IronXL;
using System.Data;
$vbLabelText   $csharpLabel

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

Dieser Code verwendet den Top-Level-Anweisungsstil für die Signatur des Ereignishandlers. Die Spalte 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.

C# DataGridView-Export nach Excel mit Formatierung: Die vollständige Anleitung: Bild 2 – Benutzeroberfläche für das Formular

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-Wert 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);
    }
}
$vbLabelText   $csharpLabel

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

Der Aufruf LoadFromDataTable(dt, true) benötigt den Befehl DataTable und ein boolesches Flag, das IronXL anweist, die Spaltennamen als erste Excel-Zeile zu schreiben – diese werden dann 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 Informationen 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 professionelle 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 umfasst. 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);
}
$vbLabelText   $csharpLabel

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

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 (#D6DCE5) ab, 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 vom Typ 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"
    ));
}
$vbLabelText   $csharpLabel

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:

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 .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 genau abgebildet, 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:

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.

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

Iron Support Team

We're online 24 hours, 5 days a week.
Chat
Email
Call Me