Ikona wiadomości
Przejdź do treści stopki
  1. Iron Software
  2. Blog IronXL
  3. Korzystanie z IronXL
  4. Eksportuj Gridview do Excle Xlsx
KORZYSTANIE Z IRONXL

Jak eksportować GridView do Excel XLSX w C# używając IronXL

Jordi Bardia
Jordi Bardia
Zaktualizowano:

Eksportowanie danych z widoku siatki ASP.NET do pliku Excel

Można wyeksportować widok siatki ASP.NET GridView do pliku Excel XLSX w języku C# poprzez zainstalowanie biblioteki IronXL, utworzenie WorkBook, iterację po wierszach widoku siatki, zapisanie wartości każdej komórki w odpowiedniej pozycji arkusza oraz zapisanie skoroszytu na dysku lub w strumieniu odpowiedzi HTTP. To podejście nie wymaga instalacji pakietu Microsoft Office na serwerze i działa niezawodnie w aplikacjach internetowych opartych na platformach .NET Framework, .NET Core oraz .NET 5 do .NET 10.

Eksportowanie danych GridView do programu Excel jest standardowym wymaganiem w korporacyjnych projektach Enterprise ASP.NET Web Forms. Użytkownicy muszą przenosić dane tabelaryczne z przeglądarki do arkuszy kalkulacyjnych w celu tworzenia raportów, analizy offline i archiwizacji. Wyzwaniem jest wypełnienie luki między kontrolką po stronie serwera GridView a poprawnie ustrukturyzowanym plikiem .xlsx — bez wprowadzania zależności Office Interop, które nie działają w środowiskach serwerów internetowych.

Ten przewodnik przeprowadzi Cię przez trzy coraz bardziej rozbudowane wzorce eksportu: minimalny eksport wiersz po wierszu, eksport nagłówków i danych z automatycznym dopasowaniem rozmiaru kolumn oraz eksport oparty na DataTable, który całkowicie omija renderowany kod HTML. Każdy przykład wykorzystuje kod zgodny z instrukcjami najwyższego poziomu języka C# oraz interfejs API IronXL.

Jak zainstalować IronXL w projekcie ASP.NET?

Otwórz konsolę menedżera pakietów w Visual Studio i uruchom:

Install-Package IronXL
dotnet add package IronXL
Install-Package IronXL
dotnet add package IronXL
SHELL

Alternatywnie, kliknij prawym przyciskiem myszy projekt w Eksploratorze rozwiązań, wybierz opcję Zarządzaj pakietami NuGet, wyszukaj IronXL i kliknij Zainstaluj. NuGet automatycznie rozwiązuje wszystkie zależności przechodnie.

Po zainstalowaniu pakietu dodaj następujące dyrektywy using do pliku code-behind:

using System;
using System.Data;
using System.Web.UI;
using IronXL;
using System;
using System.Data;
using System.Web.UI;
using IronXL;
Imports System
Imports System.Data
Imports System.Web.UI
Imports IronXL
$vbLabelText   $csharpLabel

IronXL obsługuje .NET Framework 4.6.2 i nowsze wersje, a także .NET Core 3.1 oraz .NET 5 do .NET 10. Na serwerze nie jest wymagańa instalacja pakietu Office ani rejestracja COM. Pełna dokumentacja API jest dostępna w opisie obiektów IronXL.

Jakiego identyfikatora pakietu NuGet należy użyć?

Prawidłowy identyfikator pakietu to IronXL (a nie IronXl.Excel, który jest starszym aliasem). Po instalacji automatycznie odwołuje się do zestawu IronXL.dll. Możesz sprawdzić zainstalowaną wersję, przeglądając węzeł Pakiety w Eksploratorze rozwiązań lub uruchamiając dotnet list package z katalogu projektu.

Czy IronXL działa w aplikacjach internetowych ASP.NET Core?

Tak. To samo API działa zarówno w projektach ASP.NET Web Forms, jak i ASP.NET Core (MVC lub Razor Pages). W projektach Core należy zastąpić Server.MapPath na IWebHostEnvironment.WebRootPath lub Path.Combine(Directory.GetCurrentDirectory(), "Exports") podczas tworzenia ścieżek plików po stronie serwera.

Jak wyeksportować GridView do pliku Excel?

