Icône de message
Passer au contenu du pied de page
  1. Iron Software
  2. Blog IronXL
  3. Utilisation d'IronXL
  4. Exporter vers Excel à partir de Gridview
UTILISATION D'IRONXL

Comment exporter des données d'un GridView vers Excel en C# avec IronXL

Jordi Bardia
Jordi Bardia
Mis à jour:

L'exportation des données GridView vers un fichier Excel authentique est l'une des exigences les plus courantes des applications web ASP.NET . Les approches traditionnelles utilisant HtmlTextWriter et StringWriter créent de faux fichiers Excel qui déclenchent des avertissements du navigateur et des erreurs de format lorsque les utilisateurs essaient de les ouvrir. Ce guide vous montre comment exporter des données GridView vers des fichiers .xlsx correctement formatés à l'aide d'IronXL -- en éliminant les maux de tête auxquels les développeurs sont confrontés avec les anciennes méthodes.

Pourquoi l'approche traditionnelle d'exportation GridView pose-t-elle problème ?

La méthode classique pour exporter vers Excel à partir de GridView en ASP.NET C# implique le rendu HTML et la définition d'en-têtes Response avec des valeurs de nom de fichier de pièce jointe Content-Disposition. Cette approche nécessite de remplacer public override void VerifyRenderingInServerForm pour éviter les erreurs d'exécution. Le fichier résultant n'est pas un vrai fichier Excel - il s'agit d'un HTML déguisé avec une extension .xls, ce qui fait qu'Excel affiche des messages d'avertissement lorsque les utilisateurs l'ouvrent.

Plus précisément, la technique traditionnelle présente les inconvénients suivants :

Excel affiche un avertissement " Le format et l'extension du fichier ne correspondent pas " à chaque ouverture.

  • La mise en forme et les types de données sont perdus car les données sont stockées sous forme de HTML brut.
  • Vous devez mettre en œuvre VerifyRenderingInServerForm comme solution de contournement, ce qui ajoute une dette technique à votre projet Le fichier résultant ne contient pas les métadonnées de cellule appropriées, ce qui le rend inutilisable pour l'automatisation ou les outils de reporting en aval.

IronXL résout ces problèmes en créant de véritables fichiers .xlsx Excel sans nécessiter l'installation de Microsoft Office sur le serveur. Vous obtenez un fichier que n'importe quelle application tableur peut ouvrir sans problème, avec des types de données, un style et une structure OOXML corrects et préservés.

Comment installer IronXL dans votre projet ASP.NET ?

Avant d'écrire toute logique d'exportation, ajoutez IronXL à votre projet à l'aide du gestionnaire de packages NuGet . Ouvrez la console du Package Manager dans Visual Studio et exécutez :

Install-Package IronXl.Excel
Install-Package IronXl.Excel
SHELL

Vous pouvez également rechercher IronXl.Excel dans l'interface utilisateur du gestionnaire de paquets NuGet et l'installer à partir de là. Une fois installé, vous pouvez faire référence à l'espace de noms IronXL dans n'importe quel fichier code-behind.

IronXL cible .NET Standard 2.0 et versions ultérieures, il fonctionne donc aussi bien avec les projets ASP.NET Core modernes qu'avec les applications ASP.NET Framework classiques. Aucune interopérabilité COM, aucune installation d'Office et aucune dépendance native supplémentaire ne sont requises sur votre serveur web.

Pour plus de détails, consultez le guide d'installation d'IronXL et la page du package NuGet IronXL.

Comment configurer le contrôle GridView ASP.NET pour l'exportation ?

Créez votre page Default.aspx avec un contrôle GridView et un bouton d'exportation. Le balisage est standard pour les formulaires Web :

<%@ 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

Ce balisage crée une page simple avec un lien GridView et un bouton qui déclenche l'exportation. L'attribut AutoGenerateColumns="true" signifie que la grille lit les noms de colonnes directement à partir du DataTable lié.

Liaison des exemples de données à la grille

Dans votre code-behind, liez un DataTable à la grille et stockez-le dans Session pour une utilisation ultérieure lors du postback d'exportation :

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

Le stockage du DataTable dans le Session évite de réinterroger la base de données ou de reconstruire les données lors du postback déclenché par le bouton d'exportation. Pour les applications réelles, remplacez les lignes codées en dur par une requête de base de données utilisant Entity Framework ou .NET .

Exportation vers Excel depuis GridView en ASP .NET C# : Une solution C# propre : Image 1 - Interface utilisateur montrant l'exemple de données GridView

Comment exporter des données GridView vers Excel à l'aide IronXL?

L'approche propre de l'exportation GridView convertit votre DataTable en une WorkBook IronXL et transmet le résultat directement au navigateur. Voici la méthode d'exportation complète :

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

Comment fonctionne l'exportation étape par étape

