Jak eksportować GridView do Excel z formatowaniem w C#

Jak zainstalować bibliotekę w projekcie .NET?

Przed napisaniem jakiegokolwiek kodu eksportującego zainstaluj IronXL z NuGet. Otwórz konsolę menedżera pakietów i uruchom:

Install-Package IronXL
dotnet add package IronXL

Install-Package IronXL
dotnet add package IronXL

IronXL obsługuje .NET 8, .NET 9 i .NET 10, a także .NET Framework 4.6.2 i nowsze wersje. Po instalacji dodaj następujące dyrektywy using do każdego pliku, który wykonuje operacje w programie Excel:

using IronXL;
using IronXl.Styles;

using IronXL;
using IronXl.Styles;

Imports IronXL
Imports IronXl.Styles

Nie jest wymagańe żadne dodatkowe środowisko uruchomieniowe ani integracja z pakietem Office. Biblioteka zapisuje natywne pliki binarne XLSX, które otwierają się poprawnie w programach Microsoft Excel, LibreOffice Calc i Google Sheets.

Jak wyeksportować DataGridView z Windows Forms do Excela z zachowaniem formatowania komórek?

Aplikacje Windows Forms używają kontrolki DataGridView zamiast internetowej GridView. Schemat eksportu jest taki sam w obu przypadkach: wyodrębnij wartości z wierszy i komórek, utwórz skoroszyt IronXL, zastosuj style, a następnie zapisz lub przesyłaj strumieniowo wynik.

Najbardziej niezawodnym podejściem jest rzutowanie właściwości DataSource kontrolki na DataTable, aby uniknąć iteracji wierszy wizualnych, które mogą być filtrowane lub paginowane:

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

WorkBook.Create inicjuje nowy skoroszyt w pamięci w formacie XLSX. DefaultWorkSheet zwraca pierwszy arkusz, którego nazwę można zmienić za pomocą właściwości Name przed zapisaniem. SetCellValue akceptuje ciągi znaków, liczby całkowite, liczby zmiennoprzecinkowe oraz wartości DateTime — IronXL automatycznie wybiera odpowiedni typ komórki.

Wzór naprzemiennych kolorów wierszy — row % 2 == 0 wybiera #D6DCE5, w przeciwnym razie #FFFFFF — odzwierciedla styl tabeli z paskami wbudowany w program Excel. Możesz zastąpić dowolnym sześcioznakowym kodem koloru hex, który pasuje do systemu projektowego Twojej aplikacji.

Jak wyeksportować widok siatki ASP.NET do programu Excel i przesłać plik do przeglądarki?

Aplikacje internetowe wymagają innego mechanizmu dostarczania. Zamiast zapisywać dane w systemie plików, serializujesz skoroszyt do MemoryStream i zapisujesz go w odpowiedzi HTTP z odpowiednimi nagłówkami, tak aby przeglądarka traktowała go jako plik do pobrania.