Najprostszy wzorzec eksportu iteruje przez każdy wyrenderowany wiersz w GridView i kopiuje tekst każdej komórki do odpowiedniej komórki arkusza Excel. W kodzie ASPX dodaj kontrolkę <asp:GridView ID="gvEmployees" runat="server" AutoGenerateColumns="true" /> oraz przycisk <asp:Button ID="btnExport" runat="server" Text="Export to Excel" OnClick="btnExport_Click" />. Atrybut runat="server" sprawia, że oba kontrolki są dostępne w kodzie źródłowym.

Kod źródłowy wiąże przykładowe dane przy pierwszym załadowaniu i eksportuje je po kliknięciu przycisku:

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

public partial class GridViewExport : Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        if (!IsPostBack)
        {
            BindGridView();
        }
    }

    private void BindGridView()
    {
        DataTable dt = new DataTable();
        dt.Columns.Add("EmployeeID", typeof(int));
        dt.Columns.Add("Name", typeof(string));
        dt.Columns.Add("Department", typeof(string));
        dt.Columns.Add("Salary", typeof(decimal));

        dt.Rows.Add(1, "John Smith", "Engineering", 75000);
        dt.Rows.Add(2, "Sarah Johnson", "Marketing", 65000);
        dt.Rows.Add(3, "Michael Chen", "Finance", 70000);

        ViewState["EmployeeData"] = dt;
        gvEmployees.DataSource = dt;
        gvEmployees.DataBind();
    }

    protected void btnExport_Click(object sender, EventArgs e)
    {
        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet worksheet = workbook.CreateWorkSheet("Employees");

        // Write header row
        for (int j = 0; j < gvEmployees.HeaderRow.Cells.Count; j++)
        {
            worksheet.SetCellValue(0, j, gvEmployees.HeaderRow.Cells[j].Text);
        }

        // Write data rows
        for (int i = 0; i < gvEmployees.Rows.Count; i++)
        {
            for (int j = 0; j < gvEmployees.Rows[i].Cells.Count; j++)
            {
                worksheet.SetCellValue(i + 1, j, gvEmployees.Rows[i].Cells[j].Text);
            }
        }

        string filePath = Server.MapPath("~/Exports/EmployeeData.xlsx");
        workbook.SaveAs(filePath);
    }
}
using System;
using System.Data;
using System.Web.UI;
using IronXL;

public partial class GridViewExport : Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        if (!IsPostBack)
        {
            BindGridView();
        }
    }

    private void BindGridView()
    {
        DataTable dt = new DataTable();
        dt.Columns.Add("EmployeeID", typeof(int));
        dt.Columns.Add("Name", typeof(string));
        dt.Columns.Add("Department", typeof(string));
        dt.Columns.Add("Salary", typeof(decimal));

        dt.Rows.Add(1, "John Smith", "Engineering", 75000);
        dt.Rows.Add(2, "Sarah Johnson", "Marketing", 65000);
        dt.Rows.Add(3, "Michael Chen", "Finance", 70000);

        ViewState["EmployeeData"] = dt;
        gvEmployees.DataSource = dt;
        gvEmployees.DataBind();
    }

    protected void btnExport_Click(object sender, EventArgs e)
    {
        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet worksheet = workbook.CreateWorkSheet("Employees");

        // Write header row
        for (int j = 0; j < gvEmployees.HeaderRow.Cells.Count; j++)
        {
            worksheet.SetCellValue(0, j, gvEmployees.HeaderRow.Cells[j].Text);
        }

        // Write data rows
        for (int i = 0; i < gvEmployees.Rows.Count; i++)
        {
            for (int j = 0; j < gvEmployees.Rows[i].Cells.Count; j++)
            {
                worksheet.SetCellValue(i + 1, j, gvEmployees.Rows[i].Cells[j].Text);
            }
        }

        string filePath = Server.MapPath("~/Exports/EmployeeData.xlsx");
        workbook.SaveAs(filePath);
    }
}
Imports System
Imports System.Data
Imports System.Web.UI
Imports IronXL

