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

Comment exporter un GridView au format Excel XLSX en C# avec IronXL

Jordi Bardia
Jordi Bardia
Mis à jour:

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

Vous pouvez exporter un GridView ASP.NET vers un fichier Excel XLSX en C# en installant IronXL , en créant un WorkBook, en itérant sur les lignes du GridView, en écrivant la valeur de chaque cellule à la position correspondante de la feuille de calcul et en enregistrant le classeur sur le disque ou le flux de réponse HTTP. Cette approche ne nécessite aucune installation de Microsoft Office sur le serveur et fonctionne de manière fiable avec les applications web .NET Framework, .NET Core et .NET 5 à .NET 10.

L'exportation des données GridView vers Excel est une exigence standard dans les projets Web Forms ASP.NET d'entreprise. Les utilisateurs doivent extraire les données tabulaires du navigateur et les importer dans des feuilles de calcul pour la création de rapports, l'analyse hors ligne et l'archivage. Le défi consiste à combler le fossé entre le contrôle côté serveur GridView et un fichier .xlsx correctement structuré -- sans introduire de dépendances Office Interop qui se cassent dans les environnements de serveur Web.

Ce guide vous présente trois modèles d'exportation de plus en plus riches : une exportation minimale ligne par ligne, une exportation en-tête et données avec dimensionnement automatique des colonnes et une exportation pilotée par DataTable qui contourne entièrement le HTML rendu. Chaque exemple utilise du code compatible avec les instructions de niveau supérieur C# et l'API IronXL.

Comment installer IronXLdans un projet ASP.NET ?

Ouvrez la Console du Gestionnaire de Packages dans Visual Studio et exécutez :

Install-Package IronXL
dotnet add package IronXL
Install-Package IronXL
dotnet add package IronXL
SHELL

Vous pouvez également cliquer avec le bouton droit sur le projet dans l'Explorateur de solutions , choisir Gérer les packages NuGet , rechercher IronXL et cliquer sur Installer . NuGet résout automatiquement toutes les dépendances transitives.

Une fois le package installé, ajoutez les directives using suivantes à votre fichier code-behind :

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

IronXL prend en charge .NET Framework 4.6.2 et versions ultérieures , ainsi que .NET Core 3.1 et .NET 5 à .NET 10. Aucune installation d'Office ni enregistrement COM n'est requis sur le serveur. La documentation complète de l'API est disponible dans la référence d'objet IronXL .

Quel ID de package NuGet devez-vous utiliser ?

L'identifiant de package correct est IronXL (et non IronXl.Excel, qui est un alias obsolète). Après l'installation, l'assemblage IronXL.dll est référencé automatiquement. Vous pouvez vérifier la version installée en consultant le nœud Packages dans l'explorateur de solutions ou en exécutant dotnet list package depuis le répertoire du projet.

IronXLfonctionne-t-il avec les applications Web ASP.NET Core ?

Oui. La même API fonctionne aussi bien dans les projets ASP.NET Web Forms que dans les projets ASP.NET Core (MVC ou Razor Pages). Dans les projets Core, remplacez Server.MapPath par IWebHostEnvironment.WebRootPath ou Path.Combine(Directory.GetCurrentDirectory(), "Exports") lors de la construction des chemins de fichiers côté serveur.

Comment exporter un GridView vers un fichier Excel ?

Le modèle d'exportation le plus simple parcourt chaque ligne rendue dans le GridView et copie le texte de chaque cellule dans la cellule correspondante de la feuille de calcul Excel. Dans le balisage ASPX, ajoutez un contrôle <asp:GridView ID="gvEmployees" runat="server" AutoGenerateColumns="true" /> et un bouton <asp:Button ID="btnExport" runat="server" Text="Export to Excel" OnClick="btnExport_Click" />. L'attribut runat="server" rend les deux contrôles accessibles dans le code-behind.

