DataGridView mit IronXL in C# nach Excel exportieren

Warum ist der Export von DataGridView nach Excel wichtig?

DataGridView Steuerelemente sind grundlegend für Windows Forms-Anwendungen, da sie tabellarische Daten anzeigen, mit denen Benutzer täglich interagieren. Durch den Export dieser Daten nach Excel können Benutzer die leistungsstarken Analysetools von Excel nutzen, Präsentationen erstellen und Daten mit Kollegen teilen, die möglicherweise keinen Zugriff auf die Anwendung haben. Diese C# Excel-Exportfunktion ist für Geschäftsberichte und Datenanalyse-Workflows von entscheidender Bedeutung.

Traditionelle Exportmethoden mit Microsoft.Office.Interop.Excel erfordern, dass Excel auf jedem Rechner installiert ist, auf dem die Anwendung läuft. Dies schafft Herausforderungen bei der Bereitstellung, insbesondere in Serverumgebungen oder bei der Verbreitung von Anwendungen an Benutzer ohne Office-Lizenzen. Darüber hinaus können Interop-Ansätze unter Speicherlecks und Problemen mit der Bereinigung von COM-Objekten leiden, wenn sie nicht sorgfältig behandelt werden. Diese Herausforderungen werden besonders akut bei der Bereitstellung auf AWS Lambda oder anderen serverlosen Plattformen, wo eine Office-Installation nicht möglich ist.

Moderne .NET-Anwendungen verlangen flexiblere Lösungen. IronXL begegnet diesen Herausforderungen mit einer eigenständigen Bibliothek, die Excel-Dateien ohne Abhängigkeiten von Microsoft Office generiert. Dieser Ansatz gewährleistet eine konsistente Funktionalität in Entwicklungs-, Test- und Produktionsumgebungen und unterstützt gleichzeitig die Bereitstellung auf Container- und Cloud-Plattformen.

Wie installiert man IronXL in einem C#-Projekt?

Öffnen Sie die Paket-Manager-Konsole in Visual Studio und führen Sie den folgenden Befehl aus, oder verwenden Sie die .NET Befehlszeilenschnittstelle (CLI):

Install-Package IronXL
dotnet add package IronXL

Install-Package IronXL
dotnet add package IronXL

Detaillierte Installationsoptionen finden Sie im IronXL NuGet-Installationshandbuch oder suchen Sie direkt auf NuGet.org nach dem Paket. Nach der Installation fügen Sie using IronXL; zu Ihren C#-Projektdateien hinzu, um auf die Excel-Exportfunktionen der Bibliothek zuzugreifen. Bei der Bereitstellung in Produktionsumgebungen müssen Sie Ihren Lizenzschlüssel anwenden, um alle Funktionen zu aktivieren. Sie können eine kostenlose Testlizenz erhalten, um IronXL vor dem Kauf zu testen.

using IronXL;
using System.Data;
using System.Windows.Forms;

// Create a DataTable with sample product data
var dt = new DataTable();
dt.Columns.Add("Product ID", typeof(int));
dt.Columns.Add("Product Name", typeof(string));
dt.Columns.Add("Category", typeof(string));
dt.Columns.Add("Price", typeof(decimal));
dt.Columns.Add("Stock", typeof(int));

dt.Rows.Add(1001, "Laptop Pro", "Electronics", 1299.99m, 15);
dt.Rows.Add(1002, "Wireless Mouse", "Accessories", 29.99m, 50);
dt.Rows.Add(1003, "USB-C Cable", "Accessories", 19.99m, 100);
dt.Rows.Add(1004, "Monitor 27\"", "Electronics", 399.99m, 8);
dt.Rows.Add(1005, "Keyboard Mechanical", "Accessories", 89.99m, 25);

// Bind to DataGridView
var dataGridView1 = new DataGridView();
dataGridView1.DataSource = dt;

// Create new Excel workbook
var workbook = WorkBook.Create(ExcelFileFormat.XLSX);
var worksheet = workbook.DefaultWorkSheet;

// Export column headers
for (int colIndex = 0; colIndex < dataGridView1.Columns.Count; colIndex++)
{
    worksheet.SetCellValue(0, colIndex, dataGridView1.Columns[colIndex].HeaderText);
}

