Wie kann ich GridView-Daten in C# nach Excel exportieren?

Mit der IronXL -Bibliothek können Sie GridView-Daten in C# nach Excel exportieren. Sie ermöglicht die programmgesteuerte Erstellung von Excel-Dateien und den einfachen Datenexport inklusive Formatierung und Stilen.

Warum sollte ich IronXL zum Exportieren von GridView-Daten verwenden?

IronXL vereinfacht den Export von GridView-Daten durch seine intuitive API, die es Ihnen ermöglicht, Formatierungen beizubehalten und Stile mühelos anzuwenden, was mit herkömmlichen Methoden schwierig sein kann.

Unterstützt IronXL die Formatierung beim Export von GridView nach Excel?

Ja, IronXL unterstützt verschiedene Formatierungsoptionen, darunter Schriftarten, Farben und Zellstile, sodass Ihre exportierten Excel-Dateien professionell aussehen und das gewünschte Design beibehalten.

Kann ich das Erscheinungsbild von Excel-Dateien anpassen, die aus GridView-Daten generiert werden?

IronXL bietet eine Reihe von Anpassungsoptionen für Excel-Dateien, mit denen Sie Zellstile, Schriftarten, Farben und mehr an Ihre spezifischen Anforderungen beim Export aus GridView anpassen können.

Ist es möglich, große GridView-Datensätze mit IronXL nach Excel zu exportieren?

IronXL ist in der Lage, große Datensätze effizient zu verarbeiten, sodass Sie umfangreiche GridView-Daten ohne Leistungsprobleme nach Excel exportieren können.

Welche Vorteile bietet der Export von GridView-Daten nach Excel mit IronXL gegenüber anderen Methoden?

IronXL bietet einen effizienteren und flexibleren Ansatz für den Export von GridView-Daten und bietet robuste Unterstützung für Formatierung, Anpassung und die Verarbeitung großer Datensätze, wodurch es vielen anderen Methoden überlegen ist.

Wie kann ich die Datenintegrität beim Exportieren von GridView nach Excel gewährleisten?

IronXL gewährleistet die Datenintegrität, indem es Datentypen und -formate während des Exportvorgangs von GridView nach Excel präzise konvertiert und beibehält.

Kann IronXL Daten aus GridView-Steuerelementen mit komplexen Strukturen exportieren?

Ja, IronXL kann Daten aus GridView-Steuerelementen mit komplexen Strukturen effektiv verarbeiten und exportieren, wobei Hierarchie und Formatierung in der resultierenden Excel-Datei erhalten bleiben.

In welche Dateiformate kann IronXL GridView-Daten exportieren?

IronXL exportiert Daten primär in Excel-Formate wie XLSX, unterstützt aber auch andere Formate wie CSV und bietet so Flexibilität je nach Bedarf.

Wird der Export von GridView mit bedingter Formatierung mithilfe von IronXL unterstützt?

IronXL unterstützt bedingte Formatierung, sodass Sie Regeln und Stile festlegen können, die sich beim Export von GridView-Daten nach Excel dynamisch an die Zellwerte anpassen.

Die C# Excel-Bibliothek

Explore IronXL Excel Spreadsheet Library for C# .NET Gratis testen

Excel-Dateien ohne Interop lesen

Alle Codebeispiele anzeigen

using IronXL;
using System;
using System.Linq;

// Supported for XLSX, XLS, XLSM, XLTX, CSV and TSV
WorkBook workBook = WorkBook.Load("sample.xlsx");

// Select worksheet at index 0
WorkSheet workSheet = workBook.WorkSheets[0];

// Get any existing worksheet
WorkSheet firstSheet = workBook.DefaultWorkSheet;

// Select a cell and return the converted value
int cellValue = workSheet["A2"].IntValue;

// Read from ranges of cells elegantly.
foreach (var cell in workSheet["A2:A10"])
{
    Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text);
}

// Calculate aggregate values such as Min, Max and Sum
decimal sum = workSheet["A2:A10"].Sum();

// Linq compatible
decimal max = workSheet["A2:A10"].Max(c => c.DecimalValue);

using IronXL;
using System;
using System.Linq;

// Supported for XLSX, XLS, XLSM, XLTX, CSV and TSV
WorkBook workBook = WorkBook.Load("sample.xlsx");

// Select worksheet at index 0
WorkSheet workSheet = workBook.WorkSheets[0];

// Get any existing worksheet
WorkSheet firstSheet = workBook.DefaultWorkSheet;

// Select a cell and return the converted value
int cellValue = workSheet["A2"].IntValue;

// Read from ranges of cells elegantly.
foreach (var cell in workSheet["A2:A10"])
{
    Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text);
}

// Calculate aggregate values such as Min, Max and Sum
decimal sum = workSheet["A2:A10"].Sum();

// Linq compatible
decimal max = workSheet["A2:A10"].Max(c => c.DecimalValue);

PM >Install-Package IronXL.Excel

Install-Package IronXL.Excel

IRONXL VERWENDEN

Wie exportiert man ein GridView-Steuerelement mit Formatierung in C# nach Excel?

Curtis Chau

Updated: 28. Juni 2026

Das Exportieren von GridView-Daten nach Excel unter Beibehaltung von Farben, Schriftarten, abwechselnden Zeilenhintergründen und Rahmen ist eine Anforderung, die in fast jeder datengetriebenen ASP.NET oder Windows Forms-Anwendung auftritt. Der traditionelle Ansatz – Verwenden von HtmlTextWriter und StringWriter, um das Steuerelement als HTML darzustellen – erzeugt Dateien, die Formatwarnungen in Excel hervorrufen und für die Benutzer stillschweigend fehlschlagen. IronXL löst dieses Problem, indem es native XLSX-Dateien vollständig in C# generiert, ohne Abhängigkeit von Microsoft Office, wodurch Sie die präzise Kontrolle über jeden Zellenstil erhalten.