Le code-behind lie des exemples de données lors du premier chargement et les exporte lors d'un clic sur un bouton :

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()
    {
        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)
    {
        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet worksheet = workbook.CreateWorkSheet("Employees");

        // Write header row
        for (int j = 0; j < gvEmployees.HeaderRow.Cells.Count; j++)
        {
            worksheet.SetCellValue(0, j, gvEmployees.HeaderRow.Cells[j].Text);
        }

        // Write data rows
        for (int i = 0; i < gvEmployees.Rows.Count; i++)
        {
            for (int j = 0; j < gvEmployees.Rows[i].Cells.Count; j++)
            {
                worksheet.SetCellValue(i + 1, j, gvEmployees.Rows[i].Cells[j].Text);
            }
        }

        string filePath = Server.MapPath("~/Exports/EmployeeData.xlsx");
        workbook.SaveAs(filePath);
    }
}
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()
    {
        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)
    {
        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet worksheet = workbook.CreateWorkSheet("Employees");

        // Write header row
        for (int j = 0; j < gvEmployees.HeaderRow.Cells.Count; j++)
        {
            worksheet.SetCellValue(0, j, gvEmployees.HeaderRow.Cells[j].Text);
        }

        // Write data rows
        for (int i = 0; i < gvEmployees.Rows.Count; i++)
        {
            for (int j = 0; j < gvEmployees.Rows[i].Cells.Count; j++)
            {
                worksheet.SetCellValue(i + 1, j, gvEmployees.Rows[i].Cells[j].Text);
            }
        }

        string filePath = Server.MapPath("~/Exports/EmployeeData.xlsx");
        workbook.SaveAs(filePath);
    }
}
$vbLabelText   $csharpLabel

L'appel WorkBook.Create(ExcelFileFormat.XLSX) initialise un classeur en mémoire ciblant le format moderne Open XML. CreateWorkSheet("Employees") ajoute la première feuille. La boucle externe (i) avance à travers les lignes de données ; la boucle interne (j) avance à travers les colonnes. L'index de ligne i + 1 est utilisé pour les cellules de données afin que l'en-tête de la ligne 0 ne soit pas écrasé.

Pourquoi utiliser IronXLplutôt qu'Excel Interop ?

Excel Interop nécessite une copie sous licence de Microsoft Excel installée sur le serveur et crée des objets COM qui doivent être explicitement libérés pour éviter les fuites de mémoire. IronXLlit et écrit directement les fichiers .xlsx sous forme de packages Open XML -- pas de COM, pas d'Office, pas de Marshal.ReleaseComObject de code répétitif. Cela le rend fiable dans IIS, Azure App Service, Docker et autres environnements serveur où Office n'est pas disponible.

Quel est le type MIME correct pour les téléchargements XLSX ?

Lorsque vous souhaitez que le navigateur affiche une boîte de dialogue d'enregistrement de fichier au lieu de servir les octets en ligne, définissez le type de contenu de la réponse sur application/vnd.openxmlformats-officedocument.spreadsheetml.sheet et ajoutez un en-tête Content-Disposition: attachment avant d'écrire les octets du classeur dans le flux de réponse.

Comment ajouter des en-têtes de colonnes et dimensionner automatiquement les colonnes ?

L'exemple de base écrit les en-têtes extraits de HeaderRow.Cells, mais une exportation de production devrait également dimensionner automatiquement chaque colonne afin que les données soient lisibles sans ajustements manuels dans Excel :

protected void btnExport_Click(object sender, EventArgs e)
{
    WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
    WorkSheet worksheet = workbook.CreateWorkSheet("Employees");

    // Write column headers
    int colCount = gvEmployees.HeaderRow.Cells.Count;
    for (int i = 0; i < colCount; i++)
    {
        string header = gvEmployees.HeaderRow.Cells[i].Text;
        worksheet.SetCellValue(0, i, header);
    }

    // Write data rows
    for (int i = 0; i < gvEmployees.Rows.Count; i++)
    {
        for (int j = 0; j < gvEmployees.Rows[i].Cells.Count; j++)
        {
            worksheet.SetCellValue(i + 1, j, gvEmployees.Rows[i].Cells[j].Text);
        }
    }

    // Auto-size each column for readability
    for (int col = 0; col < colCount; col++)
    {
        worksheet.AutoSizeColumn(col);
    }

    string filePath = Server.MapPath("~/Exports/EmployeeReport.xlsx");
    workbook.SaveAs(filePath);
}
protected void btnExport_Click(object sender, EventArgs e)
{
    WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
    WorkSheet worksheet = workbook.CreateWorkSheet("Employees");

    // Write column headers
    int colCount = gvEmployees.HeaderRow.Cells.Count;
    for (int i = 0; i < colCount; i++)
    {
        string header = gvEmployees.HeaderRow.Cells[i].Text;
        worksheet.SetCellValue(0, i, header);
    }

    // Write data rows
    for (int i = 0; i < gvEmployees.Rows.Count; i++)
    {
        for (int j = 0; j < gvEmployees.Rows[i].Cells.Count; j++)
        {
            worksheet.SetCellValue(i + 1, j, gvEmployees.Rows[i].Cells[j].Text);
        }
    }

    // Auto-size each column for readability
    for (int col = 0; col < colCount; col++)
    {
        worksheet.AutoSizeColumn(col);
    }

    string filePath = Server.MapPath("~/Exports/EmployeeReport.xlsx");
    workbook.SaveAs(filePath);
}
$vbLabelText   $csharpLabel

