Didn’t find what you were looking for?
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

Curtis Chau
Curtis Chau
Zaktualizowano:

Eksportowanie danych z widoku siatki ASP.NET do pliku Excel

Możesz wyeksportować ASP.NET GridView do pliku Excel XLSX w C# instalując IronXL, tworząc WorkBook, iterując przez wiersze GridView, zapisując wartość każdej komórki w odpowiedniej pozycji arkusza roboczego i zapisując skoroszyt 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. Wyzwanie polega na wypełnieniu luki pomiędzy kontrolką po stronie serwera GridView a odpowiednio zbudowanym plikiem .xlsx — bez wprowadzania zależności Office Interop, które przerywają pracę w środowisku serwera sieciowego.

Ten przewodnik prowadzi cię przez trzy progresywnie bardziej złożone wzorce eksportu: minimalny eksport wiersz-po-wierszu, eksport z nagłówkiem i danymi z automatycznym dopasowywaniem kolumn oraz eksport sterowany przez DataTable, który całkowicie omija renderowany 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.Excel

Alternatywnie, kliknij prawym przyciskiem myszy projekt w Eksploratorze Rozwiązań, wybierz 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 kodu-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 wymagana 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 (nie IronXL.Excel, który jest przestarzałym aliasem). Po instalacji, asemblaża IronXL.dll jest automatycznie odwołana. Możesz zweryfikować zainstalowaną wersję, sprawdzają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, zastąp Server.MapPath przez IWebHostEnvironment.WebRootPath lub Path.Combine(Directory.GetCurrentDirectory(), "Exports") podczas budowania ś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 znaczniku ASPX dodaj kontrolkę <asp:GridView ID="gvEmployees" runat="server" AutoGenerateColumns="true" /> i przycisk <asp:Button ID="btnExport" runat="server" Text="Export to Excel" OnClick="btnExport_Click" />. Atrybut runat="server" sprawia, że obie kontrolki są dostępne w kodzie-behind.

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 skierowany na nowoczesny format Open XML. CreateWorkSheet("Employees") dodaje pierwszy arkusz. Zewnętrzna pętla (i) przechodzi przez wiersze danych; wewnętrzna pętla (j) przechodzi przez kolumny. Indeks wiersza i + 1 jest używany dla komórek danych, aby nagłówek w wierszu 0 nie został nadpisany.

Dlaczego 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 czyta i zapisuje pliki .xlsx bezpośrednio jako pakiety Open XML — bez COM, bez Office, bez szablonu Marshal.ReleaseComObject. 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?

Gdy chcesz, aby przeglądarka wyświetliła dialog zapisu pliku zamiast podawania bajtów wewnątrz, 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?

Podstawowy przykład zapisuje nagłówki wyodrębnione z HeaderRow.Cells, ale eksport produkcyjny powinien również automatycznie dopasować każdą kolumnę, aby dane były czytelne bez ręcznej regulacji w Excelu:

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) instruuje IronXL, aby obliczył optymalną szerokość kolumny na podstawie długości zawartości komórek, odwzorowując akcję Formatuj > Automatyczne dopasowanie szerokości kolumny w aplikacji Excel na pulpicie. 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ść.

Dla dodatkowych opcji stylizacji - pogrubione nagłówki, kolory tła, formaty liczbowe - eksploruj przewodnik stylizacji komórek IronXL. Możesz także scalać komórki, aby tworzyć tytuły raportów rozciągające się na kilka kolumn.

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

Użyj obiektu IStyle zwróconego przez worksheet["A1"].Style (lub zakres). Ustaw Font.Bold = true przed lub po zapisaniu 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?

Iterowanie przez wyrenderowane wiersze GridView wiąże twój eksport z aktualnym stanem wizualnym kontrolki, co może być wpływane przez paginację, sortowanie i ustawienia widoczności kolumn. Eksportowanie z przechowywanego w ViewState podstawowego DataTable daje deterministyczny wynik niezależnie od tego, jak siatka jest skonfigurowana:

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, który odzwierciedla oryginalny schemat danych, a nie jakiekolwiek nadpisania nazw wyświetlanych zastosowane w szablonie GridView. Wartości komórek są pobierane z obiektów DataRow przy użyciu indeksu kolumny, rzutując każdą wartość na string, aby spełniała SetCellValue.