// Export data rows
for (int rowIndex = 0; rowIndex < dataGridView1.Rows.Count; rowIndex++)
{
    if (!dataGridView1.Rows[rowIndex].IsNewRow)
    {
        for (int colIndex = 0; colIndex < dataGridView1.Columns.Count; colIndex++)
        {
            var cellValue = dataGridView1.Rows[rowIndex].Cells[colIndex].Value;
            if (cellValue is decimal or double or int)
                worksheet.SetCellValue(rowIndex + 1, colIndex, Convert.ToDouble(cellValue));
            else
                worksheet.SetCellValue(rowIndex + 1, colIndex, cellValue?.ToString() ?? string.Empty);
        }
    }
}

// Save the Excel file
workbook.SaveAs("DataGridViewExport.xlsx");
Console.WriteLine("Export completed successfully!");

using IronXL;
using System.Data;
using System.Windows.Forms;

// Create a DataTable with sample product data
var dt = new DataTable();
dt.Columns.Add("Product ID", typeof(int));
dt.Columns.Add("Product Name", typeof(string));
dt.Columns.Add("Category", typeof(string));
dt.Columns.Add("Price", typeof(decimal));
dt.Columns.Add("Stock", typeof(int));

dt.Rows.Add(1001, "Laptop Pro", "Electronics", 1299.99m, 15);
dt.Rows.Add(1002, "Wireless Mouse", "Accessories", 29.99m, 50);
dt.Rows.Add(1003, "USB-C Cable", "Accessories", 19.99m, 100);
dt.Rows.Add(1004, "Monitor 27\"", "Electronics", 399.99m, 8);
dt.Rows.Add(1005, "Keyboard Mechanical", "Accessories", 89.99m, 25);

// Bind to DataGridView
var dataGridView1 = new DataGridView();
dataGridView1.DataSource = dt;

// Create new Excel workbook
var workbook = WorkBook.Create(ExcelFileFormat.XLSX);
var worksheet = workbook.DefaultWorkSheet;

// Export column headers
for (int colIndex = 0; colIndex < dataGridView1.Columns.Count; colIndex++)
{
    worksheet.SetCellValue(0, colIndex, dataGridView1.Columns[colIndex].HeaderText);
}

// Export data rows
for (int rowIndex = 0; rowIndex < dataGridView1.Rows.Count; rowIndex++)
{
    if (!dataGridView1.Rows[rowIndex].IsNewRow)
    {
        for (int colIndex = 0; colIndex < dataGridView1.Columns.Count; colIndex++)
        {
            var cellValue = dataGridView1.Rows[rowIndex].Cells[colIndex].Value;
            if (cellValue is decimal or double or int)
                worksheet.SetCellValue(rowIndex + 1, colIndex, Convert.ToDouble(cellValue));
            else
                worksheet.SetCellValue(rowIndex + 1, colIndex, cellValue?.ToString() ?? string.Empty);
        }
    }
}

// Save the Excel file
workbook.SaveAs("DataGridViewExport.xlsx");
Console.WriteLine("Export completed successfully!");

Imports IronXL
Imports System.Data
Imports System.Windows.Forms

' Create a DataTable with sample product data
Dim dt As New DataTable()
dt.Columns.Add("Product ID", GetType(Integer))
dt.Columns.Add("Product Name", GetType(String))
dt.Columns.Add("Category", GetType(String))
dt.Columns.Add("Price", GetType(Decimal))
dt.Columns.Add("Stock", GetType(Integer))

dt.Rows.Add(1001, "Laptop Pro", "Electronics", 1299.99D, 15)
dt.Rows.Add(1002, "Wireless Mouse", "Accessories", 29.99D, 50)
dt.Rows.Add(1003, "USB-C Cable", "Accessories", 19.99D, 100)
dt.Rows.Add(1004, "Monitor 27""", "Electronics", 399.99D, 8)
dt.Rows.Add(1005, "Keyboard Mechanical", "Accessories", 89.99D, 25)

' Bind to DataGridView
Dim dataGridView1 As New DataGridView()
dataGridView1.DataSource = dt

