Wie exportiert man Datagridview nach Excel in C#

Dieses Tutorial bietet eine umfassende Anleitung für den Export von Daten aus einem DataGridView-Steuerelement in einer Windows Forms-Anwendung in eine Excel-Datei mit Hilfe der IronXL bibliothek in C#. Unser Schwerpunkt liegt auf der Schaffung einer nahtlosen Erfahrung für Anfänger, die Microsoft Excel-Funktionalität in ihre C#-Projekte integrieren wollen.

Wie exportiert man DataGridView nach Excel in C#;

1. Erstellen Sie ein C# Windows Forms-Projekt in Visual Studio.

2. Installieren Sie die Excel-Bibliothek mit NuGet Package Manager.

3. Erstellen Sie ein DataGridView und eine Schaltfläche in der Windows Form UI.

4. Hängen Sie eine Datenquelle an das DataGridView an.

5. Wenden Sie die Datenexportlogik im Click-Event-Handler der Schaltfläche an.

Erste Schritte mit IronXL

IronXL ist eine robuste Bibliothek, die das Arbeiten mit Excel-Dokumenten in .NET-Framework-Anwendungen vereinfacht. Es ermöglicht Ihnen, große Excel-Dateien zu exportieren, komplexe Datenquellen zu verarbeiten und bietet umfassende Unterstützung für die Bearbeitung von .NET-Excel-Dateien, ohne dass Sie über die Microsoft Excel Object Library verfügen müssen. Richten wir unser Projekt ein.

Ihr Projekt einrichten

1. Erstellen einer neuen Windows Forms-Anwendung

Öffnen Sie Visual Studio und erstellen Sie eine neue Windows Forms-Anwendung. Dies wird die Basis für unser Projekt sein, in dem wir die Funktionalität zum Export von DataGridView-Daten in eine Excel-Datei implementieren werden.

2. IronXL installieren

IronXL kann problemlos in Ihr Projekt integriert werden. Navigieren Sie in Visual Studio zu der Option "NuGet-Pakete verwalten", suchen Sie nach IronXL und installieren Sie es. Diese Aktion behandelt alle Abhängigkeiten, die für den Export von DataGridView nach Excel in C# erforderlich sind.

3. Bereiten Sie die Benutzeroberfläche vor

Fügen Sie ein DataGridView-Steuerelement zu Ihrem Formular hinzu. Dieses Steuerelement enthält die Daten, die wir exportieren wollen. Fügen Sie außerdem eine Schaltfläche zum Auslösen des Exportvorgangs hinzu. Sie können es als "Export nach Excel" oder ähnlich bezeichnen.

Implementierung der Exportfunktionalität

In diesem Abschnitt lernen Sie, wie Sie die Funktionalität programmieren, die es Ihnen ermöglicht, Daten aus einer DataGridView in einer Windows Forms-Anwendung mit IronXL in ein Excel-Dokument zu exportieren.

Erstellung der Anwendung

Zunächst müssen Sie ein DataGridView-Steuerelement zu Ihrem Formular hinzufügen. Dieses Steuerelement ist die Hauptkomponente, in der Ihre Daten angezeigt werden, bevor sie exportiert werden. Sie können es einfach hinzufügen, indem Sie eine DataGridView aus der Toolbox in Visual Studio auf Ihr Formular ziehen. Wir können auch eine Schaltfläche zum Exportieren von DataGridView-Daten in Excel-Dateien hinzufügen.

Der nächste Schritt ist das Laden der Daten in die DataGridView. Diese Daten können aus verschiedenen Quellen stammen, beispielsweise aus einer DataTable oder einem DataSet. Wenn Sie neu anfangen, sollten Sie einen neuen Datensatz oder eine Datentabelle programmatisch erstellen und mit Beispieldaten füllen, um zu sehen, wie es funktioniert. Alternativ können Sie auch Daten aus einer externen Quelle importieren. Der Schlüssel hierzu ist die Bindung Ihrer Datenquelle an die DataGridView, die Ihre Daten effektiv mit dem Raster verbindet. Sobald Ihre Daten an die DataGridView gebunden sind, werden sie in der Tabelle auf Ihrem Formular angezeigt.