AutoSizeColumn(col) indique à IronXLde calculer la largeur de colonne optimale en fonction de la longueur du contenu de la cellule, reflétant l'action Format > Ajustement automatique de la largeur de colonne dans l'application de bureau Excel. L'appel en boucle après l'écriture de toutes les données est plus efficace que l'appel après chaque ligne, car le contenu final est connu à ce stade.

Pour des options de style supplémentaires (titres en gras, couleurs d'arrière-plan, formats de nombres), consultez le tutoriel sur le style des cellules IronXL . Vous pouvez également fusionner des cellules pour créer des titres de rapport s'étendant sur plusieurs colonnes.

Comment appliquer une mise en forme en gras aux cellules d'en-tête ?

Utilisez l'objet IStyle renvoyé par worksheet["A1"].Style (ou une plage). Définissez Font.Bold = true avant ou après l'écriture des valeurs -- le style est découplé du contenu de la cellule :

// Bold the entire header row (columns A through D)
var headerRange = worksheet["A1:D1"];
headerRange.Style.Font.Bold = true;
headerRange.Style.BackgroundColor = "#4472C4";
headerRange.Style.Font.FontColor = "#FFFFFF";
// Bold the entire header row (columns A through D)
var headerRange = worksheet["A1:D1"];
headerRange.Style.Font.Bold = true;
headerRange.Style.BackgroundColor = "#4472C4";
headerRange.Style.Font.FontColor = "#FFFFFF";
$vbLabelText   $csharpLabel

Ce modèle s'applique uniformément aux plages de toutes tailles. Pour une liste complète des propriétés de style, consultez la documentation de l'API de style IronXL .

Comment exporter des données directement depuis une DataTable ?

L'itération sur les lignes rendues GridView lie votre exportation à l'état visuel actuel du contrôle, qui peut être affecté par les paramètres de pagination, de tri et de visibilité des colonnes. L'exportation à partir du DataTable sous-jacent stocké dans ViewState produit un résultat déterministe quelle que soit la configuration de la grille :

protected void btnExport_Click(object sender, EventArgs e)
{
    DataTable sourceData = ViewState["EmployeeData"] as DataTable;
    if (sourceData == null)
    {
        Response.Write("No data available to export.");
        return;
    }

    WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
    WorkSheet worksheet = workbook.CreateWorkSheet("Report");

    // Column headers from DataTable schema
    for (int i = 0; i < sourceData.Columns.Count; i++)
    {
        worksheet.SetCellValue(0, i, sourceData.Columns[i].ColumnName);
    }

    // Data rows from DataRow objects
    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 filePath = Server.MapPath("~/Exports/DataExport.xlsx");
    workbook.SaveAs(filePath);
}
protected void btnExport_Click(object sender, EventArgs e)
{
    DataTable sourceData = ViewState["EmployeeData"] as DataTable;
    if (sourceData == null)
    {
        Response.Write("No data available to export.");
        return;
    }

    WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
    WorkSheet worksheet = workbook.CreateWorkSheet("Report");

    // Column headers from DataTable schema
    for (int i = 0; i < sourceData.Columns.Count; i++)
    {
        worksheet.SetCellValue(0, i, sourceData.Columns[i].ColumnName);
    }

    // Data rows from DataRow objects
    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 filePath = Server.MapPath("~/Exports/DataExport.xlsx");
    workbook.SaveAs(filePath);
}
$vbLabelText   $csharpLabel

Les noms de colonnes proviennent de DataTable.Columns[i].ColumnName, qui reflète le schéma de données d'origine plutôt que les substitutions de nom d'affichage appliquées dans le modèle GridView. Les valeurs des cellules sont récupérées à partir d'objets DataRow en utilisant l'index de colonne, en convertissant chaque valeur en string pour satisfaire SetCellValue.

Ce modèle est particulièrement précieux lorsque GridView utilise la pagination -- l'itération gvEmployees.Rows ne renvoie que les lignes de la page actuellement visible, tandis que la lecture à partir de la page complète DataTable exporte chaque enregistrement.

Que se passe-t-il lors de l'exportation de données volumineuses de DataTable ?

IronXL diffuse efficacement les données des classeurs pour les grands ensembles de données Excel . Pour les exportations dépassant 100 000 lignes, il est conseillé de regrouper les appels SetCellValue au sein d'une même opération de feuille de calcul plutôt que de définir des cellules individuelles dans une boucle imbriquée. Vous pouvez également écrire le classeur dans un MemoryStream et le vider progressivement dans le flux Response afin d'éviter de stocker l'intégralité du fichier dans la mémoire vive du serveur.

Comment gérez-vous les erreurs lors de l'exportation ?

Les gestionnaires d'exportation de production doivent encapsuler les opérations IronXLdans un bloc catch et renvoyer un message descriptif à l'utilisateur lorsqu'un problème survient. Les modes de défaillance courants incluent l'absence du répertoire ~/Exports/, les erreurs d'autorisation de fichiers et la valeur nulle de ViewState après un délai d'expiration de session :

protected void btnExport_Click(object sender, EventArgs e)
{
    try
    {
        DataTable sourceData = ViewState["EmployeeData"] as DataTable;
        if (sourceData == null)
            throw new InvalidOperationException("Session data has expired. Please reload the page.");

        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet worksheet = workbook.CreateWorkSheet("Employees");

        for (int i = 0; i < sourceData.Columns.Count; i++)
            worksheet.SetCellValue(0, i, sourceData.Columns[i].ColumnName);

        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 filePath = Server.MapPath("~/Exports/SafeExport.xlsx");
        workbook.SaveAs(filePath);

        lblStatus.Text = "Export successful. File saved to server.";
    }
    catch (Exception ex)
    {
        lblStatus.Text = $"Export failed: {ex.Message}";
    }
}
protected void btnExport_Click(object sender, EventArgs e)
{
    try
    {
        DataTable sourceData = ViewState["EmployeeData"] as DataTable;
        if (sourceData == null)
            throw new InvalidOperationException("Session data has expired. Please reload the page.");

        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet worksheet = workbook.CreateWorkSheet("Employees");

        for (int i = 0; i < sourceData.Columns.Count; i++)
            worksheet.SetCellValue(0, i, sourceData.Columns[i].ColumnName);

        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 filePath = Server.MapPath("~/Exports/SafeExport.xlsx");
        workbook.SaveAs(filePath);

        lblStatus.Text = "Export successful. File saved to server.";
    }
    catch (Exception ex)
    {
        lblStatus.Text = $"Export failed: {ex.Message}";
    }
}
$vbLabelText   $csharpLabel

Pour les applications Web qui fournissent le fichier en téléchargement direct dans le navigateur plutôt que de l'enregistrer sur le disque, utilisez Response.BinaryWrite ou écrivez à Response.OutputStream après avoir défini les en-têtes content-type et disposition. Assurez-vous que le répertoire ~/Exports/ existe et que l'identité du pool d'applications IIS dispose de l'autorisation d'écriture sur celui-ci.

Comment envoyer le fichier XLSX en tant que téléchargement via navigateur ?

Remplacez workbook.SaveAs(filePath) par une réponse basée sur un flux :

using System.IO;

// ... inside btnExport_Click after populating the worksheet ...

byte[] fileBytes;
using (MemoryStream ms = new MemoryStream())
{
    workbook.SaveAs(ms);
    fileBytes = ms.ToArray();
}

Response.Clear();
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
Response.AddHeader("Content-Disposition", "attachment; filename=EmployeeData.xlsx");
Response.BinaryWrite(fileBytes);
Response.End();
using System.IO;

// ... inside btnExport_Click after populating the worksheet ...

byte[] fileBytes;
using (MemoryStream ms = new MemoryStream())
{
    workbook.SaveAs(ms);
    fileBytes = ms.ToArray();
}

Response.Clear();
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
Response.AddHeader("Content-Disposition", "attachment; filename=EmployeeData.xlsx");
Response.BinaryWrite(fileBytes);
Response.End();
$vbLabelText   $csharpLabel

Ce modèle évite d'écrire un fichier temporaire sur le disque. Le MemoryStream est alloué sur le serveur, sérialisé en byte[], et envoyé directement au client. L'appel Response.End() vide la réponse et empêche l'ajout de balises de page supplémentaires après les données binaires.

Comment exporter plusieurs feuilles ou des classeurs avancés ?

Un seul WorkBook peut contenir plusieurs feuilles, ce qui est utile lorsque vous devez exporter plusieurs GridViews (ou le même jeu de données avec différents niveaux de détail) dans un seul fichier. Appelez workbook.CreateWorkSheet(name) une fois pour chaque onglet :

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);

