Dlaczego warto używać IronXL do eksportowania danych z GridView do Excela?

IronXL pozwala tworzyć prawdziwe pliki XLSX z GridView w ASP.NET C# bez typowych problemów związanych z HtmlTextWriter i StringWriter, takich jak ostrzeżenia przeglądarki i błędy formatowania.

Jakie są ograniczenia korzystania z HtmlTextWriter do eksportowania do Excela?

HtmlTextWriter często tworzy fałszywe pliki Excel, które mogą powodować ostrzeżenia przeglądarki i problemy z formatowaniem. IronXL rozwiązuje te problemy, generując prawdziwe pliki Excel.

W jaki sposób IronXL usprawnia proces eksportowania danych z GridView?

IronXL upraszcza eksport danych z GridView, umożliwiając programistom generowanie poprawnie sformatowanych plików Excel bezpośrednio z aplikacji ASP.NET, eliminując potrzebę stosowania rozwiązań opartych na HTML.

Jakiego formatu plików używa IronXL do eksportowanych plików Excel?

IronXL eksportuje dane do oryginalnych plików XLSX, zapewniając kompatybilność i prawidłowe formatowanie po otwarciu w programie Excel.

Czy IronXL może pomóc w kwestiach formatowania podczas eksportu do Excela?

Tak, IronXL eliminuje problemy z formatowaniem poprzez tworzenie prawdziwych plików Excel, co gwarantuje, że dane wyświetlają się poprawnie bez wywoływania ostrzeżeń przeglądarki.

Czy istnieje przykład kodu służący do eksportowania danych GridView za pomocą IronXL?

Tak, samouczek zawiera przykłady kodu pokazujące, jak używać IronXL do wydajnego i skutecznego eksportowania danych z GridView do Excela.

Czy IronXL obsługuje eksportowanie dużych zbiorów danych z GridView?

IronXL został zaprojektowany do wydajnej obsługi dużych zbiorów danych, dzięki czemu nadaje się do eksportowania obszernych danych z GridView do Excela.

Jakie są zalety korzystania z IronXL w porównaniu z tradycyjnymi metodami eksportu do Excela?

IronXL oferuje bardziej niezawodne i wydajne rozwiązanie, eliminując ostrzeżenia przeglądarki, zapewniając prawidłowe formatowanie plików oraz umożliwiając proste wdrożenie kodu do eksportowania danych GridView.

What steps should I follow to implement GridView export using IronXL?

First, install IronXL via NuGet. Then replace your traditional export logic with IronXL's method to create a WorkBook from a DataTable, apply necessary formatting, and stream the result to the browser.

How does IronXL handle Excel file streaming to the browser?

IronXL sets the response content type to the appropriate MIME type for Excel and writes directly to the browser's output stream, initiating a download without creating temporary files on the server.

Biblioteka Excel dla C#

Explore Biblioteka IronXL Excel dla C# .NET Bezpłatna próba

Czytaj pliki Excel bez Interop

Zobacz wszystkie przykłady kodu %s

using IronXL;
using System;
using System.Linq;

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

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

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

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

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

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

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

using IronXL;
using System;
using System.Linq;

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

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

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

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

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

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

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

PM >Install-Package IronXL.Excel

Install-Package IronXL.Excel

KORZYSTANIE Z IRONXL

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

Curtis Chau

Updated: 28 czerwca 2026

Eksportowanie danych GridView do prawdziwego pliku Excel jest jednym z najczęstszych wymagań w aplikacjach internetowych ASP.NET. Tradycyjne podejścia wykorzystujące HtmlTextWriter i StringWriter tworzą fałszywe pliki Excel, które wywołują ostrzeżenia przeglądarek i błędy formatowania, gdy użytkownicy próbują je otworzyć. Ten przewodnik pokazuje, jak eksportować dane GridView do prawidłowo sformatowanych plików .xlsx za pomocą IronXL — eliminując problemy, z którymi programiści spotykają się przy użyciu przestarzałych metod.

Dlaczego tradycyjne podejście do eksportu z GridView powoduje problemy?

Klasyczna metoda eksportu do Excela z GridView w ASP.NET C# polega na renderowaniu HTML i ustawianiu nagłówków Response z wartościami nazw plików załączników Content-Disposition. To podejście wymaga nadpisania public override void VerifyRenderingInServerForm, aby uniknąć błędów w czasie wykonywania. Wynikowy plik nie jest prawdziwym plikiem Excel — to HTML udający z rozszerzeniem .xls, który powoduje, że Excel wyświetla ostrzeżenia, gdy użytkownicy go otwierają.