Public Partial Class GridViewExport
    Inherits Page

    Protected Sub Page_Load(sender As Object, e As EventArgs)
        If Not IsPostBack Then
            BindGridView()
        End If
    End Sub

    Private Sub BindGridView()
        Dim dt As New DataTable()
        dt.Columns.Add("EmployeeID", GetType(Integer))
        dt.Columns.Add("Name", GetType(String))
        dt.Columns.Add("Department", GetType(String))
        dt.Columns.Add("Salary", GetType(Decimal))

        dt.Rows.Add(1, "John Smith", "Engineering", 75000)
        dt.Rows.Add(2, "Sarah Johnson", "Marketing", 65000)
        dt.Rows.Add(3, "Michael Chen", "Finance", 70000)

        ViewState("EmployeeData") = dt
        gvEmployees.DataSource = dt
        gvEmployees.DataBind()
    End Sub

    Protected Sub btnExport_Click(sender As Object, e As EventArgs)
        Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
        Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Employees")

        ' Write header row
        For j As Integer = 0 To gvEmployees.HeaderRow.Cells.Count - 1
            worksheet.SetCellValue(0, j, gvEmployees.HeaderRow.Cells(j).Text)
        Next

        ' Write data rows
        For i As Integer = 0 To gvEmployees.Rows.Count - 1
            For j As Integer = 0 To gvEmployees.Rows(i).Cells.Count - 1
                worksheet.SetCellValue(i + 1, j, gvEmployees.Rows(i).Cells(j).Text)
            Next
        Next

        Dim filePath As String = Server.MapPath("~/Exports/EmployeeData.xlsx")
        workbook.SaveAs(filePath)
    End Sub
End Class
$vbLabelText   $csharpLabel

Wywołanie WorkBook.Create(ExcelFileFormat.XLSX) inicjuje skoroszyt w pamięci, dostosowany do nowoczesnego formatu Open XML. CreateWorkSheet("Employees") dodaje pierwszy arkusz. Pętla zewnętrzna (i) przechodzi przez wiersze danych; pętla wewnętrzna (j) przechodzi przez kolumny. Indeks wiersza i + 1 jest używany dla komórek danych, aby nagłówek w wierszu 0 nie został nadpisany.

Dłączego warto używać IronXL zamiast Excel Interop?

Excel Interop wymaga zainstalowania na serwerze licencjonowanej kopii programu Microsoft Excel i tworzy obiekty COM, które należy wyraźnie zwolnić, aby uniknąć wycieków pamięci. IronXL odczytuje i zapisuje pliki .xlsx bezpośrednio jako pakiety Open XML — bez COM, bez Office, bez Marshal.ReleaseComObject szablonów. Dzięki temu jest niezawodny w środowiskach IIS, Azure App Service, Docker i innych środowiskach serwerowych, w których pakiet Office jest niedostępny.

Jaki jest prawidłowy typ MIME dla plików XLSX do pobrania?

Jeśli chcesz, aby przeglądarka wyświetliła okno dialogowe zapisu pliku zamiast wysyłać bajty bezpośrednio, ustaw typ zawartości odpowiedzi na application/vnd.openxmlformats-officedocument.spreadsheetml.sheet i dodaj nagłówek Content-Disposition: attachment przed zapisaniem bajtów skoroszytu do strumienia odpowiedzi.

Jak dodać nagłówki kolumn i automatycznie dostosować ich rozmiar?

W podstawowym przykładzie zapisywane są nagłówki wyodrębnione z HeaderRow.Cells, ale eksport do środowiska produkcyjnego powinien również automatycznie dostosowywać rozmiar każdej kolumny, tak aby dane były czytelne bez konieczności ręcznego dostosowywania w programie Excel:

