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

Exporter GridView au format Excel XLSX C# avec IronXL

Jordi Bardia
Jordi Bardia
Publié:

Exportation des données d'un contrôle GridView ASP.NET vers un fichier Excel

L'exportation de données d'un contrôle GridView ASP.NET vers un fichier Excel est une fonctionnalité courante des applications .NET Framework et des applications .NET modernes. Dans les formulaires Web ASP.NET, cette opération est souvent initiée à l'aide de contrôles serveur tels que asp:Button . Qu'il s'agisse de générer des rapports pour la direction, de partager des ensembles de données avec les parties prenantes ou de créer des feuilles de calcul téléchargeables pour les utilisateurs finaux, les développeurs ont besoin d'un moyen fiable de convertir le contenu de GridView en fichiers .XLSX correctement formatés qui préservent l'intégrité et la structure des données.

Cet article explique comment réaliser ce processus d'exportation à l'aide d' IronXL , une puissante bibliothèque .NET pour la création de fichiers Excel. Contrairement aux approches d'interopérabilité Excel qui nécessitent l'installation de MS Excel et rencontrent des difficultés dans les environnements de serveurs Web, IronXL fonctionne exclusivement avec du code pour générer des documents Excel natifs. La bibliothèque prend en charge les formats de sortie .XLSX , .XLS et CSV sans nécessiter Microsoft Office sur le serveur. IronXL, Syncfusion XlsIO et LargeXlsx conviennent également à la gestion de grands ensembles de données et offrent des fonctionnalités robustes sans nécessiter Microsoft Office.

Ce guide explique comment exporter un GridView au format Excel XLSX C# à l'aide d'IronXL, avec des exemples de code complets et fonctionnels. Chaque exemple comprend des structures de classes complètes avec object/byval sender et des paramètres EventArgs e , des explications détaillées pour aider les développeurs à comprendre à la fois l'implémentation et les concepts sous-jacents, ainsi que des techniques pratiques pour votre prochain projet Visual Studio. Pour les applications Web, n'oubliez pas de définir le type MIME de réponse sur application/vnd.openxmlformats-officedocument.spreadsheetml.sheet lors de la distribution de fichiers .XLSX afin de garantir que le navigateur déclenche le téléchargement du fichier.

Introduction à l'exportation de GridView

L'exportation d'un GridView vers un fichier Excel est une exigence fréquente dans les applications web modernes, notamment lorsque les utilisateurs ont besoin d'analyser, de partager ou d'archiver des données en dehors de l'application. En convertissant les données de GridView en un fichier Excel, vous permettez une importation transparente dans Microsoft Excel, ce qui facilite le travail des utilisateurs avec les données dans un environnement familier. Cet article explore les méthodes les plus efficaces pour exporter un GridView vers un fichier Excel, en se concentrant sur des solutions pratiques qui fonctionnent sur différents projets web .NET.

Comment exporter les données de GridView vers une feuille Excel par programmation ?

L'exportation par programmation des données GridView vers une feuille de calcul Excel implique l'extraction des données liées au contrôle et leur écriture dans une structure de classeur Excel. IronXL simplifie ce processus d'exportation en fournissant une API intuitive qui gère en interne la complexité du format de feuille de calcul Open XML. Les développeurs travaillent avec des concepts familiers tels que les classeurs, les feuilles de calcul, les lignes et les colonnes plutôt que de manipuler directement les schémas XML.

// Quick example: Create an Excel file with IronXL
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("Data");
worksheet["A1"].Value = "Hello from IronXL";
workbook.SaveAs("output.xlsx");
// Quick example: Create an Excel file with IronXL
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("Data");
worksheet["A1"].Value = "Hello from IronXL";
workbook.SaveAs("output.xlsx");
$vbLabelText   $csharpLabel

Remarque : En VB.NET, l'initialisation des objets pour le classeur et la feuille de calcul se fait généralement à l'aide des instructions Dim workbook et Dim worksheet . Ces éléments correspondent à la création d'objets C# illustrée ci-dessus, où WorkBook workbook et WorkSheet worksheet sont utilisés pour créer et configurer les objets Excel.

Sortie

Exporter un GridView vers Excel XLSX en C# avec IronXL : Image 1 - Sortie Excel

Comment configurer IronXL dans mon projet ASP.NET ?

L'installation d'IronXL ne prend que quelques secondes grâce au gestionnaire de packages NuGet dans Visual Studio. Ouvrez la console du gestionnaire de packages et exécutez le code suivant :

Install-Package IronXL.Excel
Install-Package IronXL.Excel
SHELL