' Create new Excel workbook
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.DefaultWorkSheet

' Export column headers
For colIndex As Integer = 0 To dataGridView1.Columns.Count - 1
    worksheet.SetCellValue(0, colIndex, dataGridView1.Columns(colIndex).HeaderText)
Next

' Export data rows
For rowIndex As Integer = 0 To dataGridView1.Rows.Count - 1
    If Not dataGridView1.Rows(rowIndex).IsNewRow Then
        For colIndex As Integer = 0 To dataGridView1.Columns.Count - 1
            Dim cellValue = dataGridView1.Rows(rowIndex).Cells(colIndex).Value
            If TypeOf cellValue Is Decimal OrElse TypeOf cellValue Is Double OrElse TypeOf cellValue Is Integer Then
                worksheet.SetCellValue(rowIndex + 1, colIndex, Convert.ToDouble(cellValue))
            Else
                worksheet.SetCellValue(rowIndex + 1, colIndex, If(cellValue?.ToString(), String.Empty))
            End If
        Next
    End If
Next

' Save the Excel file
workbook.SaveAs("DataGridViewExport.xlsx")
Console.WriteLine("Export completed successfully!")

Wie fügt man Excel-Exporten eine Professional Formatierung hinzu?

Professionelle Excel-Exporte erfordern oft eine Formatierung, um die Lesbarkeit zu verbessern. IronXL bietet Gestaltungsmöglichkeiten wie Schriftartanpassung, Hintergrundfarben, Rahmen und Ausrichtung. Das folgende Beispiel fügt eine Überschriftenformatierung und abwechselnde Zeilenfarben hinzu:

using IronXL;
using System.Data;
using System.Windows.Forms;

// Assume dataGridView1 is already populated with data
var dataGridView1 = new DataGridView();

// (populate dataGridView1 with data as shown in the previous example)

var workbook = WorkBook.Create(ExcelFileFormat.XLSX);
var worksheet = workbook.DefaultWorkSheet;

// Set column headers with formatting
for (int colIndex = 0; colIndex < dataGridView1.Columns.Count; colIndex++)
{
    var headerCell = worksheet.GetCellAt(0, colIndex);
    headerCell.Value = dataGridView1.Columns[colIndex].HeaderText;
    headerCell.Style.Font.Bold = true;
    headerCell.Style.BackgroundColor = "#4472C4";
    headerCell.Style.Font.Color = "#FFFFFF";
    headerCell.Style.HorizontalAlignment = IronXL.Styles.HorizontalAlignment.Center;
}

// Export data with alternating row colors
for (int rowIndex = 0; rowIndex < dataGridView1.Rows.Count; rowIndex++)
{
    if (!dataGridView1.Rows[rowIndex].IsNewRow)
    {
        for (int colIndex = 0; colIndex < dataGridView1.Columns.Count; colIndex++)
        {
            var cellValue = dataGridView1.Rows[rowIndex].Cells[colIndex].Value;
            var excelCell = worksheet.GetCellAt(rowIndex + 1, colIndex);

            if (cellValue != null)
                excelCell.Value = cellValue.ToString();

            // Apply alternating row background
            if (rowIndex % 2 == 0)
                excelCell.Style.BackgroundColor = "#F2F2F2";
        }
    }
}

// Auto-fit columns
for (int colIndex = 0; colIndex < dataGridView1.Columns.Count; colIndex++)
{
    worksheet.AutoSizeColumn(colIndex);
}

workbook.SaveAs("FormattedExport.xlsx");
Console.WriteLine("Formatted export completed successfully!");

using IronXL;
using System.Data;
using System.Windows.Forms;

// Assume dataGridView1 is already populated with data
var dataGridView1 = new DataGridView();

// (populate dataGridView1 with data as shown in the previous example)

var workbook = WorkBook.Create(ExcelFileFormat.XLSX);
var worksheet = workbook.DefaultWorkSheet;