private void BindDataToDataGridView()
{
    // Create a new DataTable.
    DataTable dataTable = new DataTable();
    // Define columns for the DataTable.
    dataTable.Columns.Add("Employee ID", typeof(int));
    dataTable.Columns.Add("Name", typeof(string));
    dataTable.Columns.Add("Department", typeof(string));
    dataTable.Columns.Add("Joining Date", typeof(DateTime));
    // Add sample data to the DataTable.
    for (int i = 1; i <= 25; i++)
    {
        dataTable.Rows.Add(i, "Employee " + i, "Department " + (i % 5 + 1), DateTime.Now.AddDays(-i * 15));
    }
    // Bind the DataTable to the DataGridView.
    dataGridView1.DataSource = dataTable;
}

private void BindDataToDataGridView()
{
    // Create a new DataTable.
    DataTable dataTable = new DataTable();
    // Define columns for the DataTable.
    dataTable.Columns.Add("Employee ID", typeof(int));
    dataTable.Columns.Add("Name", typeof(string));
    dataTable.Columns.Add("Department", typeof(string));
    dataTable.Columns.Add("Joining Date", typeof(DateTime));
    // Add sample data to the DataTable.
    for (int i = 1; i <= 25; i++)
    {
        dataTable.Rows.Add(i, "Employee " + i, "Department " + (i % 5 + 1), DateTime.Now.AddDays(-i * 15));
    }
    // Bind the DataTable to the DataGridView.
    dataGridView1.DataSource = dataTable;
}

Private Sub BindDataToDataGridView()
	' Create a new DataTable.
	Dim dataTable As New DataTable()
	' Define columns for the DataTable.
	dataTable.Columns.Add("Employee ID", GetType(Integer))
	dataTable.Columns.Add("Name", GetType(String))
	dataTable.Columns.Add("Department", GetType(String))
	dataTable.Columns.Add("Joining Date", GetType(DateTime))
	' Add sample data to the DataTable.
	For i As Integer = 1 To 25
		dataTable.Rows.Add(i, "Employee " & i, "Department " & (i Mod 5 + 1), DateTime.Now.AddDays(-i * 15))
	Next i
	' Bind the DataTable to the DataGridView.
	dataGridView1.DataSource = dataTable
End Sub

Behandlung des Tastenklick-Ereignisses

Unser primärer Interaktionspunkt mit dem Benutzer wird eine Schaltfläche in unserem Windows-Formular sein. Wenn Sie auf diese Schaltfläche klicken, wird der Exportvorgang eingeleitet. So richten Sie diese Interaktion ein:

• In Ihrem Windows-Formular sollten Sie eine Schaltfläche zum Exportieren der DataGridView-Daten haben.
• Diese Schaltfläche hat eine Ereignisbehandlungsmethode in Ihrem C#-Code. Diese Methode wird ausgelöst, wenn der Benutzer auf die Schaltfläche klickt.

private void btnExport_Click(object sender, EventArgs e)
{
    // Code to export data will go here
}

private void btnExport_Click(object sender, EventArgs e)
{
    // Code to export data will go here
}

Private Sub btnExport_Click(ByVal sender As Object, ByVal e As EventArgs)
	' Code to export data will go here
End Sub

Daten aus DataGridView exportieren

Um die DataGridView-Daten zu exportieren, müssen wir zunächst auf den IronXL-Namensraum verweisen:

using IronXL;

using IronXL;

Imports IronXL

Innerhalb des Ereignis-Handlers wird zunächst eine neue Arbeitsmappe und ein neues Arbeitsblatt mit IronXL initialisiert. Hierher werden die Daten aus dem DataGridView übertragen.

• Ein WorkBook-Objekt stellt die gesamte Excel-Datei dar.