Exporter GridView vers Excel XLSX C# avec IronXL : Image 2 - Installation

Vous pouvez également cliquer avec le bouton droit sur votre projet dans l'Explorateur de solutions, sélectionner " Gérer les packages NuGet ", rechercher " IronXL " et cliquer sur Installer. Le package ajoute automatiquement toutes les références et dépendances nécessaires à votre projet. IronXL prend en charge les applications .NET Framework (4.6.2 et versions ultérieures), ainsi que .NET Core et .NET 5/6/7/8, vous offrant une grande flexibilité pour différents types de projets et configurations de formulaires Web.

Après l'installation, ajoutez l'espace de noms IronXL ainsi que l'espace de noms System à votre fichier code-behind :

using System;
using System.Data;
using IronXL;
using System;
using System.Data;
using IronXL;
$vbLabelText   $csharpLabel

Comment exporter un GridView vers un fichier Excel ?

Le code suivant illustre l'exportation d'un contrôle GridView ASP.NET vers un fichier Excel lorsqu'un utilisateur clique sur un bouton d'exportation. Cet exemple utilise une structure de classes complète, typique des applications Web Forms.

Premièrement, le balisage ASPX définit un<asp:GridView> et<asp:Button> avec les attributs runat=&quot;server&quot; , qui sont des contrôles ASP.NET standard :

<asp:GridView ID="gvEmployees" runat="server" AutoGenerateColumns="true">
</asp:GridView>
<asp:Button ID="btnExport" runat="server" Text="Export to Excel" OnClick="btnExport_Click" />
<asp:GridView ID="gvEmployees" runat="server" AutoGenerateColumns="true">
</asp:GridView>
<asp:Button ID="btnExport" runat="server" Text="Export to Excel" OnClick="btnExport_Click" />
XML

Le fichier code-behind contient la méthode de liaison des données et la logique d'exportation :

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

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

    private void BindGridView()
    {
        // Create new DataTable as data source
        DataTable dt = new DataTable();
        dt.Columns.Add("EmployeeID", typeof(int));
        dt.Columns.Add("Name", typeof(string));
        dt.Columns.Add("Department", typeof(string));
        dt.Columns.Add("Salary", typeof(decimal));
        dt.Rows.Add(1, "John Smith", "Engineering", 75000);
        dt.Rows.Add(2, "Sarah Johnson", "Marketing", 65000);
        dt.Rows.Add(3, "Michael Chen", "Finance", 70000);
        ViewState["EmployeeData"] = dt;
        gvEmployees.DataSource = dt;
        gvEmployees.DataBind();
    }

    protected void btnExport_Click(object sender, EventArgs e)
    {
        // Create new Excel workbook and worksheet
        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet worksheet = workbook.CreateWorkSheet("Employees");
        for (int j = 0; j < gvEmployees.HeaderRow.Cells.Count; j++)
        {
            worksheet.SetCellValue(0, j, gvEmployees.HeaderRow.Cells[j].Text);
        }
        // Export GridView data to Excel worksheet
        for (int i = 0; i < gvEmployees.Rows.Count; i++)
        {
            for (int j = 0; j < gvEmployees.Rows[i].Cells.Count; j++)
            {
                string cellValue = gvEmployees.Rows[i].Cells[j].Text;
                worksheet.SetCellValue(i + 1, j, cellValue);
            }
        }
        // Save Excel file to server path
        string filename = Server.MapPath("~/Exports/EmployeeData.xlsx");
        workbook.SaveAs(filename);
    }
}
using System;
using System.Data;
using System.Web.UI;
using IronXL;

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

    private void BindGridView()
    {
        // Create new DataTable as data source
        DataTable dt = new DataTable();
        dt.Columns.Add("EmployeeID", typeof(int));
        dt.Columns.Add("Name", typeof(string));
        dt.Columns.Add("Department", typeof(string));
        dt.Columns.Add("Salary", typeof(decimal));
        dt.Rows.Add(1, "John Smith", "Engineering", 75000);
        dt.Rows.Add(2, "Sarah Johnson", "Marketing", 65000);
        dt.Rows.Add(3, "Michael Chen", "Finance", 70000);
        ViewState["EmployeeData"] = dt;
        gvEmployees.DataSource = dt;
        gvEmployees.DataBind();
    }

    protected void btnExport_Click(object sender, EventArgs e)
    {
        // Create new Excel workbook and worksheet
        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet worksheet = workbook.CreateWorkSheet("Employees");
        for (int j = 0; j < gvEmployees.HeaderRow.Cells.Count; j++)
        {
            worksheet.SetCellValue(0, j, gvEmployees.HeaderRow.Cells[j].Text);
        }
        // Export GridView data to Excel worksheet
        for (int i = 0; i < gvEmployees.Rows.Count; i++)
        {
            for (int j = 0; j < gvEmployees.Rows[i].Cells.Count; j++)
            {
                string cellValue = gvEmployees.Rows[i].Cells[j].Text;
                worksheet.SetCellValue(i + 1, j, cellValue);
            }
        }
        // Save Excel file to server path
        string filename = Server.MapPath("~/Exports/EmployeeData.xlsx");
        workbook.SaveAs(filename);
    }
}
$vbLabelText   $csharpLabel