// Set column headers with formatting
for (int colIndex = 0; colIndex < dataGridView1.Columns.Count; colIndex++)
{
    var headerCell = worksheet.GetCellAt(0, colIndex);
    headerCell.Value = dataGridView1.Columns[colIndex].HeaderText;
    headerCell.Style.Font.Bold = true;
    headerCell.Style.BackgroundColor = "#4472C4";
    headerCell.Style.Font.Color = "#FFFFFF";
    headerCell.Style.HorizontalAlignment = IronXL.Styles.HorizontalAlignment.Center;
}

// Export data with alternating row colors
for (int rowIndex = 0; rowIndex < dataGridView1.Rows.Count; rowIndex++)
{
    if (!dataGridView1.Rows[rowIndex].IsNewRow)
    {
        for (int colIndex = 0; colIndex < dataGridView1.Columns.Count; colIndex++)
        {
            var cellValue = dataGridView1.Rows[rowIndex].Cells[colIndex].Value;
            var excelCell = worksheet.GetCellAt(rowIndex + 1, colIndex);

            if (cellValue != null)
                excelCell.Value = cellValue.ToString();

            // Apply alternating row background
            if (rowIndex % 2 == 0)
                excelCell.Style.BackgroundColor = "#F2F2F2";
        }
    }
}

// Auto-fit columns
for (int colIndex = 0; colIndex < dataGridView1.Columns.Count; colIndex++)
{
    worksheet.AutoSizeColumn(colIndex);
}

workbook.SaveAs("FormattedExport.xlsx");
Console.WriteLine("Formatted export completed successfully!");

Imports IronXL
Imports System.Data
Imports System.Windows.Forms

' Assume dataGridView1 is already populated with data
Dim dataGridView1 As New DataGridView()

' (populate dataGridView1 with data as shown in the previous example)

Dim workbook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet = workbook.DefaultWorkSheet

' Set column headers with formatting
For colIndex As Integer = 0 To dataGridView1.Columns.Count - 1
    Dim headerCell = worksheet.GetCellAt(0, colIndex)
    headerCell.Value = dataGridView1.Columns(colIndex).HeaderText
    headerCell.Style.Font.Bold = True
    headerCell.Style.BackgroundColor = "#4472C4"
    headerCell.Style.Font.Color = "#FFFFFF"
    headerCell.Style.HorizontalAlignment = IronXL.Styles.HorizontalAlignment.Center
Next

' Export data with alternating row colors
For rowIndex As Integer = 0 To dataGridView1.Rows.Count - 1
    If Not dataGridView1.Rows(rowIndex).IsNewRow Then
        For colIndex As Integer = 0 To dataGridView1.Columns.Count - 1
            Dim cellValue = dataGridView1.Rows(rowIndex).Cells(colIndex).Value
            Dim excelCell = worksheet.GetCellAt(rowIndex + 1, colIndex)

            If cellValue IsNot Nothing Then
                excelCell.Value = cellValue.ToString()
            End If

            ' Apply alternating row background
            If rowIndex Mod 2 = 0 Then
                excelCell.Style.BackgroundColor = "#F2F2F2"
            End If
        Next
    End If
Next

' Auto-fit columns
For colIndex As Integer = 0 To dataGridView1.Columns.Count - 1
    worksheet.AutoSizeColumn(colIndex)
Next

workbook.SaveAs("FormattedExport.xlsx")
Console.WriteLine("Formatted export completed successfully!")

Diese verbesserte Version formatiert die exportierte Excel-Datei Professional . Überschriften werden fettgedruckt mit blauem Hintergrund und weißer Schrift dargestellt, wodurch sie sich klar von den Datenzeilen abheben. Der Code implementiert abwechselnde Zeilenfarben mithilfe einer Modulo-Operation, wodurch die Lesbarkeit bei großen Datensätzen verbessert wird. Sie können das Erscheinungsbild mithilfe des IronXL-Leitfadens zur Zellenformatierung weiter anpassen oder die Funktion zum Zusammenführen von Zellen anwenden, um Spalten in der Kopfzeile zu überbrücken.

Die AutoSizeColumn-Methode passt die Spaltenbreiten an den Inhalt an, sodass eine manuelle Anpassung nach dem Export entfällt. Diese Formatierungsoptionen verwandeln einen grundlegenden Datenexport in ein präsentationsfertiges Dokument, das die Benutzer sofort weitergeben können. Lesen Sie den Artikel "So schreiben Sie Excel-Dateien mit IronXL", um weitere Formatierungs- und Datenschreibmuster zu erfahren.