• Ein Arbeitsblatt innerhalb der Arbeitsmappe ist wie eine einzelne Seite oder Registerkarte in einer Excel-Datei.

  Hier erstellen wir eine Arbeitsmappe und fügen ihr ein Arbeitsblatt hinzu. Das Arbeitsblatt trägt den Namen "ExportedData", aber Sie können jeden beliebigen Namen wählen, der in den Kontext Ihrer Anwendung passt.

WorkBook workbook = new WorkBook();
WorkSheet worksheet = workbook.CreateWorkSheet("ExportedData");

WorkBook workbook = new WorkBook();
WorkSheet worksheet = workbook.CreateWorkSheet("ExportedData");

Dim workbook As New WorkBook()
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("ExportedData")

Ausfüllen der Excel-Tabelle

Der nächste Schritt besteht darin, die Zeilen und Spalten der DataGridView zu durchlaufen und die Daten jeder Zelle in die entsprechende Zelle im Excel-Arbeitsblatt zu kopieren.

• Die externe Schleife durchläuft jede Zeile, während die interne Schleife jede Spalte innerhalb der jeweiligen Zeile durchläuft.
• Wir weisen den Wert jeder Zelle in der DataGridView der entsprechenden Zelle im Excel-Arbeitsblatt zu. Dies geschieht mit Hilfe der Indizes i (für Reihen) und j (für Spalten).

for (int i = 0; i < dataGridView1.Rows.Count; i++)
{
    for (int j = 0; j < dataGridView1.Columns.Count; j++)
    {
        // Convert row and column index to Excel cell address format
        string cellAddress = ConvertToCellAddress(i, j);
        worksheet [cellAddress].Value = dataGridView1.Rows [i].Cells [j].Value.ToString();
    }
}

for (int i = 0; i < dataGridView1.Rows.Count; i++)
{
    for (int j = 0; j < dataGridView1.Columns.Count; j++)
    {
        // Convert row and column index to Excel cell address format
        string cellAddress = ConvertToCellAddress(i, j);
        worksheet [cellAddress].Value = dataGridView1.Rows [i].Cells [j].Value.ToString();
    }
}

For i As Integer = 0 To dataGridView1.Rows.Count - 1
	For j As Integer = 0 To dataGridView1.Columns.Count - 1
		' Convert row and column index to Excel cell address format
		Dim cellAddress As String = ConvertToCellAddress(i, j)
		worksheet (cellAddress).Value = dataGridView1.Rows (i).Cells (j).Value.ToString()
	Next j
Next i

Um die Zeilen- und Spaltenindizes in eine Excel-Zelladresse umzuwandeln, können Sie eine Hilfsmethode wie die folgende verwenden:

private string ConvertToCellAddress(int row, int column)
{
    // Columns in Excel are labeled as A, B, C, ..., Z, AA, AB, ..., etc.
    // The following code converts a column index to this format.
    string columnLabel = "";
    while (column >= 0)
    {
        columnLabel = (char)('A' + column % 26) + columnLabel;
        column = column / 26 - 1;
    }
    // Rows in Excel are labeled as 1, 2, 3, ..., n
    // Adding 1 because Excel is 1-based and our loop is 0-based.
    string rowLabel = (row + 1).ToString();
    return columnLabel + rowLabel;
}

private string ConvertToCellAddress(int row, int column)
{
    // Columns in Excel are labeled as A, B, C, ..., Z, AA, AB, ..., etc.
    // The following code converts a column index to this format.
    string columnLabel = "";
    while (column >= 0)
    {
        columnLabel = (char)('A' + column % 26) + columnLabel;
        column = column / 26 - 1;
    }
    // Rows in Excel are labeled as 1, 2, 3, ..., n
    // Adding 1 because Excel is 1-based and our loop is 0-based.
    string rowLabel = (row + 1).ToString();
    return columnLabel + rowLabel;
}