Cette implémentation crée une nouvelle instance WorkBook lorsque l'utilisateur clique sur le bouton d'exportation. Les boucles imbriquées parcourent chaque ligne de GridView en utilisant int i comme index de ligne et écrivent les valeurs des cellules dans les positions correspondantes de la feuille de calcul Excel à l'aide de la méthode SetCellValue .

Sortie

Exporter un GridView vers Excel XLSX en C# avec IronXL : Image 3 - Sortie du GridView

Exporter un GridView vers Excel XLSX en C# avec IronXL : Image 4 - Sortie du GridView vers Excel

En VB.NET, cette logique d'exportation se trouve généralement à l'intérieur d'une procédure pilotée par DataTable qui commence par Sub et se termine par End Sub , renforçant ainsi la structure familière de fin de sous-routine de table de données utilisée dans les projets Web Forms ASP.NET classiques.

Comment ajouter des en-têtes de colonnes et une mise en forme de base ?

L'exemple précédent exporte les lignes de données mais omet les en-têtes de colonnes. Cette version améliorée inclut les en-têtes extraits de la GridView et applique une mise en forme de base pour une meilleure lisibilité dans le fichier Excel de sortie.

protected void btnExport_Click(object sender, EventArgs e)
{
    WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
    WorkSheet worksheet = workbook.CreateWorkSheet("Employees");
    // Write column headers from GridView to Excel sheet
    int columnCount = gvEmployees.HeaderRow.Cells.Count;
    for (int i = 0; i < columnCount; i++)
    {
        string headerText = gvEmployees.HeaderRow.Cells[i].Text;
        worksheet.SetCellValue(0, i, headerText);
    }
    // Write data rows starting from row 1
    int rowCount = gvEmployees.Rows.Count;
    for (int i = 0; i < rowCount; i++)
    {
        for (int j = 0; j < gvEmployees.Rows[i].Cells.Count; j++)
        {
            string cellValue = gvEmployees.Rows[i].Cells[j].Text;
            worksheet.SetCellValue(i + 1, j, cellValue);
        }
    }
    // Apply column auto-fit formatting for better display
    worksheet.AutoSizeColumn(0);
    worksheet.AutoSizeColumn(1);
    worksheet.AutoSizeColumn(2);
    worksheet.AutoSizeColumn(3);
    string filename = Server.MapPath("~/Exports/EmployeeReport.xlsx");
    workbook.SaveAs(filename);
}
protected void btnExport_Click(object sender, EventArgs e)
{
    WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
    WorkSheet worksheet = workbook.CreateWorkSheet("Employees");
    // Write column headers from GridView to Excel sheet
    int columnCount = gvEmployees.HeaderRow.Cells.Count;
    for (int i = 0; i < columnCount; i++)
    {
        string headerText = gvEmployees.HeaderRow.Cells[i].Text;
        worksheet.SetCellValue(0, i, headerText);
    }
    // Write data rows starting from row 1
    int rowCount = gvEmployees.Rows.Count;
    for (int i = 0; i < rowCount; i++)
    {
        for (int j = 0; j < gvEmployees.Rows[i].Cells.Count; j++)
        {
            string cellValue = gvEmployees.Rows[i].Cells[j].Text;
            worksheet.SetCellValue(i + 1, j, cellValue);
        }
    }
    // Apply column auto-fit formatting for better display
    worksheet.AutoSizeColumn(0);
    worksheet.AutoSizeColumn(1);
    worksheet.AutoSizeColumn(2);
    worksheet.AutoSizeColumn(3);
    string filename = Server.MapPath("~/Exports/EmployeeReport.xlsx");
    workbook.SaveAs(filename);
}
$vbLabelText   $csharpLabel