W szczególności tradycyjna technika ma następujące wady:

Program Excel wyświetla ostrzeżenie "Format pliku i rozszerzenie nie są zgodne" przy każdym otwarciu
Formatowanie i typy danych są utracone, ponieważ dane są przechowywane jako surowy kod HTML
Należy zaimplementować VerifyRenderingInServerForm jako obejście, co dodaje dług techniczny do projektu.
W pliku wynikowym brakuje odpowiednich metadanych komórek, co sprawia, że nie nadaje się on do wykorzystania w dalszych narzędziach do automatyzacji lub raportowania

IronXL rozwiązuje te problemy, tworząc autentyczne pliki Excel .xlsx bez konieczności instalacji Microsoft Office na serwerze. Otrzymujesz plik, który można bez problemów otworzyć w dowolnym programie do obsługi arkuszy kalkulacyjnych, z zachowaniem odpowiednich typów danych, stylów i struktury OOXML.

Jak zainstalować IronXL w projekcie ASP.NET?

Przed napisaniem jakiejkolwiek logiki eksportu dodaj IronXL do swojego projektu za pomocą menedżera pakietów NuGet. Otwórz konsolę menedżera pakietów w Visual Studio i uruchom:

PM > Install-Package IronXL.Excel

Install-Package IronXL.Excel

Alternatywnie, wyszukaj IronXL.Excel w interfejsie menedżera pakietów NuGet i zainstaluj go stamtąd. Po zainstalowaniu możesz odwołać się do przestrzeni nazw IronXL w dowolnym pliku code-behind.

IronXL jest przeznaczony dla platformy .NET Standard 2.0 i nowszych, dzięki czemu współpracuje zarówno z nowoczesnymi projektami ASP.NET Core, jak i klasycznymi aplikacjami ASP.NET Framework. Nie jest wymagana interoperacyjność COM, instalacja pakietu Office ani żadne dodatkowe zależności natywne na serwerze internetowym.

Więcej szczegółów można znaleźć w instrukcji instalacji IronXL oraz na stronie pakietu IronXL NuGet.

Jak skonfigurować widok siatki ASP.NET GridView do eksportu?

Utwórz swoją stronę Default.aspx z kontrolką GridView i przyciskiem eksportu. Znaczniki są standardowymi formularzami internetowymi:

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Default.aspx.cs" Inherits="GridViewExportTest.Default" %>
<!DOCTYPE html>
<html>
<head runat="server">
    <title>Export GridView to Excel</title>
</head>
<body>
    <form id="form1" runat="server">
        <div>
            <h2>IronXL GridView Export Demo</h2>
            <asp:GridView ID="GridView1" runat="server" AutoGenerateColumns="true"
                HeaderStyle-BackColor="#3AC0F2" HeaderStyle-ForeColor="White" CellPadding="5">
            </asp:GridView>
            <br />
            <asp:Button ID="btnExport" runat="server" Text="Export to Excel (.xlsx)"
                OnClick="btnExport_Click" />
        </div>
    </form>
</body>
</html>

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Default.aspx.cs" Inherits="GridViewExportTest.Default" %>
<!DOCTYPE html>
<html>
<head runat="server">
    <title>Export GridView to Excel</title>
</head>
<body>
    <form id="form1" runat="server">
        <div>
            <h2>IronXL GridView Export Demo</h2>
            <asp:GridView ID="GridView1" runat="server" AutoGenerateColumns="true"
                HeaderStyle-BackColor="#3AC0F2" HeaderStyle-ForeColor="White" CellPadding="5">
            </asp:GridView>
            <br />
            <asp:Button ID="btnExport" runat="server" Text="Export to Excel (.xlsx)"
                OnClick="btnExport_Click" />
        </div>
    </form>
</body>
</html>

net

net

Ten znacznik tworzy prostą stronę z powiązanym GridView i przyciskiem wyzwalającym eksport. Atrybut AutoGenerateColumns="true" oznacza, że siatka odczytuje nazwy kolumn bezpośrednio z powiązanego DataTable.

Powiązanie przykładowych danych z widokiem GridView