protected void btnExport_Click(object sender, EventArgs e)
{
    WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
    WorkSheet worksheet = workbook.CreateWorkSheet("Employees");

    // Write column headers
    int colCount = gvEmployees.HeaderRow.Cells.Count;
    for (int i = 0; i < colCount; i++)
    {
        string header = gvEmployees.HeaderRow.Cells[i].Text;
        worksheet.SetCellValue(0, i, header);
    }

    // Write data rows
    for (int i = 0; i < gvEmployees.Rows.Count; i++)
    {
        for (int j = 0; j < gvEmployees.Rows[i].Cells.Count; j++)
        {
            worksheet.SetCellValue(i + 1, j, gvEmployees.Rows[i].Cells[j].Text);
        }
    }

    // Auto-size each column for readability
    for (int col = 0; col < colCount; col++)
    {
        worksheet.AutoSizeColumn(col);
    }

    string filePath = Server.MapPath("~/Exports/EmployeeReport.xlsx");
    workbook.SaveAs(filePath);
}
protected void btnExport_Click(object sender, EventArgs e)
{
    WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
    WorkSheet worksheet = workbook.CreateWorkSheet("Employees");

    // Write column headers
    int colCount = gvEmployees.HeaderRow.Cells.Count;
    for (int i = 0; i < colCount; i++)
    {
        string header = gvEmployees.HeaderRow.Cells[i].Text;
        worksheet.SetCellValue(0, i, header);
    }

    // Write data rows
    for (int i = 0; i < gvEmployees.Rows.Count; i++)
    {
        for (int j = 0; j < gvEmployees.Rows[i].Cells.Count; j++)
        {
            worksheet.SetCellValue(i + 1, j, gvEmployees.Rows[i].Cells[j].Text);
        }
    }

    // Auto-size each column for readability
    for (int col = 0; col < colCount; col++)
    {
        worksheet.AutoSizeColumn(col);
    }

    string filePath = Server.MapPath("~/Exports/EmployeeReport.xlsx");
    workbook.SaveAs(filePath);
}
Protected Sub btnExport_Click(sender As Object, e As EventArgs)
    Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
    Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Employees")

    ' Write column headers
    Dim colCount As Integer = gvEmployees.HeaderRow.Cells.Count
    For i As Integer = 0 To colCount - 1
        Dim header As String = gvEmployees.HeaderRow.Cells(i).Text
        worksheet.SetCellValue(0, i, header)
    Next

    ' Write data rows
    For i As Integer = 0 To gvEmployees.Rows.Count - 1
        For j As Integer = 0 To gvEmployees.Rows(i).Cells.Count - 1
            worksheet.SetCellValue(i + 1, j, gvEmployees.Rows(i).Cells(j).Text)
        Next
    Next

    ' Auto-size each column for readability
    For col As Integer = 0 To colCount - 1
        worksheet.AutoSizeColumn(col)
    Next

    Dim filePath As String = Server.MapPath("~/Exports/EmployeeReport.xlsx")
    workbook.SaveAs(filePath)
End Sub
$vbLabelText   $csharpLabel

AutoSizeColumn(col) nakazuje IronXL obliczenie optymalnej szerokości kolumny na podstawie długości zawartości komórki, odzwierciedlając działanie Format > Dopasuj szerokość kolumny w aplikacji Excel na komputery stacjonarne. Wywołanie funkcji w pętli po zapisaniu wszystkich danych jest bardziej wydajne niż wywoływanie jej po każdym wierszu, ponieważ w tym momencie znana jest już ostateczna zawartość.

Aby uzyskać dodatkowe opcje stylizacji — pogrubione nagłówki, kolory tła, formaty liczb — zapoznaj się z samouczkiem dotyczącym stylizacji komórek w IronXL. Można również łączyć komórki, aby tworzyć tytuły raportów obejmujące wiele kolumn.

Jak zastosować pogrubienie w komórkach nagłówkowych?

Użyj obiektu IStyle zwracanego przez worksheet["A1"].Style (lub zakres). Ustaw Font.Bold = true przed lub po wpisaniu wartości — styl jest oddzielony od zawartości komórki:

// Bold the entire header row (columns A through D)
var headerRange = worksheet["A1:D1"];
headerRange.Style.Font.Bold = true;
headerRange.Style.BackgroundColor = "#4472C4";
headerRange.Style.Font.FontColor = "#FFFFFF";
// Bold the entire header row (columns A through D)
var headerRange = worksheet["A1:D1"];
headerRange.Style.Font.Bold = true;
headerRange.Style.BackgroundColor = "#4472C4";
headerRange.Style.Font.FontColor = "#FFFFFF";
' Bold the entire header row (columns A through D)
Dim headerRange = worksheet("A1:D1")
headerRange.Style.Font.Bold = True
headerRange.Style.BackgroundColor = "#4472C4"
headerRange.Style.Font.FontColor = "#FFFFFF"
$vbLabelText   $csharpLabel

Ten wzorzec ma zastosowanie do zakresów o dowolnej wielkości. Pełna lista właściwości stylów znajduje się w Dokumentacji API stylów IronXL.

Jak wyeksportować dane bezpośrednio z tabeli DataTable?

Iteracja nad wyrenderowanymi wierszami GridView wiąże eksport z aktualnym stanem wizualnym kontrolki, na który mogą wpływać ustawienia stronicowania, sortowania i widoczności kolumn. Eksportowanie z bazowego DataTable przechowywanego w ViewState daje deterministyczny wynik niezależnie od konfiguracji siatki:

protected void btnExport_Click(object sender, EventArgs e)
{
    DataTable sourceData = ViewState["EmployeeData"] as DataTable;
    if (sourceData == null)
    {
        Response.Write("No data available to export.");
        return;
    }

    WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
    WorkSheet worksheet = workbook.CreateWorkSheet("Report");

    // Column headers from DataTable schema
    for (int i = 0; i < sourceData.Columns.Count; i++)
    {
        worksheet.SetCellValue(0, i, sourceData.Columns[i].ColumnName);
    }

    // Data rows from DataRow objects
    for (int i = 0; i < sourceData.Rows.Count; i++)
    {
        for (int j = 0; j < sourceData.Columns.Count; j++)
        {
            worksheet.SetCellValue(i + 1, j, sourceData.Rows[i][j].ToString());
        }
    }

    string filePath = Server.MapPath("~/Exports/DataExport.xlsx");
    workbook.SaveAs(filePath);
}
protected void btnExport_Click(object sender, EventArgs e)
{
    DataTable sourceData = ViewState["EmployeeData"] as DataTable;
    if (sourceData == null)
    {
        Response.Write("No data available to export.");
        return;
    }

    WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
    WorkSheet worksheet = workbook.CreateWorkSheet("Report");

    // Column headers from DataTable schema
    for (int i = 0; i < sourceData.Columns.Count; i++)
    {
        worksheet.SetCellValue(0, i, sourceData.Columns[i].ColumnName);
    }

    // Data rows from DataRow objects
    for (int i = 0; i < sourceData.Rows.Count; i++)
    {
        for (int j = 0; j < sourceData.Columns.Count; j++)
        {
            worksheet.SetCellValue(i + 1, j, sourceData.Rows[i][j].ToString());
        }
    }

    string filePath = Server.MapPath("~/Exports/DataExport.xlsx");
    workbook.SaveAs(filePath);
}
Protected Sub btnExport_Click(sender As Object, e As EventArgs)
    Dim sourceData As DataTable = TryCast(ViewState("EmployeeData"), DataTable)
    If sourceData Is Nothing Then
        Response.Write("No data available to export.")
        Return
    End If

    Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
    Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Report")

    ' Column headers from DataTable schema
    For i As Integer = 0 To sourceData.Columns.Count - 1
        worksheet.SetCellValue(0, i, sourceData.Columns(i).ColumnName)
    Next

    ' Data rows from DataRow objects
    For i As Integer = 0 To sourceData.Rows.Count - 1
        For j As Integer = 0 To sourceData.Columns.Count - 1
            worksheet.SetCellValue(i + 1, j, sourceData.Rows(i)(j).ToString())
        Next
    Next

    Dim filePath As String = Server.MapPath("~/Exports/DataExport.xlsx")
    workbook.SaveAs(filePath)
End Sub
$vbLabelText   $csharpLabel

Nazwy kolumn pochodzą z DataTable.Columns[i].ColumnName, co odzwierciedla oryginalny schemat danych, a nie nadpisania nazw wyświetlanych zastosowane w szablonie GridView. Wartości komórek są pobierane z obiektów DataRow przy użyciu indeksu kolumny, a każda wartość jest rzutowana na string, aby spełnić wymagania SetCellValue.

Ten wzorzec jest szczególnie przydatny, gdy GridView używa stronicowania — iteracja gvEmployees.Rows zwraca tylko wiersze z aktualnie widocznej strony, podczas gdy odczyt z pełnego DataTable eksportuje każdy rekord.

Co się dzieje w przypadku eksportu dużych tabel danych?

IronXL zapewnia wydajny strumieniowy transfer danych z skoroszytów w przypadku dużych zbiorów danych Excel. W przypadku eksportów przekraczających 100 000 wierszy należy rozważyć grupowanie wywołań SetCellValue w ramach jednej operacji arkusza, zamiast ustawiania poszczególnych komórek w pętli zagnieżdżonej. Można również zapisać skoroszyt do MemoryStream i stopniowo wysyłać go do strumienia Response, aby uniknąć przechowywania całego pliku w pamięci RAM serwera.

Jak radzisz sobie z błędami podczas eksportu?

Moduły obsługi eksportu produkcyjnego powinny zawrzeć operacje IronXL w bloku catch i zwrócić użytkownikowi komunikat opisujący sytuację, gdy coś pójdzie nie tak. Typowe błędy to brak katalogu ~/Exports/, błędy uprawnień do plików oraz wartość ViewState równa null po upływie limitu czasu sesji:

protected void btnExport_Click(object sender, EventArgs e)
{
    try
    {
        DataTable sourceData = ViewState["EmployeeData"] as DataTable;
        if (sourceData == null)
            throw new InvalidOperationException("Session data has expired. Please reload the page.");

        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet worksheet = workbook.CreateWorkSheet("Employees");

        for (int i = 0; i < sourceData.Columns.Count; i++)
            worksheet.SetCellValue(0, i, sourceData.Columns[i].ColumnName);

        for (int i = 0; i < sourceData.Rows.Count; i++)
            for (int j = 0; j < sourceData.Columns.Count; j++)
                worksheet.SetCellValue(i + 1, j, sourceData.Rows[i][j].ToString());

        string filePath = Server.MapPath("~/Exports/SafeExport.xlsx");
        workbook.SaveAs(filePath);

        lblStatus.Text = "Export successful. File saved to server.";
    }
    catch (Exception ex)
    {
        lblStatus.Text = $"Export failed: {ex.Message}";
    }
}
protected void btnExport_Click(object sender, EventArgs e)
{
    try
    {
        DataTable sourceData = ViewState["EmployeeData"] as DataTable;
        if (sourceData == null)
            throw new InvalidOperationException("Session data has expired. Please reload the page.");

        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet worksheet = workbook.CreateWorkSheet("Employees");

        for (int i = 0; i < sourceData.Columns.Count; i++)
            worksheet.SetCellValue(0, i, sourceData.Columns[i].ColumnName);

        for (int i = 0; i < sourceData.Rows.Count; i++)
            for (int j = 0; j < sourceData.Columns.Count; j++)
                worksheet.SetCellValue(i + 1, j, sourceData.Rows[i][j].ToString());

        string filePath = Server.MapPath("~/Exports/SafeExport.xlsx");
        workbook.SaveAs(filePath);

        lblStatus.Text = "Export successful. File saved to server.";
    }
    catch (Exception ex)
    {
        lblStatus.Text = $"Export failed: {ex.Message}";
    }
}
Protected Sub btnExport_Click(sender As Object, e As EventArgs)
    Try
        Dim sourceData As DataTable = TryCast(ViewState("EmployeeData"), DataTable)
        If sourceData Is Nothing Then
            Throw New InvalidOperationException("Session data has expired. Please reload the page.")
        End If

        Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
        Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Employees")

        For i As Integer = 0 To sourceData.Columns.Count - 1
            worksheet.SetCellValue(0, i, sourceData.Columns(i).ColumnName)
        Next

        For i As Integer = 0 To sourceData.Rows.Count - 1
            For j As Integer = 0 To sourceData.Columns.Count - 1
                worksheet.SetCellValue(i + 1, j, sourceData.Rows(i)(j).ToString())
            Next
        Next

        Dim filePath As String = Server.MapPath("~/Exports/SafeExport.xlsx")
        workbook.SaveAs(filePath)

        lblStatus.Text = "Export successful. File saved to server."
    Catch ex As Exception
        lblStatus.Text = $"Export failed: {ex.Message}"
    End Try
End Sub
$vbLabelText   $csharpLabel

W przypadku aplikacji internetowych, które dostarczają plik jako bezpośrednie pobranie w przeglądarce zamiast zapisywania go na dysku, należy użyć Response.BinaryWrite lub zapisać do Response.OutputStream po ustawieniu nagłówków content-type i disposition. Upewnij się, że katalog ~/Exports/ istnieje, a tożsamość puli aplikacji IIS ma do niego uprawnienia do zapisu.

Jak wysłać plik XLSX do pobrania w przeglądarce?

Zastąp workbook.SaveAs(filePath) odpowiedzią opartą na strumieniu:

using System.IO;

// ... inside btnExport_Click after populating the worksheet ...

byte[] fileBytes;
using (MemoryStream ms = new MemoryStream())
{
    workbook.SaveAs(ms);
    fileBytes = ms.ToArray();
}

Response.Clear();
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
Response.AddHeader("Content-Disposition", "attachment; filename=EmployeeData.xlsx");
Response.BinaryWrite(fileBytes);
Response.End();
using System.IO;

// ... inside btnExport_Click after populating the worksheet ...

byte[] fileBytes;
using (MemoryStream ms = new MemoryStream())
{
    workbook.SaveAs(ms);
    fileBytes = ms.ToArray();
}

Response.Clear();
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
Response.AddHeader("Content-Disposition", "attachment; filename=EmployeeData.xlsx");
Response.BinaryWrite(fileBytes);
Response.End();
Imports System.IO

' ... inside btnExport_Click after populating the worksheet ...

Dim fileBytes As Byte()
Using ms As New MemoryStream()
    workbook.SaveAs(ms)
    fileBytes = ms.ToArray()
End Using