Ten wzorzec jest szczególnie wartościowy, gdy GridView używa paginacji — iterowanie gvEmployees.Rows zwraca tylko wiersze na obecnie widocznej stronie, podczas gdy odczytanie całego 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. Dla eksportów przekraczających 100 000 wierszy, rozważ grupowanie wywołań SetCellValue wewnątrz pojedynczej operacji arkusza roboczego zamiast ustawiania pojedynczych komórek w zagnieżdżonej pętli. Możesz również zapisać skoroszyt do MemoryStream i wypłukać go do strumienia Response stopniowo, aby uniknąć trzymania całego pliku w pamięci RAM serwera.

Jak radzisz sobie z błędami podczas eksportu?

Obsługa eksportu produkcyjnego powinna owinąć operacje IronXL w blok catch i zwrócić użytkownikowi opisową wiadomość, gdy coś pójdzie nie tak. Typowe tryby awarii obejmują brakujący katalog ~/Exports/, błędy uprawnień pliku oraz ViewState równą null po wygaśnięciu 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

Dla aplikacji webowych, które dostarczają plik jako bezpośrednie pobranie z przeglądarki, a nie zapisują na dysku, użyj Response.BinaryWrite lub zapisz do Response.OutputStream po ustawieniu nagłówków typu zawartości i dyspozycji. Upewnij się, że katalog ~/Exports/ istnieje i że tożsamość aplikacji IIS ma uprawnienia do zapisu do niego.

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. Dane MemoryStream są przydzielane na serwerze, serializowane do byte[] i wysyłane bezpośrednio do klienta. Wywołanie Response.End() wypłukuje odpowiedź i zapobiega dołączaniu dodatkowego oznaczenia strony po danych binarnych.

Jak wyeksportować wiele arkuszy lub zaawansowanych skoroszytów?

Jeden WorkBook może zawierać wiele arkuszy, co jest przydatne, gdy potrzebujesz wyeksportować wiele GridViews — lub ten sam zestaw danych w różnych istotnościach — 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.

Dla jeszcze bogatszego wysiłku IronXL oferuje wsparcie dla formuł Excela, formatowanie warunkowe, tworzenie wykresów i osadzanie obrazów. Funkcje te zostały opisane w sekcji samouczków IronXL.

Jak IronXL wypada w porównaniu z EPPlusi 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 twojego projektu, funkcji Excela, których potrzebujesz, oraz czy wsparcie dla formatu .xls jest wymagane.

Jakie formaty Excel obsługuje IronXL?

IronXL czyta i zapisuje formaty .xlsx (Office Open XML), .xls (przestarzały BIFF8), .csv i .tsv. Możesz konwertować pomiędzy formatami plików Excela za pomocą pojedynczego wywołania API przez zmianę wartości enuma ExcelFileFormat przekazywanej do WorkBook.Create lub wczytują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 iteracyjny według wierszy — najszybsza droga do działającego eksportu z przypisanej 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 z przeglądarki używając 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łnienia kolorem tła i formaty numeryczne - używając API formatowania IronXL.
  3. Zapoznaj się z skoroszytami wielarkuszowymi, aby połączyć dane podsumowujące i szczegółowe w jednym pliku dostarczanym interesariuszom.
  4. Odczytaj pliki Excela z powrotem do obiektów DataTable używając API odczytu IronXL dla przepływów pracy związanych z importem/eksportem.
  5. Bezpłatna próba 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.

Curtis Chau
Curtis Chau
  Czat z zespołem inżynierów teraz
Autor tekstów technicznych

Curtis Chau posiada tytuł licencjata z informatyki (Uniwersytet Carleton) i specjalizuje się w front-endowym rozwoju, z ekspertką w Node.js, TypeScript, JavaScript i React. Pasjonuje się tworzeniem intuicyjnych i estetycznie przyjemnych interfejsów użytkownika, Curtis cieszy się pracą z nowoczesnymi frameworkami i tworzeniem dobrze zorganizowanych, atrakcyjnych wizualnie podrę...

Czytaj więcej

Powiązane artykuły

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

Zespół wsparcia Iron

Jesteśmy online 24 godziny, 5 dni w tygodniu.
Czat
E-mail
Zadzwoń do mnie