Wie exportiert man in mehrere Formate und fügt Formeln hinzu?

IronXL geht über den einfachen Excel-Export hinaus und bietet Funktionen wie Formelunterstützung, mehrere Arbeitsblätter und alternative Ausgabeformate. Das folgende Beispiel veranschaulicht diese Fähigkeiten:

using IronXL;

var workbook = WorkBook.Create(ExcelFileFormat.XLSX);
var worksheet = workbook.DefaultWorkSheet;

// (populate worksheet with DataGridView data as shown above)
int dataRowCount = 5; // Replace with actual dataGridView1.Rows.Count

// Add a SUM formula to calculate the total price column
worksheet.SetCellValue(dataRowCount + 2, 3, $"=SUM(D2:D{dataRowCount + 1})");

// Create a summary worksheet
var summarySheet = workbook.CreateWorkSheet("Summary");
summarySheet.SetCellValue(0, 0, "Total Products");
summarySheet.SetCellValue(0, 1, dataRowCount);

// Save in multiple formats
workbook.SaveAs("export.xlsx");
workbook.SaveAsCsv("export.csv");
workbook.SaveAsJson("export.json");
workbook.SaveAsXml("export.xml");

Console.WriteLine("Multi-format export completed!");

using IronXL;

var workbook = WorkBook.Create(ExcelFileFormat.XLSX);
var worksheet = workbook.DefaultWorkSheet;

// (populate worksheet with DataGridView data as shown above)
int dataRowCount = 5; // Replace with actual dataGridView1.Rows.Count

// Add a SUM formula to calculate the total price column
worksheet.SetCellValue(dataRowCount + 2, 3, $"=SUM(D2:D{dataRowCount + 1})");

// Create a summary worksheet
var summarySheet = workbook.CreateWorkSheet("Summary");
summarySheet.SetCellValue(0, 0, "Total Products");
summarySheet.SetCellValue(0, 1, dataRowCount);

// Save in multiple formats
workbook.SaveAs("export.xlsx");
workbook.SaveAsCsv("export.csv");
workbook.SaveAsJson("export.json");
workbook.SaveAsXml("export.xml");

Console.WriteLine("Multi-format export completed!");

Imports IronXL

Dim workbook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet = workbook.DefaultWorkSheet

' (populate worksheet with DataGridView data as shown above)
Dim dataRowCount As Integer = 5 ' Replace with actual dataGridView1.Rows.Count

' Add a SUM formula to calculate the total price column
worksheet.SetCellValue(dataRowCount + 2, 3, $"=SUM(D2:D{dataRowCount + 1})")

' Create a summary worksheet
Dim summarySheet = workbook.CreateWorkSheet("Summary")
summarySheet.SetCellValue(0, 0, "Total Products")
summarySheet.SetCellValue(0, 1, dataRowCount)

' Save in multiple formats
workbook.SaveAs("export.xlsx")
workbook.SaveAsCsv("export.csv")
workbook.SaveAsJson("export.json")
workbook.SaveAsXml("export.xml")

Console.WriteLine("Multi-format export completed!")

IronXL unterstützt Excel-Formeln, sodass Sie Berechnungen direkt in exportierte Dateien einfügen können. Das obige Beispiel fügt eine SUM Formel hinzu, um Spaltensummen automatisch zu berechnen. Das Erstellen mehrerer Arbeitsblätter hilft, komplexe Exporte zu organisieren, wie z. B. die Trennung von detaillierten Daten und Zusammenfassungen. Weitere Muster für die Arbeitsblattverwaltung finden Sie im IronXL-Leitfaden zum Erstellen von Excel-Dateien.

Die Formatflexibilität ist insbesondere für Integrationsszenarien von großem Wert. Während XLSX der Standard für Excel-Dateien ist, bietet der CSV-Export universelle Kompatibilität mit Datenbanksystemen und älteren Anwendungen. Die Formate JSON und XML erleichtern den Datenaustausch mit Webdiensten und APIs. Sie können auch vorhandene Arbeitsmappen öffnen, um exportierte Daten an bestehende Tabellen anzuhängen, anstatt jedes Mal neue Dateien zu erstellen.