W swoim kodzie-behind zwiąż DataTable z siatką i przechowaj ją w Session do późniejszego użycia podczas eksportu postback:

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

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

        private void BindGridView()
        {
            DataTable dt = new DataTable("Employees");
            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, "Mike Wilson", "Sales", 70000);
            dt.Rows.Add(4, "Emily Davis", "Engineering", 80000);

            GridView1.DataSource = dt;
            GridView1.DataBind();

            // Store DataTable in Session for export postback
            Session["GridData"] = dt;
        }
    }
}

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

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

        private void BindGridView()
        {
            DataTable dt = new DataTable("Employees");
            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, "Mike Wilson", "Sales", 70000);
            dt.Rows.Add(4, "Emily Davis", "Engineering", 80000);

            GridView1.DataSource = dt;
            GridView1.DataBind();

            // Store DataTable in Session for export postback
            Session["GridData"] = dt;
        }
    }
}

Imports System
Imports System.Data
Imports System.Web.UI
Imports IronXL

Namespace GridViewExport
    Partial Public Class [Default]
        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("Employees")
            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, "Mike Wilson", "Sales", 70000)
            dt.Rows.Add(4, "Emily Davis", "Engineering", 80000)

            GridView1.DataSource = dt
            GridView1.DataBind()

            ' Store DataTable in Session for export postback
            Session("GridData") = dt
        End Sub
    End Class
End Namespace

Imports System
Imports System.Data
Imports System.Web.UI
Imports IronXL

Namespace GridViewExport
    Partial Public Class [Default]
        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("Employees")
            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, "Mike Wilson", "Sales", 70000)
            dt.Rows.Add(4, "Emily Davis", "Engineering", 80000)

            GridView1.DataSource = dt
            GridView1.DataBind()

            ' Store DataTable in Session for export postback
            Session("GridData") = dt
        End Sub
    End Class
End Namespace

Przechowywanie DataTable w Session unika ponownego zapytania bazy danych lub odbudowy danych podczas postback wywołanego przez przycisk eksportu. W rzeczywistych zastosowaniach należy zastąpić wbudowane w kod wiersze zapytaniem do bazy danych przy użyciu Entity Framework lub ADO.NET Framework.

Eksport do Excela z GridView w ASP.NET C#: Czyste rozwiązanie C#: Obraz 1 - Interfejs użytkownika pokazujący przykładowe dane GridView

Jak wyeksportować dane z GridView do Excela za pomocą IronXL?

Czyste podejście do eksportu GridView konwertuje twój DataTable na WorkBook IronXL i strumieniuje wynik bezpośrednio do przeglądarki. Oto pełna metoda eksportu:

protected void btnExport_Click(object sender, EventArgs e)
{
    ExportGridViewToExcel();
}

private void ExportGridViewToExcel()
{
    DataTable dt = (DataTable)Session["GridData"];

    // Create a workbook and load data from the DataTable
    WorkBook workbook = WorkBook.Create();
    WorkBook.LoadWorkSheetsFromDataSet(new DataSet { Tables = { dt } }, workbook);
    WorkSheet worksheet = workbook.DefaultWorkSheet;

    // Apply header row formatting
    var headerRange = worksheet["A1:D1"];
    headerRange.Style.Font.Bold = true;
    headerRange.Style.Font.Size = 12;
    headerRange.Style.SetBackgroundColor("#3AC0F2");

    // Stream the file to the browser
    string filename = "GridViewExport_" + DateTime.Now.ToString("yyyyMMdd") + ".xlsx";
    Response.Clear();
    Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
    Response.AddHeader("content-disposition", "attachment;filename=" + filename);
    workbook.SaveAsStream(Response.OutputStream, IronXL.Enum.FileFormat.Xlsx);
    Response.Flush();
    Response.End();
}

protected void btnExport_Click(object sender, EventArgs e)
{
    ExportGridViewToExcel();
}

private void ExportGridViewToExcel()
{
    DataTable dt = (DataTable)Session["GridData"];

    // Create a workbook and load data from the DataTable
    WorkBook workbook = WorkBook.Create();
    WorkBook.LoadWorkSheetsFromDataSet(new DataSet { Tables = { dt } }, workbook);
    WorkSheet worksheet = workbook.DefaultWorkSheet;

    // Apply header row formatting
    var headerRange = worksheet["A1:D1"];
    headerRange.Style.Font.Bold = true;
    headerRange.Style.Font.Size = 12;
    headerRange.Style.SetBackgroundColor("#3AC0F2");

    // Stream the file to the browser
    string filename = "GridViewExport_" + DateTime.Now.ToString("yyyyMMdd") + ".xlsx";
    Response.Clear();
    Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
    Response.AddHeader("content-disposition", "attachment;filename=" + filename);
    workbook.SaveAsStream(Response.OutputStream, IronXL.Enum.FileFormat.Xlsx);
    Response.Flush();
    Response.End();
}