Wie installiert man die Bibliothek in einem .NET -Projekt?

Installieren Sie IronXL über NuGet , bevor Sie Exportcode schreiben. Öffnen Sie die Paket-Manager-Konsole und führen Sie aus:

PM > Install-Package IronXL.Excel

Install-Package IronXL.Excel

IronXL unterstützt .NET 8, .NET 9 und .NET 10 sowie .NET Framework 4.6.2 und höher. Nach der Installation fügen Sie die folgenden using-Direktiven zu jeder Datei hinzu, die Excel-Operationen durchführt:

using IronXL;
using IronXL.Styles;

using IronXL;
using IronXL.Styles;

Imports IronXL
Imports IronXL.Styles

Imports IronXL
Imports IronXL.Styles

Es ist keine zusätzliche Laufzeit oder Office-Interoperabilität erforderlich. Die Bibliothek schreibt native XLSX-Binärdateien, die sich problemlos in Microsoft Excel, LibreOffice Calc und Google Sheets öffnen lassen.

Wie exportiert man ein Windows Forms DataGridView mit Zellformatierung nach Excel?

Windows Forms-Anwendungen verwenden das DataGridView-Steuerelement anstelle des webbasierten GridView. Das Exportmuster ist in beiden Fällen identisch: Werte aus Zeilen und Zellen extrahieren, ein IronXL-Arbeitsbuch erstellen, Stile anwenden und dann das Ergebnis speichern oder streamen.

Der zuverlässigste Ansatz wandelt die DataSource-Eigenschaft des Steuerelements in einen DataTable, um das Durchlaufen der visuellen Zeilen zu vermeiden, die möglicherweise gefiltert oder paginiert sind:

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

DataTable dt = (DataTable)dataGridView1.DataSource;

WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workBook.DefaultWorkSheet;

// Header row -- bold, blue background, white text
for (int col = 0; col < dt.Columns.Count; col++)
{
    sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
    var cell = sheet.GetCellAt(0, col);
    cell.Style.Font.Bold = true;
    cell.Style.SetBackgroundColor("#4472C4");
    cell.Style.Font.Color = "#FFFFFF";
    cell.Style.BottomBorder.Type = BorderType.Thin;
}

// Data rows -- alternating row color
for (int row = 0; row < dt.Rows.Count; row++)
{
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        string value = dt.Rows[row][col]?.ToString() ?? string.Empty;
        sheet.SetCellValue(row + 1, col, value);

        var cell = sheet.GetCellAt(row + 1, col);
        cell.Style.SetBackgroundColor(row % 2 == 0 ? "#D6DCE5" : "#FFFFFF");
        cell.Style.BottomBorder.Type = BorderType.Thin;
    }
}

// Save via dialog
using var saveDialog = new SaveFileDialog
{
    Filter = "Excel Files|*.xlsx",
    FileName = "GridViewExport.xlsx"
};

if (saveDialog.ShowDialog() == DialogResult.OK)
{
    workBook.SaveAs(saveDialog.FileName);
    MessageBox.Show("Export successful.", "Export",
        MessageBoxButtons.OK, MessageBoxIcon.Information);
}

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

DataTable dt = (DataTable)dataGridView1.DataSource;

WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workBook.DefaultWorkSheet;

// Header row -- bold, blue background, white text
for (int col = 0; col < dt.Columns.Count; col++)
{
    sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
    var cell = sheet.GetCellAt(0, col);
    cell.Style.Font.Bold = true;
    cell.Style.SetBackgroundColor("#4472C4");
    cell.Style.Font.Color = "#FFFFFF";
    cell.Style.BottomBorder.Type = BorderType.Thin;
}

// Data rows -- alternating row color
for (int row = 0; row < dt.Rows.Count; row++)
{
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        string value = dt.Rows[row][col]?.ToString() ?? string.Empty;
        sheet.SetCellValue(row + 1, col, value);

        var cell = sheet.GetCellAt(row + 1, col);
        cell.Style.SetBackgroundColor(row % 2 == 0 ? "#D6DCE5" : "#FFFFFF");
        cell.Style.BottomBorder.Type = BorderType.Thin;
    }
}

// Save via dialog
using var saveDialog = new SaveFileDialog
{
    Filter = "Excel Files|*.xlsx",
    FileName = "GridViewExport.xlsx"
};

if (saveDialog.ShowDialog() == DialogResult.OK)
{
    workBook.SaveAs(saveDialog.FileName);
    MessageBox.Show("Export successful.", "Export",
        MessageBoxButtons.OK, MessageBoxIcon.Information);
}

Imports IronXL
Imports IronXL.Styles
Imports System
Imports System.Data
Imports System.IO
Imports System.Windows.Forms

Dim dt As DataTable = DirectCast(dataGridView1.DataSource, DataTable)

Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim sheet As WorkSheet = workBook.DefaultWorkSheet

' Header row -- bold, blue background, white text
For col As Integer = 0 To dt.Columns.Count - 1
    sheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
    Dim cell = sheet.GetCellAt(0, col)
    cell.Style.Font.Bold = True
    cell.Style.SetBackgroundColor("#4472C4")
    cell.Style.Font.Color = "#FFFFFF"
    cell.Style.BottomBorder.Type = BorderType.Thin
Next

' Data rows -- alternating row color
For row As Integer = 0 To dt.Rows.Count - 1
    For col As Integer = 0 To dt.Columns.Count - 1
        Dim value As String = If(dt.Rows(row)(col)?.ToString(), String.Empty)
        sheet.SetCellValue(row + 1, col, value)

        Dim cell = sheet.GetCellAt(row + 1, col)
        cell.Style.SetBackgroundColor(If(row Mod 2 = 0, "#D6DCE5", "#FFFFFF"))
        cell.Style.BottomBorder.Type = BorderType.Thin
    Next
Next