Le processus se décompose en trois étapes logiques :

  1. Retrieve the DataTable -- Session["GridData"] renvoie la même DataTable qui était liée à la grille. Cela évite les appels de base de données en double.
  2. Inconvénientstruire le livre de travail -- WorkBook.LoadWorkSheetsFromDataSet crée automatiquement une feuille de calcul par DataTable dans le DataSet, en copiant les en-têtes de colonne et les valeurs de ligne dans les cellules appropriées.
  3. Stream to the browser -- Le fait de définir Content-Type comme type MIME OOXML et d'écrire dans Response.OutputStream déclenche un téléchargement dans le navigateur avec l'extension .xlsx correcte. Aucun fichier temporaire n'est écrit sur le disque.

Il s'agit d'une approche fondamentalement différente de l'approche traditionnelle HtmlTextWriter. Le fichier exporté utilise le format Open XML — le même format que celui utilisé nativement par Microsoft Excel — il s'ouvre donc sans avertissement.

Pour plus d'informations sur le chargement de données par programmation, consultez la documentation IronXL WorkBook et la procédure d'exportation de DataTable vers Excel en C# .

Exportation vers Excel depuis GridView en ASP .NET C# : Une solution C# propre : Image 2 - Fichier Excel exporté

Comment enregistrer le fichier Excel sur disque au lieu de le diffuser en continu ?

Si votre application doit archiver les exportations sur le serveur avant de fournir un lien de téléchargement à l'utilisateur, enregistrez le classeur dans un chemin de fichier plutôt que de le diffuser vers 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

Choisir entre le streaming et l'enregistrement sur disque

Comparaison des stratégies d'exportation en continu et sur disque
Stratégie Avantages Inconvénients Idéal pour
Diffuser vers le navigateur Aucune utilisation de disque, livraison immédiate Impossible d'archiver ou de renvoyer Exportations utilisateur à la demande
Enregistrer sur le disque Le fichier est conservé pour vérification, téléchargement ultérieur ou envoi par courriel. Nécessite une tâche de nettoyage et la gestion de l'espace disque. Rapports programmés, pistes d'audit

Pour la plupart des applications web interactives, la diffusion directe vers le navigateur est la solution idéale. Enregistrez le fichier sur le disque dur uniquement si vous devez l'envoyer par courriel, le conserver à des fins de conformité ou autoriser les téléchargements ultérieurs depuis une page de gestion de fichiers.

Comment appliquer une mise en forme avancée à la feuille Excel exportée ?

IronXL vous offre un contrôle précis sur les styles de cellules, la largeur des colonnes, les formats de nombres, et bien plus encore. L'exemple suivant montre comment créer une exportation de style professionnel :

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

Options de mise en forme disponibles dans IronXL

IronXL expose un riche ensemble de propriétés de formatage à travers l'espace de noms IronXl.Styles :

  • Style de police : gras, italique, souligné, famille de polices et taille
  • Couleurs d'arrière-plan des cellules : les chaînes de couleurs hexadécimales sont acceptées directement.
  • Formats de nombres et de dates : toute chaîne de format Excel, y compris les modèles de devises, de pourcentages et de dates
  • Largeur de colonne -- largeur en pixels manuelle ou AutoSizeColumn pour un ajustement automatique
  • Figer les volets : verrouiller les lignes ou colonnes d'en-tête pendant le défilement
  • Bordures des cellules : les quatre bordures sont personnalisables en termes de style et de couleur.
  • Fusionner les cellules -- combiner les cellules de plusieurs lignes ou colonnes pour les en-têtes de rapport

Pour consulter la référence API complète, voir la documentation sur la mise en forme des cellules IronXL et le formatage des nombres IronXL.

Exportation vers Excel depuis GridView en ASP .NET C# : Une solution C# propre : Image 3 - Document Excel formaté exporté

Comment gérer les grands ensembles de données lors des exportations GridView ?

Lorsque le GridView est lié à des milliers de lignes, quelques techniques permettent de garantir une exportation rapide et économe en mémoire :

Pagination et tableau de données côté serveur

N'exportez pas uniquement la page visible du GridView. Récupérez l'ensemble des données de votre source de données dans un DataTable avant d'appeler WorkBook.LoadWorkSheetsFromDataSet. IronXL écrit les lignes en une seule passe sans charger plusieurs fois l'intégralité du classeur en mémoire, ce qui le rend adapté aux dizaines de milliers de lignes.

Ajout de plusieurs feuilles de calcul

Vous pouvez inclure plusieurs objets DataTable dans le DataSet pour produire un classeur avec des onglets séparés :

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

Chaque DataTable.TableName devient le nom de l'onglet de la feuille de calcul dans Excel. Ce modèle convient parfaitement aux rapports de gestion qui combinent des données connexes issues de plusieurs vues.

Guides associés :

Quels sont les principaux avantages de l'utilisation IronXL pour l'exportation GridView ?

