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

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:

Install-Package IronXL
dotnet add package IronXL

Install-Package IronXL
dotnet add package IronXL

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

using IronXL;
using IronXl.Styles;

using IronXL;
using 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-Steuerelements. Das Exportmuster ist in beiden Fällen gleich: Werte aus Zeilen und Zellen extrahieren, eine IronXL Arbeitsmappe erstellen, Stile anwenden und dann das Ergebnis speichern oder streamen.

Der zuverlässigste Ansatz besteht darin, die DataSource-Eigenschaft des Steuerelements in eine DataTable-Eigenschaft umzuwandeln, 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);
}

WorkBook.Create initialisiert eine neue Arbeitsmappe im Arbeitsspeicher im XLSX-Format. DefaultWorkSheet gibt das erste Tabellenblatt zurück, das Sie vor dem Speichern über seine Eigenschaft Name umbenennen können. SetCellValue akzeptiert Zeichenketten, ganze Zahlen, Gleitkommazahlen und DateTime Werte -- IronXL wählt den richtigen Zelltyp automatisch aus.

Das abwechselnde Zeilenfarbmuster -- row % 2 == 0 wählt #D6DCE5 aus, andernfalls #FFFFFF -- spiegelt den in Excel integrierten Tabellenstil mit gestaffelten Zeilen wider. Sie können jede beliebige sechsstellige Hexadezimalfarbe verwenden, die zum Designsystem Ihrer Anwendung passt.

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

Webanwendungen benötigen einen anderen Bereitstellungsmechanismus. Anstatt direkt in das Dateisystem zu schreiben, serialisieren Sie die Arbeitsmappe in ein MemoryStream und schreiben sie mit den korrekten Headern in die HTTP-Antwort, damit der Browser sie als Dateidownload behandelt.

Wichtiger Vorbereitungsschritt für paginierte GridViews: Deaktivieren Sie die Paginierung (AllowPaging = false) und binden Sie die Datenquelle vor dem Export neu, damit jeder Datensatz – und 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();

Response.AddHeader mit content-disposition: attachment erzwingt einen Dateidownload-Dialog 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.

Bei ASP.NET Core Anwendungen ersetzen Sie Response.BinaryWrite durch File(fileBytes, contentType, fileName) in einer Controller-Aktion -- die Logik zur Erstellung der Arbeitsmappe ist identisch.

// 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");
        }
    }
}

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 Spaltenzugriff WorkSheet und die Kopfzeilenfixierung über die Methodee FreezeRows bereit:

// 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);

Für den Produktiveinsatz empfiehlt es sich, die Breite anhand der maximalen Zeichenanzahl in jeder Spalte zu berechnen, anstatt einen festen Wert zu verwenden. Iteriere die Werte der Spalte DataTable, messe die Zeichenkettenlänge und multipliziere sie mit einem Zeichenbreitenfaktor, der der gewählten Schriftgröße entspricht.

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 füllen Daten über Serviceaufrufe oder Datenbankabfragen und speichern sie in einem DataTable, ohne sie jemals an ein UI-Steuerelement zu binden. Sie können einen DataTable direkt nach Excel exportieren, ohne vorher ein GridView-Objekt 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();
}

Diese Methodee gibt ein byte[] zurück, das 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:

Bei paginierten GridViews muss vor dem Exportieren immer AllowPaging = false gesetzt und neu gebunden werden. 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 zum Exportieren einer Liste von Objekten nach Excel in C# einsehen, um Muster zu finden, die mit stark typisierten Sammlungen anstelle von untypisierten DataTable Zeilen funktionieren.

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

ASP.NET Core und Blazor Anwendungen verfügen nicht über ein Web Forms-Steuerelement, aber die zugrunde liegende Herausforderung beim Datenexport ist dieselbe: Man nimmt eine Sammlung von Objekten oder eine Liste, erstellt eine formatierte Arbeitsmappe und liefert eine Datei. Der Code zur Erstellung der Arbeitsmappe 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");
}

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 .

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

Die traditionelle ASP.NET -Exporttechnik – das Überschreiben von VerifyRenderingInServerForm, das Erstellen von StringWriter und HtmlTextWriter und das Schreiben des gerenderten Steuerelements in die Antwort – erzeugt ein HTML-Dokument mit der Erweiterung .xls. 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 korrekte .xlsx-Datei – identisch mit der von Excel selbst erstellten – die sich unter macOS in Excel, LibreOffice, Google Sheets und Numbers ohne Warnungen öffnen lässt. Die Formatierung wird als Tabellenstile und nicht als HTML-Attribute kodiert, sodass sie auch bei wiederholtem Datenaustausch und plattformübergreifender Anzeige erhalten bleibt.

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