' Save via dialog
Using saveDialog As New SaveFileDialog With {
    .Filter = "Excel Files|*.xlsx",
    .FileName = "GridViewExport.xlsx"
}
    If saveDialog.ShowDialog() = DialogResult.OK Then
        workBook.SaveAs(saveDialog.FileName)
        MessageBox.Show("Export successful.", "Export", MessageBoxButtons.OK, MessageBoxIcon.Information)
    End If
End Using

Imports IronXL
Imports IronXL.Styles
Imports System
Imports System.Data
Imports System.IO
Imports System.Windows.Forms

Dim dt As DataTable = DirectCast(dataGridView1.DataSource, DataTable)

Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim sheet As WorkSheet = workBook.DefaultWorkSheet

' Header row -- bold, blue background, white text
For col As Integer = 0 To dt.Columns.Count - 1
    sheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
    Dim cell = sheet.GetCellAt(0, col)
    cell.Style.Font.Bold = True
    cell.Style.SetBackgroundColor("#4472C4")
    cell.Style.Font.Color = "#FFFFFF"
    cell.Style.BottomBorder.Type = BorderType.Thin
Next

' Data rows -- alternating row color
For row As Integer = 0 To dt.Rows.Count - 1
    For col As Integer = 0 To dt.Columns.Count - 1
        Dim value As String = If(dt.Rows(row)(col)?.ToString(), String.Empty)
        sheet.SetCellValue(row + 1, col, value)

        Dim cell = sheet.GetCellAt(row + 1, col)
        cell.Style.SetBackgroundColor(If(row Mod 2 = 0, "#D6DCE5", "#FFFFFF"))
        cell.Style.BottomBorder.Type = BorderType.Thin
    Next
Next

' Save via dialog
Using saveDialog As New SaveFileDialog With {
    .Filter = "Excel Files|*.xlsx",
    .FileName = "GridViewExport.xlsx"
}
    If saveDialog.ShowDialog() = DialogResult.OK Then
        workBook.SaveAs(saveDialog.FileName)
        MessageBox.Show("Export successful.", "Export", MessageBoxButtons.OK, MessageBoxIcon.Information)
    End If
End Using

WorkBook.Create initialisiert ein neues In-Memory-Arbeitsbuch im XLSX-Format. DefaultWorkSheet gibt das erste Blatt zurück, das Sie vor dem Speichern über seine Name-Eigenschaft umbenennen können. SetCellValue akzeptiert Strings, Integer, Doubles und DateTime-Werte – IronXL wählt automatisch den richtigen Zellentyp aus.

Das wechselnde Zeilenfarbmuster – row % 2 == 0 wählt #D6DCE5, andernfalls #FFFFFF – spiegelt den in Excel integrierten tabellenstil mit Bänderzeilen wider. Sie können jede beliebige sechsstellige Hexadezimalfarbe verwenden, die zum Designsystem Ihrer Anwendung passt.

Ausgabebilder

GridView nach Excel mit Formatierung in C# exportieren mit IronXL: Bild 1 - GridView-Ausgabe

GridView nach Excel mit Formatierung in C# exportieren mit IronXL: Bild 2 - Excel-Ausgabe

GridView nach Excel mit Formatierung in C# exportieren mit IronXL: Bild 3 - Meldungsausgabe

Wie exportiert man ein ASP.NET GridView nach Excel und streamt die Datei an den Browser?

Webanwendungen benötigen einen anderen Bereitstellungsmechanismus. Anstatt auf das Dateisystem zu schreiben, serialisieren Sie das Arbeitsbuch in einen MemoryStream und schreiben es mit den richtigen Headern in die HTTP-Antwort, sodass der Browser es als Datei-Download behandelt.

Der wichtige Pre-Flight-Schritt für paginierte GridViews: Paging deaktivieren (AllowPaging = false) und die Datenquelle neu binden, bevor exportiert wird, damit jeder Datensatz – nicht nur die aktuelle Seite – erfasst wird.

using IronXL;
using IronXL.Styles;
using System;
using System.Data;
using System.IO;
using System.Web.UI;

// Disable paging so all rows are captured
GridView1.AllowPaging = false;
GridView1.DataBind();

DataTable dt = (DataTable)GridView1.DataSource;

WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workBook.DefaultWorkSheet;

// Header row
for (int col = 0; col < dt.Columns.Count; col++)
{
    sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
    var cell = sheet.GetCellAt(0, col);
    cell.Style.Font.Bold = true;
    cell.Style.SetBackgroundColor("#2E75B6");
    cell.Style.Font.Color = "#FFFFFF";
    cell.Style.HorizontalAlignment = HorizontalAlignment.Center;
    cell.Style.BottomBorder.Type = BorderType.Medium;
}

// Data rows
for (int row = 0; row < dt.Rows.Count; row++)
{
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        sheet.SetCellValue(row + 1, col, dt.Rows[row][col]?.ToString() ?? string.Empty);
        var cell = sheet.GetCellAt(row + 1, col);
        cell.Style.SetBackgroundColor(row % 2 == 0 ? "#DEEAF1" : "#FFFFFF");
        cell.Style.BottomBorder.Type = BorderType.Thin;
        cell.Style.LeftBorder.Type = BorderType.Thin;
        cell.Style.RightBorder.Type = BorderType.Thin;
    }
}

// Stream to browser
byte[] fileBytes = workBook.ToByteArray();
Response.Clear();
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
Response.AddHeader("content-disposition", "attachment; filename=GridViewExport.xlsx");
Response.BinaryWrite(fileBytes);
Response.End();

using IronXL;
using IronXL.Styles;
using System;
using System.Data;
using System.IO;
using System.Web.UI;

// Disable paging so all rows are captured
GridView1.AllowPaging = false;
GridView1.DataBind();

DataTable dt = (DataTable)GridView1.DataSource;

WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workBook.DefaultWorkSheet;