Imports System
Imports System.Data

Protected Sub btnExport_Click(sender As Object, e As EventArgs)
    ExportGridViewToExcel()
End Sub

Private Sub ExportGridViewToExcel()
    Dim dt As DataTable = DirectCast(Session("GridData"), DataTable)

    ' Create a workbook and load data from the DataTable
    Dim workbook As WorkBook = WorkBook.Create()
    WorkBook.LoadWorkSheetsFromDataSet(New DataSet With {.Tables = {dt}}, workbook)
    Dim worksheet As WorkSheet = workbook.DefaultWorkSheet

    ' Apply header row formatting
    Dim headerRange = worksheet("A1:D1")
    headerRange.Style.Font.Bold = True
    headerRange.Style.Font.Size = 12
    headerRange.Style.SetBackgroundColor("#3AC0F2")

    ' Stream the file to the browser
    Dim filename As String = "GridViewExport_" & DateTime.Now.ToString("yyyyMMdd") & ".xlsx"
    Response.Clear()
    Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
    Response.AddHeader("content-disposition", "attachment;filename=" & filename)
    workbook.SaveAsStream(Response.OutputStream, IronXL.Enum.FileFormat.Xlsx)
    Response.Flush()
    Response.End()
End Sub

Imports System
Imports System.Data

Protected Sub btnExport_Click(sender As Object, e As EventArgs)
    ExportGridViewToExcel()
End Sub

Private Sub ExportGridViewToExcel()
    Dim dt As DataTable = DirectCast(Session("GridData"), DataTable)

    ' Create a workbook and load data from the DataTable
    Dim workbook As WorkBook = WorkBook.Create()
    WorkBook.LoadWorkSheetsFromDataSet(New DataSet With {.Tables = {dt}}, workbook)
    Dim worksheet As WorkSheet = workbook.DefaultWorkSheet

    ' Apply header row formatting
    Dim headerRange = worksheet("A1:D1")
    headerRange.Style.Font.Bold = True
    headerRange.Style.Font.Size = 12
    headerRange.Style.SetBackgroundColor("#3AC0F2")

    ' Stream the file to the browser
    Dim filename As String = "GridViewExport_" & DateTime.Now.ToString("yyyyMMdd") & ".xlsx"
    Response.Clear()
    Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
    Response.AddHeader("content-disposition", "attachment;filename=" & filename)
    workbook.SaveAsStream(Response.OutputStream, IronXL.Enum.FileFormat.Xlsx)
    Response.Flush()
    Response.End()
End Sub

Jak działa eksport krok po kroku

Proces dzieli się na trzy logiczne etapy:

Pobierz DataTable — Session["GridData"] zwraca ten sam DataTable, który został powiązany z siatką. Pozwala to uniknąć powielania wywołań bazy danych.
Utwórz WorkBook — WorkBook.LoadWorkSheetsFromDataSet automatycznie tworzy jeden arkusz na DataTable w DataSet, kopiując nagłówki kolumn i wartości wierszy do odpowiednich komórek.
Strumieniowanie do przeglądarki — ustawienie Content-Type na MIME typu OOXML i zapisanie do Response.OutputStream wyzwala pobranie przez przeglądarkę z prawidłowym rozszerzeniem .xlsx. Na dysk nie są zapisywane żadne pliki tymczasowe.

To zasadniczo różni się od przestarzałego podejścia HtmlTextWriter. Eksportowany plik wykorzystuje format Open XML — ten sam format, którego natywnie używa program Microsoft Excel — dzięki czemu otwiera się bez ostrzeżeń.

Aby uzyskać więcej informacji o programowym ładowaniu danych, zobacz dokumentację WorkBook IronXL i jak eksportować DataTable do Excela w C#.

Eksport do Excela z GridView w ASP.NET C#: Czyste rozwiązanie C#: Obraz 2 - Wyeksportowany plik Excel

Jak zapisać plik Excel na dysku zamiast przesyłać go strumieniowo?

Jeśli aplikacja musi zarchiwizować eksporty na serwerze przed dostarczeniem linku do pobrania użytkownikowi, zapisz skoroszyt na ścieżce pliku zamiast strumieniować go do Response.OutputStream:

private void SaveExcelToDisk(WorkBook workbook, string exportFolder)
{
    // Ensure the exports directory exists
    if (!System.IO.Directory.Exists(exportFolder))
    {
        System.IO.Directory.CreateDirectory(exportFolder);
    }

    string timestamp = DateTime.Now.ToString("yyyyMMdd_HHmmss");
    string filename = System.IO.Path.Combine(exportFolder, $"Report_{timestamp}.xlsx");

    workbook.SaveAs(filename);

    // Return the relative path for generating a download link
    string relativePath = "~/Exports/Report_" + timestamp + ".xlsx";
    Response.Write($"<script>alert('File saved to {relativePath}');</script>");
}

private void SaveExcelToDisk(WorkBook workbook, string exportFolder)
{
    // Ensure the exports directory exists
    if (!System.IO.Directory.Exists(exportFolder))
    {
        System.IO.Directory.CreateDirectory(exportFolder);
    }

    string timestamp = DateTime.Now.ToString("yyyyMMdd_HHmmss");
    string filename = System.IO.Path.Combine(exportFolder, $"Report_{timestamp}.xlsx");

    workbook.SaveAs(filename);

    // Return the relative path for generating a download link
    string relativePath = "~/Exports/Report_" + timestamp + ".xlsx";
    Response.Write($"<script>alert('File saved to {relativePath}');</script>");
}

Private Sub SaveExcelToDisk(workbook As WorkBook, exportFolder As String)
    ' Ensure the exports directory exists
    If Not System.IO.Directory.Exists(exportFolder) Then
        System.IO.Directory.CreateDirectory(exportFolder)
    End If

    Dim timestamp As String = DateTime.Now.ToString("yyyyMMdd_HHmmss")
    Dim filename As String = System.IO.Path.Combine(exportFolder, $"Report_{timestamp}.xlsx")

    workbook.SaveAs(filename)

    ' Return the relative path for generating a download link
    Dim relativePath As String = "~/Exports/Report_" & timestamp & ".xlsx"
    Response.Write($"<script>alert('File saved to {relativePath}');</script>")
End Sub

Private Sub SaveExcelToDisk(workbook As WorkBook, exportFolder As String)
    ' Ensure the exports directory exists
    If Not System.IO.Directory.Exists(exportFolder) Then
        System.IO.Directory.CreateDirectory(exportFolder)
    End If

    Dim timestamp As String = DateTime.Now.ToString("yyyyMMdd_HHmmss")
    Dim filename As String = System.IO.Path.Combine(exportFolder, $"Report_{timestamp}.xlsx")

    workbook.SaveAs(filename)

    ' Return the relative path for generating a download link
    Dim relativePath As String = "~/Exports/Report_" & timestamp & ".xlsx"
    Response.Write($"<script>alert('File saved to {relativePath}');</script>")
End Sub

Wybór między strumieniowaniem a zapisywaniem na dysku

Porównanie strategii eksportu strumieniowego i eksportu z zapisaniem na dysku
Strategia	Zalety	Wady	Najlepsze dla
Przesyłaj strumieniowo do przeglądarki	Bez zajmowania miejsca na dysku, natychmiastowa dostawa	Nie można archiwizować ani ponownie wysyłać	Eksporty użytkowników na żądanie
Zapisz na dysku	Plik pozostaje dostępny do celów audytu, ponownego pobrania lub wysłania e-mailem	Wymaga czyszczenia, zarządzania przestrzenią dyskową	Zaplanowane raporty, ścieżki audytu

W przypadku większości interaktywnych aplikacji internetowych właściwym wyborem jest strumieniowe przesyłanie bezpośrednio do przeglądarki. Zapisz na dysku, gdy chcesz wysłać plik pocztą elektroniczną, przechować go dla celów zgodności z przepisami lub umożliwić ponowne pobranie ze strony zarządzania plikami.

Jak zastosować zaawansowane formatowanie do wyeksportowanego arkusza Excel?

IronXL zapewnia precyzyjną kontrolę nad stylami komórek, szerokością kolumn, formatami liczb i nie tylko. Poniższy przykład pokazuje, jak stworzyć profesjonalnie sformatowany plik eksportu:

private void ExportWithFormatting()
{
    DataTable dt = new DataTable("Products");
    dt.Columns.Add("Product", typeof(string));
    dt.Columns.Add("Category", typeof(string));
    dt.Columns.Add("Price", typeof(decimal));
    dt.Columns.Add("InStock", typeof(bool));

    dt.Rows.Add("Widget A", "Hardware", 29.99m, true);
    dt.Rows.Add("Widget B", "Hardware", 49.99m, false);
    dt.Rows.Add("Service Plan", "Support", 199.00m, true);

    WorkBook workbook = WorkBook.Create();
    WorkBook.LoadWorkSheetsFromDataSet(new DataSet { Tables = { dt } }, workbook);
    WorkSheet sheet = workbook.WorkSheets[0];

    // Style the header row
    sheet["A1:D1"].Style.Font.Bold = true;
    sheet["A1:D1"].Style.Font.Size = 13;
    sheet["A1:D1"].Style.SetBackgroundColor("#2196F3");
    sheet["A1:D1"].Style.Font.Color = "#FFFFFF";

    // Apply currency format to the Price column (column C, rows 2 onwards)
    sheet["C2:C4"].Style.NumberFormat.Format = "$#,##0.00";

    // Auto-size all columns for readability
    for (int col = 0; col < 4; col++)
    {
        sheet.AutoSizeColumn(col);
    }

    // Freeze the header row so it stays visible when scrolling
    sheet.FreezePanes(0, 0, 1, 0);

    workbook.SaveAs("FormattedExport.xlsx");
}

private void ExportWithFormatting()
{
    DataTable dt = new DataTable("Products");
    dt.Columns.Add("Product", typeof(string));
    dt.Columns.Add("Category", typeof(string));
    dt.Columns.Add("Price", typeof(decimal));
    dt.Columns.Add("InStock", typeof(bool));

    dt.Rows.Add("Widget A", "Hardware", 29.99m, true);
    dt.Rows.Add("Widget B", "Hardware", 49.99m, false);
    dt.Rows.Add("Service Plan", "Support", 199.00m, true);

    WorkBook workbook = WorkBook.Create();
    WorkBook.LoadWorkSheetsFromDataSet(new DataSet { Tables = { dt } }, workbook);
    WorkSheet sheet = workbook.WorkSheets[0];

    // Style the header row
    sheet["A1:D1"].Style.Font.Bold = true;
    sheet["A1:D1"].Style.Font.Size = 13;
    sheet["A1:D1"].Style.SetBackgroundColor("#2196F3");
    sheet["A1:D1"].Style.Font.Color = "#FFFFFF";

    // Apply currency format to the Price column (column C, rows 2 onwards)
    sheet["C2:C4"].Style.NumberFormat.Format = "$#,##0.00";

    // Auto-size all columns for readability
    for (int col = 0; col < 4; col++)
    {
        sheet.AutoSizeColumn(col);
    }

    // Freeze the header row so it stays visible when scrolling
    sheet.FreezePanes(0, 0, 1, 0);

    workbook.SaveAs("FormattedExport.xlsx");
}

Private Sub ExportWithFormatting()
    Dim dt As New DataTable("Products")
    dt.Columns.Add("Product", GetType(String))
    dt.Columns.Add("Category", GetType(String))
    dt.Columns.Add("Price", GetType(Decimal))
    dt.Columns.Add("InStock", GetType(Boolean))

    dt.Rows.Add("Widget A", "Hardware", 29.99D, True)
    dt.Rows.Add("Widget B", "Hardware", 49.99D, False)
    dt.Rows.Add("Service Plan", "Support", 199.0D, True)

    Dim workbook As WorkBook = WorkBook.Create()
    WorkBook.LoadWorkSheetsFromDataSet(New DataSet With {.Tables = {dt}}, workbook)
    Dim sheet As WorkSheet = workbook.WorkSheets(0)

    ' Style the header row
    sheet("A1:D1").Style.Font.Bold = True
    sheet("A1:D1").Style.Font.Size = 13
    sheet("A1:D1").Style.SetBackgroundColor("#2196F3")
    sheet("A1:D1").Style.Font.Color = "#FFFFFF"

    ' Apply currency format to the Price column (column C, rows 2 onwards)
    sheet("C2:C4").Style.NumberFormat.Format = "$#,##0.00"

    ' Auto-size all columns for readability
    For col As Integer = 0 To 3
        sheet.AutoSizeColumn(col)
    Next

    ' Freeze the header row so it stays visible when scrolling
    sheet.FreezePanes(0, 0, 1, 0)

    workbook.SaveAs("FormattedExport.xlsx")
End Sub