WorkSheet summary = workbook.CreateWorkSheet("Summary");
WorkSheet detail  = workbook.CreateWorkSheet("Detail");

// Populate summary sheet ...
// Populate detail sheet ...

workbook.SaveAs(Server.MapPath("~/Exports/FullReport.xlsx"));
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);

WorkSheet summary = workbook.CreateWorkSheet("Summary");
WorkSheet detail  = workbook.CreateWorkSheet("Detail");

// Populate summary sheet ...
// Populate detail sheet ...

workbook.SaveAs(Server.MapPath("~/Exports/FullReport.xlsx"));
$vbLabelText   $csharpLabel

IronXL prend également en charge la lecture de fichiers Excel existants , ce qui vous permet de charger un modèle préconfiguré avec une marque et une mise en forme, d'injecter des données dans des cellules spécifiques et d'enregistrer le résultat, en préservant les graphiques, les images et les styles déjà présents dans le modèle.

Pour des résultats encore plus riches, IronXLoffre la prise en charge des formules Excel , la mise en forme conditionnelle, la création de graphiques et l'intégration d'images . Ces fonctionnalités sont documentées dans la section tutoriels IronXL .

Comment IronXLse compare-t-il à EPPluset ClosedXML ?

Fonction IronXL EPPlus ClosedXML
Installation requise au bureau Non Non Non
Lecture et écriture XLSX Oui Oui Oui
Prise en charge XLS (héritée) Oui Non Non
Exportation CSV / TSV Oui Non Partiel
API de création de graphiques Oui Oui Limité
Modèle de licence Perpétuel + SaaS Polyform non commercial MIT
Prise en charge de .NET 10 Oui Oui Oui