// Header row
for (int col = 0; col < dt.Columns.Count; col++)
{
    sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
    var cell = sheet.GetCellAt(0, col);
    cell.Style.Font.Bold = true;
    cell.Style.SetBackgroundColor("#2E75B6");
    cell.Style.Font.Color = "#FFFFFF";
    cell.Style.HorizontalAlignment = HorizontalAlignment.Center;
    cell.Style.BottomBorder.Type = BorderType.Medium;
}

// Data rows
for (int row = 0; row < dt.Rows.Count; row++)
{
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        sheet.SetCellValue(row + 1, col, dt.Rows[row][col]?.ToString() ?? string.Empty);
        var cell = sheet.GetCellAt(row + 1, col);
        cell.Style.SetBackgroundColor(row % 2 == 0 ? "#DEEAF1" : "#FFFFFF");
        cell.Style.BottomBorder.Type = BorderType.Thin;
        cell.Style.LeftBorder.Type = BorderType.Thin;
        cell.Style.RightBorder.Type = BorderType.Thin;
    }
}

// Stream to browser
byte[] fileBytes = workBook.ToByteArray();
Response.Clear();
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
Response.AddHeader("content-disposition", "attachment; filename=GridViewExport.xlsx");
Response.BinaryWrite(fileBytes);
Response.End();

Imports IronXL
Imports IronXL.Styles
Imports System
Imports System.Data
Imports System.IO
Imports System.Web.UI

' Disable paging so all rows are captured
GridView1.AllowPaging = False
GridView1.DataBind()

Dim dt As DataTable = CType(GridView1.DataSource, DataTable)

Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim sheet As WorkSheet = workBook.DefaultWorkSheet

' Header row
For col As Integer = 0 To dt.Columns.Count - 1
    sheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
    Dim cell = sheet.GetCellAt(0, col)
    cell.Style.Font.Bold = True
    cell.Style.SetBackgroundColor("#2E75B6")
    cell.Style.Font.Color = "#FFFFFF"
    cell.Style.HorizontalAlignment = HorizontalAlignment.Center
    cell.Style.BottomBorder.Type = BorderType.Medium
Next

' Data rows
For row As Integer = 0 To dt.Rows.Count - 1
    For col As Integer = 0 To dt.Columns.Count - 1
        sheet.SetCellValue(row + 1, col, If(dt.Rows(row)(col)?.ToString(), String.Empty))
        Dim cell = sheet.GetCellAt(row + 1, col)
        cell.Style.SetBackgroundColor(If(row Mod 2 = 0, "#DEEAF1", "#FFFFFF"))
        cell.Style.BottomBorder.Type = BorderType.Thin
        cell.Style.LeftBorder.Type = BorderType.Thin
        cell.Style.RightBorder.Type = BorderType.Thin
    Next
Next

' Stream to browser
Dim fileBytes As Byte() = workBook.ToByteArray()
Response.Clear()
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
Response.AddHeader("content-disposition", "attachment; filename=GridViewExport.xlsx")
Response.BinaryWrite(fileBytes)
Response.End()

Imports IronXL
Imports IronXL.Styles
Imports System
Imports System.Data
Imports System.IO
Imports System.Web.UI

' Disable paging so all rows are captured
GridView1.AllowPaging = False
GridView1.DataBind()

Dim dt As DataTable = CType(GridView1.DataSource, DataTable)

Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim sheet As WorkSheet = workBook.DefaultWorkSheet

' Header row
For col As Integer = 0 To dt.Columns.Count - 1
    sheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
    Dim cell = sheet.GetCellAt(0, col)
    cell.Style.Font.Bold = True
    cell.Style.SetBackgroundColor("#2E75B6")
    cell.Style.Font.Color = "#FFFFFF"
    cell.Style.HorizontalAlignment = HorizontalAlignment.Center
    cell.Style.BottomBorder.Type = BorderType.Medium
Next

' Data rows
For row As Integer = 0 To dt.Rows.Count - 1
    For col As Integer = 0 To dt.Columns.Count - 1
        sheet.SetCellValue(row + 1, col, If(dt.Rows(row)(col)?.ToString(), String.Empty))
        Dim cell = sheet.GetCellAt(row + 1, col)
        cell.Style.SetBackgroundColor(If(row Mod 2 = 0, "#DEEAF1", "#FFFFFF"))
        cell.Style.BottomBorder.Type = BorderType.Thin
        cell.Style.LeftBorder.Type = BorderType.Thin
        cell.Style.RightBorder.Type = BorderType.Thin
    Next
Next

' Stream to browser
Dim fileBytes As Byte() = workBook.ToByteArray()
Response.Clear()
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
Response.AddHeader("content-disposition", "attachment; filename=GridViewExport.xlsx")
Response.BinaryWrite(fileBytes)
Response.End()

Response.AddHeader mit content-disposition: attachment erzwingt ein Dialogfeld für Datei-Downloads in allen modernen Browsern. Der MIME-Typ application/vnd.openxmlformats-officedocument.spreadsheetml.sheet ist der registrierte Typ für XLSX-Dateien und verhindert, dass der Browser versucht, den Binärinhalt inline anzuzeigen.

Für ASP.NET Core-Anwendungen ersetzen Sie Response.BinaryWrite durch File(fileBytes, contentType, fileName) in einer Controller-Aktion – die Logik zur Erstellung des Arbeitsbuchs ist identisch.

Wie wendet man bedingte Formatierung basierend auf Zellwerten an?

Die bedingte Formatierung hebt Zellen hervor, die bestimmte Kriterien erfüllen – beispielsweise werden überfällige Daten rot markiert oder Werte unterhalb eines Schwellenwerts orange dargestellt. IronXL wendet bedingte Formatierungen auf Zellenebene während der Erstellung der Arbeitsmappe an:

// Assume "DueDate" is column index 3 and "Amount" is column index 4
DateTime today = DateTime.Today;