Private Function ConvertToCellAddress(ByVal row As Integer, ByVal column As Integer) As String
	' Columns in Excel are labeled as A, B, C, ..., Z, AA, AB, ..., etc.
	' The following code converts a column index to this format.
	Dim columnLabel As String = ""
	Do While column >= 0
		columnLabel = ChrW(AscW("A"c) + column Mod 26) & columnLabel
		column = column \ 26 - 1
	Loop
	' Rows in Excel are labeled as 1, 2, 3, ..., n
	' Adding 1 because Excel is 1-based and our loop is 0-based.
	Dim rowLabel As String = (row + 1).ToString()
	Return columnLabel & rowLabel
End Function

Speichern der Excel-Datei

Sobald alle Daten übertragen sind, müssen Sie diese Arbeitsmappe als Excel-Datei speichern. Bei diesem Schritt wird eine Excel-Datei auf Ihrem System unter dem angegebenen Pfad erstellt.

workbook.SaveAs("DataGridViewExport.xlsx");
MessageBox.Show("Data exported successfully!", "Success", MessageBoxButtons.OK, MessageBoxIcon.Information);

workbook.SaveAs("DataGridViewExport.xlsx");
MessageBox.Show("Data exported successfully!", "Success", MessageBoxButtons.OK, MessageBoxIcon.Information);

workbook.SaveAs("DataGridViewExport.xlsx")
MessageBox.Show("Data exported successfully!", "Success", MessageBoxButtons.OK, MessageBoxIcon.Information)

Fehlerbehandlung

Bei jedem Datenexportprozess ist die Behandlung von Ausnahmen entscheidend für die Stabilität der Anwendung. Die Einbettung der Exportlogik in einen try-catch-Block stellt sicher, dass alle Probleme während des Exports (wie Dateizugriffsberechtigungen, Datenformatprobleme usw.) werden aufgefangen und anständig behandelt.

try
{
    // Export logic
}
catch (Exception ex)
{
    MessageBox.Show("An exception occurred: " + ex.Message);
}

try
{
    // Export logic
}
catch (Exception ex)
{
    MessageBox.Show("An exception occurred: " + ex.Message);
}

Try
	' Export logic
Catch ex As Exception
	MessageBox.Show("An exception occurred: " & ex.Message)
End Try

Ausgabe

Sobald wir das Programm starten, wird diese Schnittstelle angezeigt:

Hier können Sie sehen, dass die Daten in der DataGridView angezeigt werden. Klicken Sie nun auf die Schaltfläche Exportieren. Es exportiert die Daten aus der DataGridView in eine Excel-Datei.

Hier sehen Sie, dass ein Meldungsfenster erscheint und die Daten in eine Excel-Datei exportiert werden. Hier sehen Sie die Excel-Ausgabedatei:

Schlussfolgerung

Wenn Sie diese Anleitung befolgen, verfügen Sie über ein einfaches, aber leistungsfähiges Tool zum Exportieren von DataGridView-Daten in eine Excel-Datei mit C# und IronXL. Diese Funktionalität ist von entscheidender Bedeutung für Anwendungen, die Datenanalysen, Berichte oder einfach die Übertragung von Daten zwischen verschiedenen Formaten erfordern. Denken Sie daran, dass das Experimentieren mit verschiedenen Funktionen des DataGridView-Steuerelements und der IronXL-Bibliothek zu individuelleren und fortgeschritteneren Implementierungen führen kann.

IronXL bietet eine kostenlos testen die Sie nutzen können, um seine Funktionen zu erkunden. Die Lizenzierung beginnt bei $749, was eine lohnende Investition für Fachleute und Organisationen ist, die eine zuverlässige und effiziente Lösung für die Manipulation von Excel-Dateien in .NET-Anwendungen suchen.

Ihre Reise ist hier noch nicht zu Ende. Entdecken Sie weitere Funktionen von IronXL und andere Möglichkeiten zur Verbesserung Ihrer Windows Forms-Anwendungen. Fröhliches Kodieren!