Private Sub ExportWithFormatting()
    Dim dt As New DataTable("Products")
    dt.Columns.Add("Product", GetType(String))
    dt.Columns.Add("Category", GetType(String))
    dt.Columns.Add("Price", GetType(Decimal))
    dt.Columns.Add("InStock", GetType(Boolean))

    dt.Rows.Add("Widget A", "Hardware", 29.99D, True)
    dt.Rows.Add("Widget B", "Hardware", 49.99D, False)
    dt.Rows.Add("Service Plan", "Support", 199.0D, True)

    Dim workbook As WorkBook = WorkBook.Create()
    WorkBook.LoadWorkSheetsFromDataSet(New DataSet With {.Tables = {dt}}, workbook)
    Dim sheet As WorkSheet = workbook.WorkSheets(0)

    ' Style the header row
    sheet("A1:D1").Style.Font.Bold = True
    sheet("A1:D1").Style.Font.Size = 13
    sheet("A1:D1").Style.SetBackgroundColor("#2196F3")
    sheet("A1:D1").Style.Font.Color = "#FFFFFF"

    ' Apply currency format to the Price column (column C, rows 2 onwards)
    sheet("C2:C4").Style.NumberFormat.Format = "$#,##0.00"

    ' Auto-size all columns for readability
    For col As Integer = 0 To 3
        sheet.AutoSizeColumn(col)
    Next

    ' Freeze the header row so it stays visible when scrolling
    sheet.FreezePanes(0, 0, 1, 0)

    workbook.SaveAs("FormattedExport.xlsx")
End Sub

Opcje formatowania dostępne w IronXL

IronXL udostępnia bogaty zbiór właściwości formatowania poprzez przestrzeń nazw IronXL.Styles:

Styl czcionki — pogrubienie, kursywa, podkreślenie, rodzina czcionek i rozmiar
Kolory tła komórek — akceptowane są bezpośrednie ciągi znaków kolorów w formacie szesnastkowym
Formaty liczb i dat — dowolny ciąg formatujący programu Excel, w tym wzorce walut, wartości procentowych i dat
Szerokość kolumny — ręczna szerokość w pikselach lub AutoSizeColumn dla automatycznego dopasowania
Zablokuj okienka — zablokuj wiersze lub kolumny nagłówka podczas przewijania
Obramowania komórek — wszystkie cztery krawędzie z konfigurowalnym stylem i kolorem
Scal komórki — połącz komórki w wierszach lub kolumnach w nagłówkach raportów

Aby uzyskać pełną dokumentację API, zobacz dokumentację stylizacji komórek IronXL i formatowanie liczby IronXL.

Eksport do Excela z GridView w ASP.NET C#: Czyste rozwiązanie C#: Obraz 3 - Wyeksportowany sformatowany dokument Excel

Jak radzisz sobie z dużymi zbiorami danych w eksportach GridView?

Gdy GridView jest powiązany z tysiącami wierszy, kilka technik pozwala zachować szybkość eksportu i oszczędność pamięci:

Stronicowanie i DataTable po stronie serwera

Nie eksportuj tylko widocznej strony GridView. Pobierz pełny zestaw danych ze źródła danych do DataTable przed wywołaniem WorkBook.LoadWorkSheetsFromDataSet. IronXL zapisuje wiersze w jednym przebiegu bez wielokrotnego ładowania całego skoroszytu do pamięci, dzięki czemu nadaje się do obsługi dziesiątek tysięcy wierszy.

Dodawanie wielu arkuszy

Możesz uwzględnić wiele obiektów DataTable w DataSet, aby utworzyć skoroszyt z oddzielnymi kartami:

DataSet exportSet = new DataSet();
exportSet.Tables.Add(GetEmployeeData());    // Sheet 1
exportSet.Tables.Add(GetDepartmentData());  // Sheet 2
exportSet.Tables.Add(GetSalaryReport());    // Sheet 3

WorkBook workbook = WorkBook.Create();
WorkBook.LoadWorkSheetsFromDataSet(exportSet, workbook);

Response.Clear();
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
Response.AddHeader("content-disposition", "attachment;filename=MultiSheetReport.xlsx");
workbook.SaveAsStream(Response.OutputStream, IronXL.Enum.FileFormat.Xlsx);
Response.Flush();
Response.End();

DataSet exportSet = new DataSet();
exportSet.Tables.Add(GetEmployeeData());    // Sheet 1
exportSet.Tables.Add(GetDepartmentData());  // Sheet 2
exportSet.Tables.Add(GetSalaryReport());    // Sheet 3

WorkBook workbook = WorkBook.Create();
WorkBook.LoadWorkSheetsFromDataSet(exportSet, workbook);

Response.Clear();
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
Response.AddHeader("content-disposition", "attachment;filename=MultiSheetReport.xlsx");
workbook.SaveAsStream(Response.OutputStream, IronXL.Enum.FileFormat.Xlsx);
Response.Flush();
Response.End();

Imports System.Data
Imports IronXL