for (int row = 0; row < dt.Rows.Count; row++)
{
    // Highlight past-due dates
    if (dt.Columns.Contains("DueDate") && dt.Rows[row]["DueDate"] != DBNull.Value)
    {
        DateTime dueDate = Convert.ToDateTime(dt.Rows[row]["DueDate"]);
        var dueDateCell = sheet.GetCellAt(row + 1, 3);
        if (dueDate < today)
        {
            dueDateCell.Style.SetBackgroundColor("#FF0000");
            dueDateCell.Style.Font.Color = "#FFFFFF";
            dueDateCell.Style.Font.Bold = true;
        }
    }

    // Highlight amounts below threshold
    if (dt.Columns.Contains("Amount") && dt.Rows[row]["Amount"] != DBNull.Value)
    {
        decimal amount = Convert.ToDecimal(dt.Rows[row]["Amount"]);
        var amountCell = sheet.GetCellAt(row + 1, 4);
        if (amount < 100m)
        {
            amountCell.Style.SetBackgroundColor("#FFC000");
        }
    }
}

// Assume "DueDate" is column index 3 and "Amount" is column index 4
DateTime today = DateTime.Today;

for (int row = 0; row < dt.Rows.Count; row++)
{
    // Highlight past-due dates
    if (dt.Columns.Contains("DueDate") && dt.Rows[row]["DueDate"] != DBNull.Value)
    {
        DateTime dueDate = Convert.ToDateTime(dt.Rows[row]["DueDate"]);
        var dueDateCell = sheet.GetCellAt(row + 1, 3);
        if (dueDate < today)
        {
            dueDateCell.Style.SetBackgroundColor("#FF0000");
            dueDateCell.Style.Font.Color = "#FFFFFF";
            dueDateCell.Style.Font.Bold = true;
        }
    }

    // Highlight amounts below threshold
    if (dt.Columns.Contains("Amount") && dt.Rows[row]["Amount"] != DBNull.Value)
    {
        decimal amount = Convert.ToDecimal(dt.Rows[row]["Amount"]);
        var amountCell = sheet.GetCellAt(row + 1, 4);
        if (amount < 100m)
        {
            amountCell.Style.SetBackgroundColor("#FFC000");
        }
    }
}

Imports System

' Assume "DueDate" is column index 3 and "Amount" is column index 4
Dim today As DateTime = DateTime.Today

For row As Integer = 0 To dt.Rows.Count - 1
    ' Highlight past-due dates
    If dt.Columns.Contains("DueDate") AndAlso dt.Rows(row)("DueDate") IsNot DBNull.Value Then
        Dim dueDate As DateTime = Convert.ToDateTime(dt.Rows(row)("DueDate"))
        Dim dueDateCell = sheet.GetCellAt(row + 1, 3)
        If dueDate < today Then
            dueDateCell.Style.SetBackgroundColor("#FF0000")
            dueDateCell.Style.Font.Color = "#FFFFFF"
            dueDateCell.Style.Font.Bold = True
        End If
    End If

    ' Highlight amounts below threshold
    If dt.Columns.Contains("Amount") AndAlso dt.Rows(row)("Amount") IsNot DBNull.Value Then
        Dim amount As Decimal = Convert.ToDecimal(dt.Rows(row)("Amount"))
        Dim amountCell = sheet.GetCellAt(row + 1, 4)
        If amount < 100D Then
            amountCell.Style.SetBackgroundColor("#FFC000")
        End If
    End If
Next row

Imports System

' Assume "DueDate" is column index 3 and "Amount" is column index 4
Dim today As DateTime = DateTime.Today

For row As Integer = 0 To dt.Rows.Count - 1
    ' Highlight past-due dates
    If dt.Columns.Contains("DueDate") AndAlso dt.Rows(row)("DueDate") IsNot DBNull.Value Then
        Dim dueDate As DateTime = Convert.ToDateTime(dt.Rows(row)("DueDate"))
        Dim dueDateCell = sheet.GetCellAt(row + 1, 3)
        If dueDate < today Then
            dueDateCell.Style.SetBackgroundColor("#FF0000")
            dueDateCell.Style.Font.Color = "#FFFFFF"
            dueDateCell.Style.Font.Bold = True
        End If
    End If

    ' Highlight amounts below threshold
    If dt.Columns.Contains("Amount") AndAlso dt.Rows(row)("Amount") IsNot DBNull.Value Then
        Dim amount As Decimal = Convert.ToDecimal(dt.Rows(row)("Amount"))
        Dim amountCell = sheet.GetCellAt(row + 1, 4)
        If amount < 100D Then
            amountCell.Style.SetBackgroundColor("#FFC000")
        End If
    End If
Next row

Dieses Muster ist modular erweiterbar – fügen Sie beliebig viele bedingte Prüfungen hinzu, je nach Ihren Berichtsanforderungen. Da IronXL zellenweise arbeitet, können Sie bedingte Formatierungen mit der Logik für abwechselnde Zeilenfarben kombinieren, indem Sie den bedingten Stil nach dem Basiszeilenstil anwenden.

Wie legt man Spaltenbreiten fest und fixiert die Kopfzeile?

Ein professionell formatierter Excel-Export beinhaltet angemessene Spaltenbreiten und eine fixierte Kopfzeile, sodass die Spaltennamen auch beim Scrollen durch große Datensätze sichtbar bleiben.

IronXL stellt die Spaltenbreite über den WorkSheet-Spalten-Accessor und das Einfrieren der Kopfzeilen über die FreezeRows-Methodee zur Verfügung:

// Auto-size columns 0 through the last column index
for (int col = 0; col < dt.Columns.Count; col++)
{
    // Set column width in character units (1 unit ≈ one default character width)
    sheet.SetColumnWidth(col, 20);
}

// Freeze the first row (index 0) so the header stays visible while scrolling
sheet.FreezeRows(1);

// Optionally set row height for the header (in points)
sheet.SetRowHeight(0, 20);

// Auto-size columns 0 through the last column index
for (int col = 0; col < dt.Columns.Count; col++)
{
    // Set column width in character units (1 unit ≈ one default character width)
    sheet.SetColumnWidth(col, 20);
}