La propriété HeaderRow permet d'accéder aux en-têtes de colonnes du GridView, qui sont écrits sur la ligne 0 de la feuille de calcul Excel. Les lignes de données se remplissent ensuite à partir de la ligne 1 (notez le décalage i + 1 dans l'appel SetCellValue ). Ce décalage est essentiel pour éviter d'écraser la ligne d'en-tête avec des données.

Comment exporter des données à l'aide de ViewState ?

Lorsque le contrôle GridView est lié à un DataTable , l'accès direct à la DataSource offre un code plus propre et de meilleures performances que l'itération sur les éléments HTML de l'interface utilisateur.

protected void btnExport_Click(object sender, EventArgs e)
{
    // Cast DataSource to DataTable
    DataTable sourceData = ViewState["EmployeeData"] as DataTable;
    if (sourceData == null)
        return; // or show error
    // In VB.NET, this would be declared as: Dim dt As DataTable
    // Create new workbook and worksheet
    WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
    WorkSheet worksheet = workbook.CreateWorkSheet("Report");
    // Write headers from DataTable columns
    for (int i = 0; i < sourceData.Columns.Count; i++)
    {
        worksheet.SetCellValue(0, i, sourceData.Columns[i].ColumnName);
    }
    // Write data rows to Excel
    for (int i = 0; i < sourceData.Rows.Count; i++)
    {
        for (int j = 0; j < sourceData.Columns.Count; j++)
        {
            worksheet.SetCellValue(i + 1, j, sourceData.Rows[i][j].ToString());
        }
    }
    string filename = Server.MapPath("~/Exports/DataExport.xlsx");
    workbook.SaveAs(filename);
}
protected void btnExport_Click(object sender, EventArgs e)
{
    // Cast DataSource to DataTable
    DataTable sourceData = ViewState["EmployeeData"] as DataTable;
    if (sourceData == null)
        return; // or show error
    // In VB.NET, this would be declared as: Dim dt As DataTable
    // Create new workbook and worksheet
    WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
    WorkSheet worksheet = workbook.CreateWorkSheet("Report");
    // Write headers from DataTable columns
    for (int i = 0; i < sourceData.Columns.Count; i++)
    {
        worksheet.SetCellValue(0, i, sourceData.Columns[i].ColumnName);
    }
    // Write data rows to Excel
    for (int i = 0; i < sourceData.Rows.Count; i++)
    {
        for (int j = 0; j < sourceData.Columns.Count; j++)
        {
            worksheet.SetCellValue(i + 1, j, sourceData.Rows[i][j].ToString());
        }
    }
    string filename = Server.MapPath("~/Exports/DataExport.xlsx");
    workbook.SaveAs(filename);
}
$vbLabelText   $csharpLabel

Cette approche extrait les noms de colonnes directement de la collection Columns de la DataTable et récupère les valeurs des cellules à partir des objets DataRow . L'utilisation de la source de données sous-jacente élimine les dépendances au rendu GridView et fournit des résultats cohérents quel que soit l'état visuel du contrôle, la configuration de pagination ou les paramètres d'affichage par défaut.

Sortie

Exporter un GridView vers Excel XLSX en C# avec IronXL : Image 5 - Exporter en utilisant la sortie ViewState

Pour les scénarios impliquant de grands ensembles de données ou des opérations d'importation de données, IronXL prend en charge des opérations de feuille de calcul efficaces qui gèrent des milliers de lignes sans problèmes de mémoire. La bibliothèque peut également charger et lire des fichiers Excel existants pour les flux de travail de traitement des données.

Gestion des erreurs et des sorties

Lors de l'exportation d'un GridView vers un fichier Excel, il est important de s'assurer que le processus d'exportation est fiable et convivial. Les erreurs peuvent survenir pour diverses raisons, telles que des problèmes d'autorisation de fichiers, des données invalides ou des exceptions inattendues ; une gestion robuste des erreurs est donc essentielle. En intégrant votre logique d'exportation dans un bloc try-catch, vous pouvez gérer avec élégance tout problème qui pourrait survenir et fournir un retour d'information clair à l'utilisateur.

De plus, la personnalisation du résultat de votre processus d'exportation améliore l'expérience utilisateur. Vous pouvez spécifier le nom du fichier, choisir le format de fichier approprié et définir la disposition du contenu pour contrôler la manière dont le fichier Excel est livré à l'utilisateur (par exemple, en tant que pièce jointe à télécharger).

Le code suivant illustre comment gérer les erreurs et les résultats lors de l'exportation d'un GridView vers un fichier Excel :