Dim exportSet As New DataSet()
exportSet.Tables.Add(GetEmployeeData()) ' Sheet 1
exportSet.Tables.Add(GetDepartmentData()) ' Sheet 2
exportSet.Tables.Add(GetSalaryReport()) ' Sheet 3

Dim workbook As WorkBook = WorkBook.Create()
WorkBook.LoadWorkSheetsFromDataSet(exportSet, workbook)

Response.Clear()
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
Response.AddHeader("content-disposition", "attachment;filename=MultiSheetReport.xlsx")
workbook.SaveAsStream(Response.OutputStream, IronXL.Enum.FileFormat.Xlsx)
Response.Flush()
Response.End()

Imports System.Data
Imports IronXL

Dim exportSet As New DataSet()
exportSet.Tables.Add(GetEmployeeData()) ' Sheet 1
exportSet.Tables.Add(GetDepartmentData()) ' Sheet 2
exportSet.Tables.Add(GetSalaryReport()) ' Sheet 3

Dim workbook As WorkBook = WorkBook.Create()
WorkBook.LoadWorkSheetsFromDataSet(exportSet, workbook)

Response.Clear()
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
Response.AddHeader("content-disposition", "attachment;filename=MultiSheetReport.xlsx")
workbook.SaveAsStream(Response.OutputStream, IronXL.Enum.FileFormat.Xlsx)
Response.Flush()
Response.End()

Każdy DataTable.TableName staje się nazwą karty arkusza w Excelu. Ten wzorzec sprawdza się dobrze w przypadku raportów zarządczych, które łączą powiązane dane z wielu widoków.

Powiązane przewodniki:

Jakie są główne zalety korzystania z IronXL do eksportu GridView?

Wykorzystanie IronXL do eksportowania danych z GridView oferuje wyraźne zalety w porównaniu z tradycyjnym podejściem opartym na owijaniu w HTML:

Autentyczne pliki Excel — tworzy poprawny format .xlsx, który otwiera się bez ostrzeżeń przeglądarki lub komunikatów o błędach
Nie wymaga instalacji pakietu Office — działa na dowolnym serwerze internetowym bez programu Microsoft Excel lub interoperacyjności z pakietem Office
Bez nadpisywania VerifyRenderingInServerForm — eliminuje podstawową obejście, które zaśmieca tradycyjny kod
Pełna kontrola formatowania — stylizowanie komórek, stosowanie formatów liczb, zamrażanie okienek i programowe tworzenie profesjonalnych arkuszy
Obsługa wielu arkuszy — eksportowanie powiązanych zestawów danych jako oddzielnych kart w jednym skoroszycie
Kompatybilność międzyplatformowa — działa poprawnie na serwerach Windows i Linux, w tym w kontenerach Docker i usłudze Azure App Service

Biblioteka jest dostępna na NuGet i obsługuje wszystkie nowoczesne platformy .NET, w tym .NET 10. Obsługuje również odczyt i zapis innych formatów, takich jak CSV i ODS, co sprawia, że stanowi ona jedyne rozwiązanie dla wszystkich potrzeb związanych z arkuszami kalkulacyjnymi w Twojej aplikacji.

Aby uzyskać porównanie z innymi bibliotekami Excela, zobacz IronXL vs ClosedXML i przegląd funkcji IronXL.

Jakie są Twoje kolejne kroki?

Teraz masz wszystko, czego potrzebujesz, aby zastąpić przestarzały eksport GridView HtmlTextWriter czystą, wolną od ostrzeżeń implementacją IronXL. Oto jak należy postępować:

Wypróbuj bezpłatną wersję próbną — rozpocznij 30-dniowy bezpłatny okres próbny IronXL bez konieczności podawania danych karty kredytowej i przetestuj kod eksportu w swoim własnym projekcie
Zapoznaj się z innymi samouczkami IronXL — blog IronXL obejmuje tematy takie jak import danych, formuły komórek, generowanie wykresów oraz przepływy pracy z szablonami Excel
Przeczytaj dokumentację API — dokumentacja API IronXL obejmuje każdą metodę na WorkBook, WorkSheet i API stylizacji
Porównaj opcje licencyjne — zapoznaj się z cennikiem IronXL, aby znaleźć licencję odpowiednią dla wielkości Twojego zespołu i scenariusza wdrożenia
Zadaj pytanie — jeśli napotkasz jakieś nieoczekiwane problemy, możesz skorzystać z pomocy zespołu wsparcia Iron Software oraz forów społecznościowych

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ęczników.

...

Czytaj więcej