Response.Clear()
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
Response.AddHeader("Content-Disposition", "attachment; filename=EmployeeData.xlsx")
Response.BinaryWrite(fileBytes)
Response.End()
$vbLabelText   $csharpLabel

Ten wzorzec pozwala uniknąć zapisywania pliku tymczasowego na dysku. MemoryStream jest przydzielany na serwerze, serializowany do byte[] i wysyłany bezpośrednio do klienta. Wywołanie Response.End() opróżnia odpowiedź i zapobiega dołączaniu dodatkowych znaczników strony po danych binarnych.

Jak wyeksportować wiele arkuszy lub zaawansowanych skoroszytów?

Pojedynczy WorkBook może zawierać wiele arkuszy, co jest przydatne, gdy trzeba wyeksportować kilka widoków GridView — lub ten sam zestaw danych o różnej szczegółowości — do jednego pliku. Wywołaj workbook.CreateWorkSheet(name) raz dla każdej karty:

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);

WorkSheet summary = workbook.CreateWorkSheet("Summary");
WorkSheet detail  = workbook.CreateWorkSheet("Detail");

// Populate summary sheet ...
// Populate detail sheet ...

workbook.SaveAs(Server.MapPath("~/Exports/FullReport.xlsx"));
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);

WorkSheet summary = workbook.CreateWorkSheet("Summary");
WorkSheet detail  = workbook.CreateWorkSheet("Detail");

// Populate summary sheet ...
// Populate detail sheet ...

workbook.SaveAs(Server.MapPath("~/Exports/FullReport.xlsx"));
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)

Dim summary As WorkSheet = workbook.CreateWorkSheet("Summary")
Dim detail As WorkSheet = workbook.CreateWorkSheet("Detail")

' Populate summary sheet ...
' Populate detail sheet ...

workbook.SaveAs(Server.MapPath("~/Exports/FullReport.xlsx"))
$vbLabelText   $csharpLabel

IronXL obsługuje również odczyt istniejących plików Excel, dzięki czemu można załadować gotowy szablon z brandingiem i formatowaniem, wstawić dane do określonych komórek i zapisać wynik — zachowując wykresy, obrazy i style już zawarte w szablonie.

Aby uzyskać jeszcze bogatszy wynik, IronXL zapewnia obsługę formuł Excel, formatowanie warunkówe, tworzenie wykresów i osadzanie obrazów. Funkcje te zostały opisane w sekcji samouczków IronXL.

Jak IronXL wypada w porównaniu z EPPlus i ClosedXML?

Funkcja IronXL EPPlus ClosedXML
Wymagana instalacja pakietu Office Nie Nie Nie
Odczyt i zapis plików XLSX Tak Tak Tak
Obsługa plików XLS (starsza wersja) Tak Nie Nie
Eksport do plików CSV / TSV Tak Nie Częściowe
API do tworzenia wykresów Tak Tak Ograniczone
Model licencji Licencja wieczysta + SaaS Polyform niekomercyjne MIT
Obsługa .NET 10 Tak Tak Tak

W wersji 5 EPPlus przeszedł na licencję komercyjną, co sprawiło, że IronXL stał się naturalną alternatywą dla zespołów, które już zainwestowały w ekosystem komercyjnych bibliotek .NET. ClosedXML pozostaje na licencji MIT, ale ma ograniczoną obsługę wykresów. Właściwy wybór zależy od ograniczeń licencyjnych projektu, potrzebnych funkcji programu Excel oraz tego, czy wymagańa jest obsługa starszego formatu .xls.

Jakie formaty Excel obsługuje IronXL?

IronXL odczytuje i zapisuje formaty .xlsx (Office Open XML), .xls (starszy BIFF8), .csv oraz .tsv. Możesz konwertować formaty plików Excel za pomocą jednego wywołania API, zmieniając wartość wyliczeniową ExcelFileFormat przekazaną do WorkBook.Create lub ładując istniejący plik i zapisując go w innym formacie.

Jakie są Twoje kolejne kroki?

Masz teraz trzy gotowe do użycia wzorce eksportowania danych z ASP.NET GridView do plików Excel XLSX przy użyciu IronXL:

  • Eksport iteracji wierszy — najszybsza droga do działającego eksportu z powiązanego GridView
  • Eksport nagłówków i formatowania — dodaje automatyczne dopasowywanie rozmiaru kolumn i pogrubione nagłówki, aby raporty wyglądały profesjonalnie
  • Eksport oparty na DataTable — całkowicie omija renderowany element sterujący w przypadku siatek stronicowanych lub filtrowanych