Wie vereinfacht IronXL Ihren C#-Entwicklungsworkflow?

Der Hauptvorteil von IronXL besteht darin, dass keine Abhängigkeiten von Microsoft Office bestehen. Ihre Anwendung läuft konsistent, egal ob sie auf einer Entwickler-Workstation, einem Kundenrechner oder in einem Docker-Container bereitgestellt wird. Diese Unabhängigkeit vereinfacht die Bereitstellung und reduziert Supportprobleme, die mit Office-Versionen und -Installationen zusammenhängen. Das Open XML SDK von Microsoft ist eine weitere Alternative ohne Office-Software, erfordert jedoch im Vergleich zur High-Level-API von IronXL deutlich mehr Boilerplate-Code. Für plattformübergreifende Entwicklungsrichtlinien für .NET 10 bietet die Microsoft .NET Dokumentation Informationen zu Plattformzielen, Bereitstellungsmodellen und Besonderheiten von Windows Forms.

Das API-Design der Bibliothek priorisiert Einfachheit. Im Gegensatz zum COM-basierten Ansatz von Interop, der eine sorgfältige Objektfreigabe erfordert, verwendet IronXL Standard .NET Muster, die sich für C#-Entwickler natürlich anfühlen. Die plattformübergreifende Unterstützung bedeutet, dass die für Windows Forms entwickelten Exportfunktionen in ASP.NET Core Anwendungen, die auf Linux-Servern laufen, wiederverwendet werden können. Eine vollständige Übersicht der verfügbaren Funktionen finden Sie auf der IronXL -Funktionsseite .

Sie können auch Daten aus Excel importieren, um Ihre DataGridView vor dem Export zu befüllen und so Round-Trip-Workflows zu erstellen, bei denen Benutzer Excel-Daten laden, sie im Grid bearbeiten und das Ergebnis zurück nach Excel exportieren. Die Anleitung zum Lesen von Excel-Dateien behandelt den Importvorgang ausführlich.

Bei der Arbeit mit sensiblen Daten unterstützt IronXL den Passwortschutz auf Arbeitsmappen- und Tabellenblattebene. Die IronXL Dokumentation behandelt Sicherheitsoptionen für Szenarien, in denen exportierte Dateien vor der Verteilung geschützt werden müssen.

IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";

IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";

Imports IronXL

IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"

Warum sollten Sie IronXL für Excel-Exporte in C# wählen?

Der Export von DataGridView Daten nach Excel wird mit IronXL zum Kinderspiel. Die Bibliothek beseitigt herkömmliche Interop-Komplexitäten und bietet professionelle Formatierungsfähigkeiten und mehrere Exportformate. Dank seiner containerfreundlichen Architektur, minimalen Abhängigkeiten und plattformübergreifenden Unterstützung ist es ideal für moderne DevOps-Workflows.

Die IronXL Homepage ist der Ausgangspunkt für die Erkundung der gesamten Bibliothek. Egal ob es um die Entwicklung von Microservices, die Bereitstellung in Kubernetes-Clustern oder die Ausführung serverloser Funktionen geht, IronXL lässt sich nahtlos in CI/CD-Pipelines integrieren. Die Anleitung zum Exportieren in Excel bietet zusätzliche Vorlagen für verschiedene Exportszenarien, und die Anleitung zum Öffnen von Arbeitsmappen behandelt das Lesen und Bearbeiten bestehender Dateien.

Beginnen Sie mit einer kostenlosen Testlizenz, um den vollen Funktionsumfang kennenzulernen. Die Tutorials und Codebeispiele von IronXL helfen Ihnen, schnell produktionsreife Lösungen zu implementieren. Wählen Sie aus flexiblen Lizenzierungsoptionen , die Ihren Bereitstellungsanforderungen entsprechen – von Einzelentwicklerlizenzen bis hin zu unbegrenzten Enterprise . Bei Fragen zum Einstieg bietet das IronXL Dokumentationsportal API-Referenzen, Codebeispiele und Hilfestellungen zur Fehlerbehebung.