L'utilisation IronXL pour exporter les données de GridView offre des avantages indéniables par rapport à l'approche traditionnelle d'encapsulation HTML :

  • Fichiers Excel authentiques -- crée un format .xlsx valide qui s'ouvre sans avertissement ni message d'erreur du navigateur
  • Aucune installation d'Office requise -- fonctionne sur n'importe quel serveur web sans interopérabilité avec Microsoft Excel ou Office
  • No VerifyRenderingInServerForm override -- élimine les solutions de contournement de type "boilerplate" qui encombrent le code traditionnel
  • Contrôle total de la mise en forme : stylisez les cellules, appliquez des formats numériques, figez les volets et créez des feuilles de calcul Professional par programmation.
  • Prise en charge de plusieurs feuilles : exportez les ensembles de données associés sous forme d'onglets distincts dans un seul classeur.
  • Compatibilité multiplateforme : fonctionne correctement sur les serveurs Windows et Linux, y compris les conteneurs Docker et Azure App Service

La bibliothèque est disponible sur NuGet et prend en charge toutes les cibles .NET modernes, y compris .NET 10. Elle prend également en charge la lecture et l'écriture d'autres formats tels que CSV et ODS, ce qui en fait une dépendance unique pour tous les besoins de tableur de votre application.

Pour une comparaison côte à côte avec d'autres bibliothèques Excel, voir IronXL vs ClosedXML et la présentation des fonctionnalités IronXL .

Quelles sont vos prochaines étapes ?

Vous disposez désormais de tout ce dont vous avez besoin pour remplacer l'ancienne exportation HtmlTextWriter GridView par une implémentation IronXL propre et sans avertissement. Voici comment procéder :

  • Essayez la version d'essai gratuite : démarrez un essai gratuit de 30 jours d' IronXL , sans carte de crédit, et testez le code d'exportation dans votre propre projet.
  • Explorez d'autres tutoriels IronXL : le blog IronXL aborde l'importation de données, les formules de cellules, la génération de graphiques et les flux de travail des modèles Excel.
  • Lisez la référence API -- la documentation API IronXL couvre chaque méthode sur WorkBook, WorkSheet, et l'API de stylisme
  • Comparez les options de licence : consultez les tarifs IronXL pour trouver la licence adaptée à la taille de votre équipe et à votre scénario de déploiement.
  • Posez une question : l'équipe d'assistance d'Iron Software et les forums communautaires sont à votre disposition si vous rencontrez un problème inattendu

Questions Fréquemment Posées

Pourquoi utiliser IronXL pour exporter les données de GridView vers Excel ?

IronXL vous permet de créer de véritables fichiers XLSX à partir de GridView dans ASP.NET C# sans les problèmes courants associés à HtmlTextWriter et StringWriter, tels que les avertissements du navigateur et les erreurs de formatage.

Quelles sont les limitations de l'utilisation de HtmlTextWriter pour l'exportation vers Excel ?

HtmlTextWriter crée souvent de faux fichiers Excel, ce qui peut provoquer des avertissements du navigateur et des problèmes de mise en forme. IronXL résout ces problèmes en générant de véritables fichiers Excel.

Comment IronXL améliore-t-il le processus d'exportation de données depuis GridView ?

IronXL simplifie l'exportation de données depuis GridView en permettant aux développeurs de générer des fichiers Excel correctement formatés directement depuis leurs applications ASP.NET , évitant ainsi le recours à des solutions de contournement basées sur HTML.

Quel format de fichier IronXL utilise-t-il pour les fichiers Excel exportés ?

IronXL exporte les données vers de véritables fichiers XLSX, garantissant ainsi la compatibilité et un formatage correct lors de leur ouverture dans Excel.

IronXL peut-il résoudre les problèmes de formatage lors de l'exportation vers Excel ?

Oui, IronXL élimine les problèmes de formatage en créant de véritables fichiers Excel, ce qui garantit que les données s'affichent correctement sans déclencher d'avertissements du navigateur.

Existe-t-il un exemple de code pour exporter des données GridView avec IronXL?

Oui, le tutoriel inclut des exemples de code montrant comment utiliser IronXL pour exporter efficacement les données de GridView vers Excel.

IronXL prend-il en charge l'exportation de grands ensembles de données depuis GridView ?

IronXL est conçu pour gérer efficacement de grands ensembles de données, ce qui le rend adapté à l'exportation de données volumineuses de GridView vers Excel.

Quels sont les avantages de l'utilisation IronXL par rapport aux méthodes traditionnelles d'exportation Excel ?

IronXL offre une solution plus fiable et efficace, éliminant les avertissements du navigateur, garantissant un formatage correct des fichiers et fournissant une implémentation de code simple pour l'exportation des données GridView.

Jordi Bardia
Jordi Bardia
  Discutez maintenant avec l'équipe d'ingénierie
Ingénieur logiciel
Jordi est le plus compétent en Python, C# et C++, et lorsqu'il ne met pas à profit ses compétences chez Iron Software, il programme des jeux. Partageant les responsabilités des tests de produit, du développement de produit et de la recherche, Jordi apporte une immense valeur à l'amé...
Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Essai gratuit

Équipe de soutien Iron

Nous sommes en ligne 24 heures sur 24, 5 jours sur 7.
Chat
Email
Appelez-moi