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. Eksport do Excela z Gridview
KORZYSTANIE Z IRONXL

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

Curtis Chau
Curtis Chau
Zaktualizowano:

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:

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>
$vbLabelText   $csharpLabel

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
$vbLabelText   $csharpLabel

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
$vbLabelText   $csharpLabel

Jak działa eksport krok po kroku

Proces dzieli się na trzy logiczne etapy:

  1. Pobierz DataTable — Session["GridData"] zwraca ten sam DataTable, który został powiązany z siatką. Pozwala to uniknąć powielania wywołań bazy danych.
  2. 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.
  3. 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
$vbLabelText   $csharpLabel

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
$vbLabelText   $csharpLabel

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()
$vbLabelText   $csharpLabel

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

Często Zadawane Pytania

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.

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