EPPlus est passé à une licence commerciale dans la version 5, faisant IronXLune alternative naturelle pour les équipes investissant déjà dans un écosystème de bibliothèques .NET commerciales. ClosedXML reste sous licence MIT mais sa prise en charge des graphiques est limitée. Le bon choix dépend des contraintes de licence de votre projet, des fonctionnalités Excel dont vous avez besoin et de la nécessité ou non de prendre en charge le format hérité .xls.

Quels formats Excel sont pris en charge par IronXL ?

IronXL lit et écrit les formats .xlsx (Office Open XML), .xls (BIFF8 hérité), .csv et .tsv. Vous pouvez convertir entre les formats de fichiers Excel avec un seul appel API en modifiant la valeur d'énumération ExcelFileFormat transmise à WorkBook.Create ou en chargeant un fichier existant et en l'enregistrant dans un format différent.

Quelles sont vos prochaines étapes ?

Vous disposez désormais de trois modèles prêts à l'emploi pour exporter les données ASP.NET GridView vers des fichiers Excel XLSX à l'aide IronXL:

  • Exportation par itération de ligne -- le chemin le plus rapide vers une exportation fonctionnelle à partir d'une limite GridView
  • Exportation des en-têtes et de la mise en forme : ajoute un dimensionnement automatique des colonnes et des en-têtes en gras pour des rapports présentables.
  • Exportation pilotée par DataTable : contourne entièrement le contrôle rendu pour les grilles paginées ou filtrées.

Les prochaines étapes logiques sont :

  1. Ajoutez une réponse de téléchargement du navigateur en utilisant MemoryStream et Response.BinaryWrite afin que les utilisateurs reçoivent le fichier immédiatement sans chemin d'enregistrement côté serveur.
  2. Appliquez le style des cellules (en-têtes en gras, remplissages de couleur d'arrière-plan et formats de nombres) à l'aide de l' API de formatage IronXL .
  3. Explorez les classeurs à plusieurs feuilles pour combiner les données de synthèse et les données détaillées dans un seul fichier remis aux parties prenantes.
  4. Relire les fichiers Excel dans des objets DataTable en utilisant l'API de lecture d'IronXL pour les flux de travail d'import/export aller-retour.
  5. Démarrez un essai gratuit sur ironsoftware.com/csharp/excel/ pour tester toutes les fonctionnalités de votre projet avec une licence d'essai complète.

Pour les équipes qui développent des processus de génération de documents, IronPDF s'intègre à IronXLpour exporter directement les feuilles de calcul au format PDF. La Iron Suite regroupe IronXLavec IronPDF, IronOCR, IronBarcode et IronZIP à un prix combiné réduit.

Questions Fréquemment Posées

Quel est l'objectif principal de l'utilisation 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 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, prenant en charge les formats Excel modernes et assurant une intégration directe 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 IronXL dans un projet ?

Pour utiliser IronXL, vous avez besoin d'un environnement .NET et vous pouvez installer IronXL 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, reportez-vous à 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

Iron Support Team

We're online 24 hours, 5 days a week.
Chat
Email
Call Me