Kolejne logiczne kroki to:

  1. Dodaj odpowiedź pobierania w przeglądarce przy użyciu MemoryStream i Response.BinaryWrite, aby użytkownicy otrzymywali plik natychmiast, bez ścieżki zapisu po stronie serwera.
  2. Zastosuj stylizację komórek — pogrubione nagłówki, wypełnienie kolorem tła i formaty liczb — przy użyciu interfejsu API formatowania IronXL.
  3. Zapoznaj się z skoroszytami wielarkuszowymi, aby połączyć dane podsumowujące i szczegółowe w jednym pliku dostarczanym interesariuszom.
  4. Wczytaj pliki Excel z powrotem do obiektów DataTable, korzystając z interfejsu API odczytu IronXL do przepływów pracy importu/eksportu w obie strony.
  5. Rozpocznij bezpłatny okres próbny na stronie ironsoftware.com/csharp/excel/, aby przetestować wszystkie funkcje w swoim projekcie dzięki bezpłatnej licencji próbnej z pełnym zakresem możliwości.

Dla zespołów tworzących procesy generowania dokumentów, IronPDF integruje się z IronXL, umożliwiając eksport arkuszy kalkulacyjnych bezpośrednio do formatu PDF. Pakiet Iron Suite łączy IronXL z IronPDF, IronOCR, IronBarcode i IronZIP w obniżonej cenie łącznej.

Często Zadawane Pytania

Jaki jest główny cel użycia IronXL do eksportowania GridView do Excela?

IronXL służy przede wszystkim do ułatwiania eksportu danych z widoku siatki ASP.NET GridView do formatów Excel, takich jak XLSX, zapewniając wysoką wydajność i łatwość integracji z aplikacjami C#.

Czy IronXL radzi sobie z dużymi zbiorami danych podczas eksportu z GridView?

Tak, IronXL jest zoptymalizowany pod kątem wydajnej obsługi dużych zbiorów danych podczas procesu eksportu z GridView do Excela, zachowując szybkość i wydajność.

Czy podczas korzystania z IronXL można dostosować wynik w formacie Excel?

Dzięki IronXL możesz dostosować różne aspekty pliku wyjściowego Excel, takie jak formatowanie, stylizację oraz dodawanie dodatkowych danych lub formuł do eksportowanego pliku.

Jak biblioteka IronXL wypada na tle innych bibliotek służących do eksportowania GridView do Excela?

Biblioteka IronXL oferuje bardziej bezpośrednie i elastyczne podejście w porównaniu z niektórymi innymi bibliotekami, zapewniając obsługę nowoczesnych formatów Excel oraz bezpośrednią integrację z aplikacjami C#.

Czy IronXL obsługuje eksport do formatów innych niż XLSX?

Tak, IronXL obsługuje eksport do różnych formatów Excel, w tym XLS, CSV i TSV, zapewniając wszechstronność dostosowaną do różnych wymagań projektowych.

Jakie są warunki korzystania z IronXL w projekcie?

Aby korzystać z IronXL, potrzebne jest środowisko .NET. IronXL można zainstalować za pośrednictwem NuGet w projekcie C#.

Czy IronXL może eksportować dane GridView asynchronicznie?

IronXL obsługuje operacje asynchroniczne, umożliwiając programistom eksportowanie danych GridView do plików Excel bez blokowania głównego wątku aplikacji.

Jak zacząć korzystać z IronXL do eksportowania GridView do Excela?

Aby rozpocząć, zapoznaj się z dokumentacją i przykładami IronXL, które zawierają szczegółowe instrukcje dotyczące konfiguracji i wykonywania eksportu danych z GridView do Excela.

Jordi Bardia
Jordi Bardia
  Czat z zespołem inżynierów teraz
Inżynier oprogramowania
Jordi jest najbardziej biegły w Pythonie, C# i C++. Kiedy nie wykorzystuje swoich umiejętności w Iron Software, programuje gry. Dzieląc odpowiedzialność za testowanie produktów, rozwój produktów i badania, Jordi wnosi ogromną wartość do ciągłej poprawy produktów. Różnorodne doświadczenia ...
Czytaj więcej

Powiązane artykuły

30-dniowy okres próbny → Pełna wersja produktu. Bez ograniczeń. Bez karty. Bezpłatna próba

Zespol wsparcia Iron

Jestesmy online 24 godziny, 5 dni w tygodniu.
Czat
Email
Zadzwon do mnie