// Freeze the first row (index 0) so the header stays visible while scrolling
sheet.FreezeRows(1);

// Optionally set row height for the header (in points)
sheet.SetRowHeight(0, 20);

' Auto-size columns 0 through the last column index
For col As Integer = 0 To dt.Columns.Count - 1
    ' Set column width in character units (1 unit ≈ one default character width)
    sheet.SetColumnWidth(col, 20)
Next

' Freeze the first row (index 0) so the header stays visible while scrolling
sheet.FreezeRows(1)

' Optionally set row height for the header (in points)
sheet.SetRowHeight(0, 20)

' Auto-size columns 0 through the last column index
For col As Integer = 0 To dt.Columns.Count - 1
    ' Set column width in character units (1 unit ≈ one default character width)
    sheet.SetColumnWidth(col, 20)
Next

' Freeze the first row (index 0) so the header stays visible while scrolling
sheet.FreezeRows(1)

' Optionally set row height for the header (in points)
sheet.SetRowHeight(0, 20)

Für den Produktiveinsatz empfiehlt es sich, die Breite anhand der maximalen Zeichenanzahl in jeder Spalte zu berechnen, anstatt einen festen Wert zu verwenden. Iterieren Sie die DataTable-Spaltenwerte, messen Sie die Stringlänge und multiplizieren Sie mit einem Zeichenbreitenfaktor, der für die gewählte Schriftgröße angemessen ist.

Sie können Excel-Zellen auch mithilfe von C# unabhängig von der Zeilenbandlogik eine Hintergrundfarbe zuweisen, um eine feinere Formatierung zu ermöglichen.

Wie exportiert man eine DataTable nach Excel ohne ein GridView-Steuerelement?

Viele .NET-Anwendungen befüllen Daten durch Serviceaufrufe oder Datenbankabfragen und halten sie in einem DataTable, ohne sie jemals an ein UI-Steuerelement zu binden. Sie können ein DataTable direkt nach Excel exportieren, ohne überhaupt ein GridView zu instanziieren.

Dies ist der effizienteste Weg für Hintergrundprozesse, geplante Berichte und API-Endpunkte, die Excel-Dateien auf dem Server erzeugen müssen:

using IronXL;
using IronXL.Styles;
using System.Data;

public static byte[] DataTableToExcelBytes(DataTable dt, string sheetName = "Report")
{
    WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
    WorkSheet sheet = workBook.CreateWorkSheet(sheetName);

    // Header
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
        var cell = sheet.GetCellAt(0, col);
        cell.Style.Font.Bold = true;
        cell.Style.SetBackgroundColor("#4472C4");
        cell.Style.Font.Color = "#FFFFFF";
    }

    // Data
    for (int row = 0; row < dt.Rows.Count; row++)
    {
        for (int col = 0; col < dt.Columns.Count; col++)
        {
            sheet.SetCellValue(row + 1, col, dt.Rows[row][col]?.ToString() ?? string.Empty);
        }
    }

    return workBook.ToByteArray();
}

using IronXL;
using IronXL.Styles;
using System.Data;

public static byte[] DataTableToExcelBytes(DataTable dt, string sheetName = "Report")
{
    WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
    WorkSheet sheet = workBook.CreateWorkSheet(sheetName);

    // Header
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
        var cell = sheet.GetCellAt(0, col);
        cell.Style.Font.Bold = true;
        cell.Style.SetBackgroundColor("#4472C4");
        cell.Style.Font.Color = "#FFFFFF";
    }

    // Data
    for (int row = 0; row < dt.Rows.Count; row++)
    {
        for (int col = 0; col < dt.Columns.Count; col++)
        {
            sheet.SetCellValue(row + 1, col, dt.Rows[row][col]?.ToString() ?? string.Empty);
        }
    }

    return workBook.ToByteArray();
}

Imports IronXL
Imports IronXL.Styles
Imports System.Data

Public Shared Function DataTableToExcelBytes(dt As DataTable, Optional sheetName As String = "Report") As Byte()
    Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
    Dim sheet As WorkSheet = workBook.CreateWorkSheet(sheetName)

    ' Header
    For col As Integer = 0 To dt.Columns.Count - 1
        sheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
        Dim cell = sheet.GetCellAt(0, col)
        cell.Style.Font.Bold = True
        cell.Style.SetBackgroundColor("#4472C4")
        cell.Style.Font.Color = "#FFFFFF"
    Next

    ' Data
    For row As Integer = 0 To dt.Rows.Count - 1
        For col As Integer = 0 To dt.Columns.Count - 1
            sheet.SetCellValue(row + 1, col, If(dt.Rows(row)(col)?.ToString(), String.Empty))
        Next
    Next

    Return workBook.ToByteArray()
End Function

Imports IronXL
Imports IronXL.Styles
Imports System.Data

Public Shared Function DataTableToExcelBytes(dt As DataTable, Optional sheetName As String = "Report") As Byte()
    Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
    Dim sheet As WorkSheet = workBook.CreateWorkSheet(sheetName)

    ' Header
    For col As Integer = 0 To dt.Columns.Count - 1
        sheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
        Dim cell = sheet.GetCellAt(0, col)
        cell.Style.Font.Bold = True
        cell.Style.SetBackgroundColor("#4472C4")
        cell.Style.Font.Color = "#FFFFFF"
    Next

    ' Data
    For row As Integer = 0 To dt.Rows.Count - 1
        For col As Integer = 0 To dt.Columns.Count - 1
            sheet.SetCellValue(row + 1, col, If(dt.Rows(row)(col)?.ToString(), String.Empty))
        Next
    Next

    Return workBook.ToByteArray()
End Function

Diese Methodee gibt einen byte[] zurück, den Sie auf die Festplatte schreiben, von einem API-Endpunkt streamen, an eine E-Mail anhängen oder im Speicher zwischenspeichern können. Verwandte Techniken finden Sie im Leitfaden zum Exportieren einer DataTable nach Excel und im Tutorial zur schnellsten Methodee zum Exportieren einer DataTable nach Excel .

