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

Jordi Bardia
Jordi Bardia
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ądarki i błędy formatowania, gdy użytkownicy próbują je otworzyć. W tym przewodniku dowiesz się, jak eksportować dane z GridView do poprawnie sformatowanych plików .xlsx przy użyciu IronXL — eliminując w ten sposób problemy, z którymi borykają się programiści stosujący starsze metody.

Dłączego tradycyjne podejście do eksportu z GridView powoduje problemy?

Klasyczna metoda eksportu do Excela z GridView w ASP.NET C# polega na renderowaniu kodu HTML i ustawieniu nagłówków Response z wartościami nazw plików załączników Content-Disposition. Takie podejście wymaga nadpisania public override void VerifyRenderingInServerForm, aby uniknąć błędów wykonania. Powstały plik nie jest prawdziwym plikiem Excel — jest to kod HTML udający plik z rozszerzeniem .xls, co powoduje wyświetlanie komunikatów ostrzegawczych przez program Excel podczas otwierania go przez użytkowników.

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
  • Musisz zaimplementować VerifyRenderingInServerForm jako rozwiązanie tymczasowe, co zwiększy dług techniczny Twojego 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 instalowania pakietu 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
Install-Package IronXl.Excel
SHELL

Alternatywnie, wyszukaj IronXl.Excel w interfejsie użytkownika NuGet Package Manager i zainstaluj go stamtąd. Po zainstalowaniu można odwołać się do przestrzeni nazw IronXL w dowolnym pliku kodu zaplecza.

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 wymagańa 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 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 wbudowanym GridView oraz przyciskiem, który uruchamia 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 kodzie pomocniczym (code-behind) należy powiązać DataTable z siatką i zapisać go w Session do późniejszego wykorzystania podczas operacji eksportu:

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

Zapisanie DataTable w Session pozwala uniknąć ponownego wysyłania zapytania do bazy danych lub odtwarzania danych podczas operacji postback wywołanej 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#: Zaletyte rozwiązanie w C#: Obraz 1 – Interfejs użytkownika przedstawiający przykładowe dane GridView

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

Zaletyty sposób eksportu GridView konwertuje DataTable na IronXL WorkBook i przesyła 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
Imports IronXL

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 tabelę danych -- Session["GridData"] zwraca tę samą DataTable, która była powiązana z siatką. Pozwala to uniknąć powielania wywołań bazy danych.
  2. Utwórz skoroszyt — WorkBook.LoadWorkSheetsFromDataSet automatycznie tworzy jeden arkusz na DataTable w DataSet, kopiując nagłówki kolumn i wartości wierszy do odpowiednich komórek.
  3. Przesyłanie strumieniowe do przeglądarki — ustawienie Content-Type jako typu MIME OOXML i zapisanie w Response.OutputStream powoduje pobranie pliku przez przeglądarkę z prawidłowym rozszerzeniem .xlsx. Na dysk nie są zapisywane żadne pliki tymczasowe.

Różni się to zasadniczo od dotychczasowego 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ń.

Więcej informacji na temat programowego ładowania danych można znaleźć w dokumentacji IronXL WorkBook oraz w instrukcji eksportowania tabeli danych do programu Excel w języku C#.

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

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

Jeśli Twoja aplikacja wymaga archiwizacji eksportów na serwerze przed dostarczeniem linku do pobrania użytkownikowi, zapisz skoroszyt w ścieżce pliku zamiast przesyłać go strumieniowo 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 zestaw 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

Pełne informacje o Dokumentacji API można znaleźć w dokumentacji dotyczącej stylizacji komórek IronXL oraz formatowania liczb IronXL.

Eksport do Excela z GridView w ASP .NET C#: Zaletyte rozwiązanie w C#: Ilustracja 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 umieścić 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.FileFormat.Xlsx)
Response.Flush()
Response.End()
$vbLabelText   $csharpLabel

Każdy DataTable.TableName staje się nazwą karty arkusza w programie Excel. 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:

  • Prawdziwe 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
  • Brak nadpisania VerifyRenderingInServerForm — eliminuje standardowe obejście, które zaśmieća 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 zapoznać się z porównaniem z innymi bibliotekami Excel, zobacz IronXL vs ClosedXML oraz przegląd funkcji IronXL.

Jakie są Twoje kolejne kroki?

Masz teraz wszystko, czego potrzebujesz, aby zastąpić starszą wersję eksportu HtmlTextWriter GridView czystą, pozbawioną 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
  • Zapoznaj się z Dokumentacją API — Dokumentacja API IronXL obejmuje wszystkie metody w WorkBook, WorkSheet oraz 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.

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

Powiązane artykuły

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

Zespol wsparcia Iron

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