Ważny krok przed eksportem w przypadku paginowanych widoków GridView: wyłącz paginację (AllowPaging = false) i ponownie podłącz źródło danych przed eksportem, aby uchwycić każdy rekord — nie tylko bieżącą stronę.

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 = DirectCast(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 wraz z content-disposition: attachment wywołuje okno dialogowe pobierania pliku we wszystkich nowoczesnych przeglądarkach. Typ MIME application/vnd.openxmlformats-officedocument.spreadsheetml.sheet jest typem zarejestrowanym dla plików XLSX i zapobiega próbom wyświetlania zawartości binarnej w przeglądarce.

W przypadku aplikacji .NET Core należy zastąpić Response.BinaryWrite na File(fileBytes, contentType, fileName) w akcji kontrolera — logika tworzenia skoroszytu jest identyczna.

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

Jak ustawić szerokość kolumn i zablokować wiersz nagłówka?

Profesjonalnie sformatowany eksport do Excela zawiera odpowiednie szerokości kolumn i zablokowany wiersz nagłówka, dzięki czemu nazwy kolumn pozostają widoczne, gdy użytkownicy przewijają duże zbiory danych.

IronXL udostępnia szerokość kolumny poprzez akcesor kolumny WorkSheet oraz zamrożenie nagłówków poprzez metodę FreezeRows:

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

W przypadku zastosowań produkcyjnych warto rozważyć obliczenie szerokości na podstawie maksymalnej liczby znaków w każdej kolumnie zamiast stosowania stałej wartości. Przetwórz wartości kolumny DataTable, zmierz długość ciągu znaków i pomnóż ją przez współczynnik szerokości znaku odpowiedni dla wybranego rozmiaru czcionki.

Można również zastosować kolor tła do komórek programu Excel przy użyciu języka C# niezależnie od logiki pasmowania wierszy, co pozwala na bardziej precyzyjne stylizowanie.

Jak wyeksportować tabelę danych do programu Excel bez kontrolki GridView?

Wiele aplikacji .NET pobiera dane poprzez wywołania usług lub zapytania do baz danych i przechowuje je w DataTable bez wiązania ich z kontrolką interfejsu użytkownika. Możesz wyeksportować DataTable bezpośrednio do Excela bez konieczności instancjonowania GridView.

Jest to najbardziej wydajna ścieżka dla zadań w tle, zaplanowanych raportów i punktów końcowych API, które wymagają generowania plików Excel na serwerze:

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

Ta metoda zwraca byte[], który można zapisać na dysku, przesłać strumieniowo z punktu końcowego API, dołączyć do wiadomości e-mail lub zapisać w pamięci podręcznej. Aby zapoznać się z powiązanymi technikami, zobacz przewodnik dotyczący eksportowania tabeli danych (DataTable) do programu Excel oraz samouczek dotyczący najszybszego sposobu eksportowania tabeli danych (DataTable) do programu Excel.

Jak radzisz sobie z dużymi zbiorami danych i wydajnością?

Eksportowanie dziesiątek tysięcy wierszy do programu Excel wymaga zwrócenia uwagi na alokację pamięci. Tworzenie nowego obiektu typu komórka dla każdej komórki w dużej siatce jest najczęstszym wąskim gardłem wydajności. W miarę możliwości należy ponownie wykorzystywać definicje stylów, ustawiając style na obiektach zakresu zamiast na poszczególnych komórkach:

W przypadku paginowanych widoków GridView należy zawsze ustawić AllowPaging = false i ponownie powiązać przed eksportem. Paginacja ogranicza liczbę widocznych wierszy w kontrolce, więc eksport z paginacją przechwytuje tylko bieżącą stronę, a nie cały zbiór danych — co często jest przyczyną błędów związanych z niekompletnym eksportem.

Możesz również zapoznać się z przewodnikiem dotyczącym eksportowania listy obiektów do programu Excel w języku C#, aby znaleźć wzorce, które działają z kolekcjami silnie typowanymi, a nie z nietypowanymi wierszami DataTable.

Jak wyeksportować GridView w ASP.NET Core lub Blazor?

Aplikacje ASP.NET Core i Blazor nie posiadają kontrolki Web Forms GridView, ale podstawowe wyzwanie związane z eksportem danych jest takie samo: pobranie zbioru obiektów lub DataTable, utworzenie stylizowanego skoroszytu i dostarczenie pliku. Kod tworzenia skoroszytu jest identyczny; zmienia się jedynie mechanizm dostarczania.

W aplikacji Blazor uruchom pobieranie pliku za pomocą interoperacyjności JavaScript:

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

Pełny opis wzorca pobierania w Blazorze znajduje się w samouczku dotyczącym eksportu z Blazora do Excela. Aby zapoznać się z podejściem opartym na kontrolerze ASP.NET Core, zobacz samouczek dotyczący eksportu do programu Excel w ASP.NET Core.

Dłączego natywna biblioteka Excel generuje czystsze eksporty niż HtmlTextWriter?

Tradycyjna technika eksportu ASP.NET — nadpisywanie VerifyRenderingInServerForm, tworzenie StringWriter i HtmlTextWriter oraz zapisywanie wyrenderowanego kontrolki w odpowiedzi — generuje dokument HTML z rozszerzeniem .xls. Program Microsoft Excel otwiera takie pliki z ostrzeżeniem o kompatybilności, ponieważ plik nie jest w rzeczywistości w formacie binarnym Excel lub OOXML. Style są ograniczone do wbudowanego CSS, który Excel częściowo interpretuje. Formatowanie warunkówe jest niemożliwe. Użytkownicy korzystający z platform innych niż Windows lub z pakietu LibreOffice widzą pogorszoną jakość wyników.

IronXL zapisuje bezpośrednio w formacie Open XML Spreadsheet (OOXML). Wynikiem jest poprawny plik .xlsx — identyczny z tym, który tworzy sam program Excel — który otwiera się bez ostrzeżeń w programach Excel, LibreOffice, Arkusze Google i Numbers na systemie macOS. Formatowanie jest zakodowane jako style arkusza kalkulacyjnego, a nie atrybuty HTML, dzięki czemu zachowuje się podczas przesyłania i wyświetlania na różnych platformach.

Oficjalna dokumentacja Microsoftu dotycząca Open XML SDK wyjaśnia format, na którym opiera się IronXL. Specyfikacja OOXML utrzymywana przez ECMA International definiuje standard gwarantujący kompatybilność między aplikacjami. Dokumentacja kontrolki ASP.NET GridView w serwisie Microsoft Docs opisuje model kontrolki, z którego odczytują dane powyższe wzorce eksportu.

Jakie są Twoje kolejne kroki?

Dysponujesz teraz wzorcami niezbędnymi do eksportowania danych z GridView i DataGridView do poprawnie sformatowanych plików XLSX przy użyciu IronXL — obejmującymi modele dostarczania Windows Forms, ASP.NET Web Forms, ASP.NET Core i Blazor.

Więcej informacji:

• Rozpocznij bezpłatny okres próbny IronXL, aby przetestować pełne możliwości formatowania i eksportu na własnych danych.
• Zapoznaj się z dokumentacją IronXL, aby uzyskać pełny opis Dokumentacji API, w tym tabele przestawne, wykresy i walidację danych.
• Zapoznaj się z tworzeniem raportów Excel w języku C#, aby połączyć powyższe wzorce eksportu z obliczonymi podsumowaniami i wykresami.
• Zobacz odczytywanie plików Excel w języku C#, aby zapoznać się z uzupełniającym procesem importu, gdy aplikacja musi również wykorzystywać przesłane arkusze kalkulacyjne.
• Informacje na temat eksportu do formatu CSV oraz XLSX można znaleźć w samouczku dotyczącym eksportu do formatu CSV w języku C#.
• Jeśli eksportujesz dane z DataGridView z nagłówkami kolumn w pierwszym wierszu, zapoznaj się z dedykowanym przewodnikiem "DataGridView do Excela z nagłówkami kolumn".