Wie geht man mit großen Datensätzen und der Performance um?

Der Export von Zehntausenden von Zeilen nach Excel erfordert besondere Aufmerksamkeit bei der Speicherverwaltung. Das Erstellen eines neuen zellartigen Objekts für jede Zelle in einem großen Raster ist der häufigste Leistungsengpass. Verwenden Sie Stildefinitionen nach Möglichkeit wieder, indem Sie Stile für Bereichsobjekte anstatt für einzelne Zellen festlegen:

IronXL -Exportansätze nach Datensatzgröße
Datensatzgröße	Empfohlene Vorgehensweise	Wichtiger Aspekt
Bis zu 5.000 Zeilen	Zellweise Styling-Schleife	Einfacher Code, vernachlässigbarer Overhead
5.000 – 50.000 Zeilen	Anwendungsstil auf Bereichsebene	Reduziert die Objektzuweisungen erheblich
Mehr als 50.000 Zeilen	Direkter DataTable-Export, minimales Styling	Minimieren Sie die Operationen pro Zelle; nutzen Sie Streaming, falls verfügbar.

Für paginierte GridViews setzen Sie immer AllowPaging = false und binden Sie erneut, bevor Sie exportieren. Durch die Paginierung wird die Anzahl der sichtbaren Zeilen im Steuerelement begrenzt. Daher erfasst ein paginierter Export nur die aktuelle Seite und nicht den gesamten Datensatz – eine häufige Ursache für Fehler bei unvollständigen Exporten.

Sie können auch den Leitfaden auf Export einer Liste von Objekten nach Excel in C# überprüfen für Muster, die mit stark typisierten Sammlungen funktionieren, anstatt mit untypisierten DataTable-Zeilen.

Wie exportiert man ein GridView in ASP.NET Core oder Blazor?

ASP.NET Core- und Blazor-Anwendungen haben kein Web Forms-GridView-Steuerelement, aber die zugrunde liegende Herausforderung der Datenausgabe ist die gleiche: Nehmen Sie eine Sammlung von Objekten oder ein DataTable, erstellen Sie ein stilvolles Arbeitsbuch und liefern Sie eine Datei aus. Der Code zur Erstellung des Arbeitsbuchs ist identisch; Nur der Verabreichungsmechanismus ändert sich.

In einer Blazor Anwendung einen Dateidownload über JavaScript Interop auslösen:

// In a Blazor component or service
using IronXL;
using System.Data;
using Microsoft.JSInterop;