try
{
    // Export GridView to Excel file
    GridViewExport.ExcelExport(GridView1, "ExportedData");
    Response.Write("Export successful! Your Excel file is ready.");
}
catch (Exception ex)
{
    // Handle exception and inform the user
    Response.Write("Error exporting data: " + ex.Message);
}
try
{
    // Export GridView to Excel file
    GridViewExport.ExcelExport(GridView1, "ExportedData");
    Response.Write("Export successful! Your Excel file is ready.");
}
catch (Exception ex)
{
    // Handle exception and inform the user
    Response.Write("Error exporting data: " + ex.Message);
}
$vbLabelText   $csharpLabel

Dans cet exemple, le processus d'exportation est enveloppé dans un bloc try-catch. Si l'exportation réussit, un message de confirmation s'affiche pour l'utilisateur. En cas d'erreur, le bloc catch capture l'exception et affiche un message d'erreur, informant ainsi l'utilisateur de l'état de son exportation. Vous pouvez personnaliser davantage le résultat en définissant le nom du fichier, son type et les en-têtes de disposition du contenu afin de contrôler la manière dont le fichier Excel est présenté à l'utilisateur lors du téléchargement.

Conclusion

L'exportation des données ASP.NET GridView vers des fichiers Excel devient simple avec IronXL. La bibliothèque gère la création de classeurs, le remplissage des cellules et la génération de fichiers sans nécessiter de dépendances MS Excel ou Microsoft Office sur le serveur. Cela rend IronXL particulièrement adapté aux applications web où la génération de fichiers Excel côté serveur doit fonctionner de manière fiable dans différents environnements d'hébergement.

Les exemples de cet article montrent comment progresser graduellement, de l'exportation de base à l'inclusion des en-têtes de colonnes et à la mise en forme. L'approche DataTable présentée dans le dernier exemple offre la solution la plus robuste pour les applications .NET de production, garantissant l'intégrité des données quelle que soit la configuration GridView . L'ensemble complet de fonctionnalités d'IronXL prend également en charge la lecture de fichiers Excel existants , l'utilisation de formules et la gestion de plusieurs feuilles de calcul pour des scénarios de reporting plus complexes. La bibliothèque gère nativement les formats XLSX et XLS, et peut également générer des sorties CSV en cas de besoin.

Démarrez votre essai gratuit dès aujourd'hui pour implémenter l'exportation GridView vers Excel dans vos applications ASP.NET. Pour une utilisation en production, explorez les options de licence IronXL , notamment les licences perpétuelles avec assistance dédiée.

Questions Fréquemment Posées

Quel est l'objectif principal de l'utilisation d'IronXL pour exporter GridView vers Excel ?

IronXL est principalement utilisé pour faciliter l'exportation de données d'un GridView ASP.NET vers des formats Excel tels que XLSX, garantissant des performances élevées et une intégration facile dans les applications C#.

IronXL peut-il gérer de grands ensembles de données lors de l'exportation depuis GridView ?

Oui, IronXL est optimisé pour gérer efficacement les grands ensembles de données lors du processus d'exportation de GridView vers Excel, tout en maintenant la vitesse et les performances.

Est-il possible de personnaliser le fichier Excel généré lors de l'utilisation d'IronXL ?

Avec IronXL, vous pouvez personnaliser différents aspects de la sortie Excel, tels que la mise en forme, le style et l'inclusion de données ou de formules supplémentaires dans le fichier exporté.

Comment IronXL se compare-t-il aux autres bibliothèques d'exportation de GridView vers Excel ?

IronXL offre une approche plus simple et plus flexible que certaines autres bibliothèques, assurant une prise en charge robuste des formats Excel modernes et une intégration transparente avec les applications C#.

IronXL prend-il en charge l'exportation vers des formats autres que XLSX ?

Oui, IronXL prend en charge l'exportation vers différents formats Excel, notamment XLS, CSV et TSV, offrant ainsi une grande polyvalence pour répondre aux exigences de différents projets.

Quelles sont les conditions préalables à l'utilisation d'IronXL dans un projet ?

Pour utiliser IronXL, vous devrez disposer d'un environnement .NET configuré, et vous pourrez facilement intégrer IronXL en l'installant via NuGet dans votre projet C#.

IronXL peut-il exporter des données GridView de manière asynchrone ?

IronXL prend en charge les opérations asynchrones, permettant aux développeurs d'exporter les données GridView vers des fichiers Excel sans bloquer le thread principal de l'application.

Comment puis-je commencer à utiliser IronXL pour exporter un GridView vers Excel ?

Pour commencer, vous pouvez vous référer à la documentation et aux exemples d'IronXL, qui fournissent des instructions étape par étape sur la configuration et l'exécution des exportations de données de GridView vers Excel.

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