public async Task ExportToExcelAsync(DataTable dt, IJSRuntime js)
{
    WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
    WorkSheet sheet = workBook.DefaultWorkSheet;

    for (int col = 0; col < dt.Columns.Count; col++)
    {
        sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
        var cell = sheet.GetCellAt(0, col);
        cell.Style.Font.Bold = true;
        cell.Style.SetBackgroundColor("#4472C4");
        cell.Style.Font.Color = "#FFFFFF";
    }

    for (int row = 0; row < dt.Rows.Count; row++)
    {
        for (int col = 0; col < dt.Columns.Count; col++)
        {
            sheet.SetCellValue(row + 1, col, dt.Rows[row][col]?.ToString() ?? string.Empty);
        }
    }

    byte[] fileBytes = workBook.ToByteArray();
    string base64 = Convert.ToBase64String(fileBytes);
    await js.InvokeVoidAsync("downloadFileFromBase64", base64, "GridViewExport.xlsx",
        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
}

// In a Blazor component or service
using IronXL;
using System.Data;
using Microsoft.JSInterop;

public async Task ExportToExcelAsync(DataTable dt, IJSRuntime js)
{
    WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
    WorkSheet sheet = workBook.DefaultWorkSheet;

    for (int col = 0; col < dt.Columns.Count; col++)
    {
        sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
        var cell = sheet.GetCellAt(0, col);
        cell.Style.Font.Bold = true;
        cell.Style.SetBackgroundColor("#4472C4");
        cell.Style.Font.Color = "#FFFFFF";
    }

    for (int row = 0; row < dt.Rows.Count; row++)
    {
        for (int col = 0; col < dt.Columns.Count; col++)
        {
            sheet.SetCellValue(row + 1, col, dt.Rows[row][col]?.ToString() ?? string.Empty);
        }
    }

    byte[] fileBytes = workBook.ToByteArray();
    string base64 = Convert.ToBase64String(fileBytes);
    await js.InvokeVoidAsync("downloadFileFromBase64", base64, "GridViewExport.xlsx",
        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
}

Imports IronXL
Imports System.Data
Imports Microsoft.JSInterop

Public Async Function ExportToExcelAsync(dt As DataTable, js As IJSRuntime) As Task
    Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
    Dim sheet As WorkSheet = workBook.DefaultWorkSheet

    For col As Integer = 0 To dt.Columns.Count - 1
        sheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
        Dim cell = sheet.GetCellAt(0, col)
        cell.Style.Font.Bold = True
        cell.Style.SetBackgroundColor("#4472C4")
        cell.Style.Font.Color = "#FFFFFF"
    Next

    For row As Integer = 0 To dt.Rows.Count - 1
        For col As Integer = 0 To dt.Columns.Count - 1
            sheet.SetCellValue(row + 1, col, If(dt.Rows(row)(col)?.ToString(), String.Empty))
        Next
    Next

    Dim fileBytes As Byte() = workBook.ToByteArray()
    Dim base64 As String = Convert.ToBase64String(fileBytes)
    Await js.InvokeVoidAsync("downloadFileFromBase64", base64, "GridViewExport.xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
End Function

Imports IronXL
Imports System.Data
Imports Microsoft.JSInterop

Public Async Function ExportToExcelAsync(dt As DataTable, js As IJSRuntime) As Task
    Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
    Dim sheet As WorkSheet = workBook.DefaultWorkSheet

    For col As Integer = 0 To dt.Columns.Count - 1
        sheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
        Dim cell = sheet.GetCellAt(0, col)
        cell.Style.Font.Bold = True
        cell.Style.SetBackgroundColor("#4472C4")
        cell.Style.Font.Color = "#FFFFFF"
    Next

    For row As Integer = 0 To dt.Rows.Count - 1
        For col As Integer = 0 To dt.Columns.Count - 1
            sheet.SetCellValue(row + 1, col, If(dt.Rows(row)(col)?.ToString(), String.Empty))
        Next
    Next

    Dim fileBytes As Byte() = workBook.ToByteArray()
    Dim base64 As String = Convert.ToBase64String(fileBytes)
    Await js.InvokeVoidAsync("downloadFileFromBase64", base64, "GridViewExport.xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
End Function

Die vollständige Anleitung zum Blazor -Downloadmuster finden Sie im Tutorial "Blazor -Export nach Excel" . Für einen ASP.NET Core Controller-Ansatz siehe das ASP.NET Core -Export-Excel-Tutorial .

Schriftart- und Rahmenoptionen

IronXL bietet granulare Schriftart- und Randkontrollen durch das Style-Objekt für jede Zelle. Die vollständige Palette der Excel-Schriftstile in C# umfasst Fettdruck, Kursivschrift, Unterstreichung, Größe und Farbe. Die über BorderType verfügbaren Randtypen decken dünne, mittlere, dicke, gestrichelte, gepunktete, doppelte und mehrere Haarliniervarianten ab.

Für zusammengeführte Kopfzeilen oder Zusammenfassungsfußzeilen unterstützt IronXL auch das Zusammenführen von Zellen in Excel mit C# - nützlich, wenn Sie eine einzelne Titelzelle benötigen, die sich über mehrere Spalten oberhalb Ihrer Datentabelle erstreckt.

Informationen zum automatischen Anpassen der Spaltenbreiten nach dem Einfügen von Daten finden Sie im Leitfaden "Automatische Zellenanpassung in Excel mit C#" für die empfohlene Vorgehensweise.

Warum erzeugt eine native Excel-Bibliothek sauberere Exporte als HtmlTextWriter?

Die traditionelle ASP.NET-Exporttechnik – Überschreiben von VerifyRenderingInServerForm, Erstellen von StringWriter und HtmlTextWriter und Schreiben des gerenderten Steuerelements in die Antwort – erzeugt ein HTML-Dokument mit einer .xls-Erweiterung. Microsoft Excel öffnet solche Dateien mit einer Kompatibilitätswarnung, da die Datei nicht im Excel-Binär- oder OOXML-Format vorliegt. Die Stile sind auf Inline-CSS beschränkt, das Excel nur teilweise interpretiert. Bedingte Formatierung ist nicht möglich. Benutzer von Nicht-Windows-Plattformen oder von LibreOffice erhalten eine verminderte Ausgabe.

IronXL schreibt das Open XML Spreadsheet-Format (OOXML) direkt. Das Ergebnis ist eine richtige .xlsx-Datei – identisch mit dem, was Excel selbst erstellt – die in Excel, LibreOffice, Google Sheets und Numbers auf macOS ohne Warnungen geöffnet wird. Die Formatierung wird als Tabellenstile und nicht als HTML-Attribute kodiert, sodass sie auch bei wiederholtem Datenaustausch und plattformübergreifender Anzeige erhalten bleibt.

Vergleich der Exportmethoden für ASP.NET GridView
Methode	Dateiformat	Formatwarnungen	Vollständige Stilunterstützung	Büro erforderlich
HtmlTextWriter + StringWriter	HTML, das sich als XLS ausgibt	Ja	Nein	Nein
Office-Interop (COM)	Nativer XLS/XLSX	Nein	Ja	Ja
IronXL	Nativer XLSX/XLS	Nein	Ja	Nein

In der offiziellen Dokumentation von Microsoft zum Open XML SDK wird das zugrunde liegende Format erläutert, das IronXL erzeugt. Die von ECMA International gepflegte OOXML-Spezifikation definiert den Standard, der die anwendungsübergreifende Kompatibilität gewährleistet. Die Dokumentation zum ASP.NET GridView-Steuerelement auf Microsoft Docs beschreibt das Steuerelementmodell, aus dem die oben genannten Exportmuster lesen.

Was sind Ihre nächsten Schritte?

Sie verfügen nun über die notwendigen Muster, um GridView- und DataGridView-Daten mithilfe von IronXL in korrekt formatierte XLSX-Dateien zu exportieren – und zwar für die Bereitstellungsmodelle Windows Forms, ASP.NET Web Forms, ASP.NET Core und Blazor .

Um noch weiter zu gehen:

Starten Sie eine kostenlose Testversion von IronXL , um die vollständigen Formatierungs- und Exportfunktionen anhand Ihrer eigenen Daten zu testen.
Lesen Sie die IronXL -Dokumentation , um die vollständige API-Referenz einschließlich Pivot-Tabellen, Diagrammen und Datenvalidierung zu erhalten.
Erforschen Sie die Erstellung von Excel-Berichten in C# , um die oben genannten Exportmuster mit berechneten Zusammenfassungen und Diagrammen zu kombinieren.
Informationen zum ergänzenden Import-Workflow, wenn Ihre Anwendung auch hochgeladene Tabellenkalkulationen verarbeiten muss, finden Sie unter Lesen von Excel-Dateien in C#.
Für CSV-basierte Exporte neben XLSX siehe das Tutorial "C# Export nach CSV" .
Wenn Sie Daten aus einem DataGridView exportieren, bei dem die Spaltenüberschriften in der ersten Zeile stehen, lesen Sie bitte den entsprechenden Leitfaden "DataGridView zu Excel mit Spaltenüberschriften" .

Curtis Chau

Jetzt mit dem Ingenieurteam chatten

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 Handbücher.

...