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 GridView, en écrivant chaque valeur de cellule à la position correspondante de la feuille de calcul, et en sauvegardant le classeur sur disque ou dans 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 Enterprise . 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 est de combler l'écart entre le contrôle serveur GridView et un fichier .xlsx correctement structuré, sans introduire de dépendances Office Interop qui cassent dans les environnements de serveur web.
Ce guide vous guide à travers trois modèles d'exportation progressivement plus riches : une exportation minimale ligne par ligne, une exportation en-tête plus données avec redimensionnement automatique des colonnes, et une exportation dirigé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.
Ouvrez la Console du Gestionnaire de Packages dans Visual Studio et exécutez :
Alternativement, faites un clic droit sur le projet dans Explorateur de solutions, choisissez Gérer les packages NuGet, recherchez IronXL, et cliquez sur Installer. NuGet résout automatiquement toutes les dépendances transitives.
Après l'installation du package, ajoutez les directives using suivantes à votre fichier code-behind :
using System;
using System.Data;
using System.Web.UI;
using IronXL;Imports System
Imports System.Data
Imports System.Web.UI
Imports IronXLIronXL 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 .
L'ID du package correct est IronXL (pas IronXL.Excel, qui est un alias hérité). Après l'installation, l'assemblée IronXL.dll est référencée automatiquement. Vous pouvez vérifier la version installée en vérifiant le nœud Packages dans l'Explorateur de solutions ou en exécutant dotnet list package depuis le répertoire du projet.
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 génération de chemins de fichiers côté serveur.
Le modèle d'exportation le plus simple itère sur 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);
}
}Imports System
Imports System.Data
Imports System.Web.UI
Imports IronXL
Public Partial Class GridViewExport
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()
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, "Michael Chen", "Finance", 70000)
ViewState("EmployeeData") = dt
gvEmployees.DataSource = dt
gvEmployees.DataBind()
End Sub
Protected Sub btnExport_Click(sender As Object, e As EventArgs)
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Employees")
' Write header row
For j As Integer = 0 To gvEmployees.HeaderRow.Cells.Count - 1
worksheet.SetCellValue(0, j, gvEmployees.HeaderRow.Cells(j).Text)
Next
' Write data rows
For i As Integer = 0 To gvEmployees.Rows.Count - 1
For j As Integer = 0 To gvEmployees.Rows(i).Cells.Count - 1
worksheet.SetCellValue(i + 1, j, gvEmployees.Rows(i).Cells(j).Text)
Next
Next
Dim filePath As String = Server.MapPath("~/Exports/EmployeeData.xlsx")
workbook.SaveAs(filePath)
End Sub
End ClassL'appel WorkBook.Create(ExcelFileFormat.XLSX) initialise un classeur en mémoire ciblant le format Open XML moderne. 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 à la ligne 0 ne soit pas écrasé.
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. IronXL lit et écrit des fichiers .xlsx directement en tant que packages Open XML -- pas de COM, pas d'Office, pas de la nécessité de Marshal.ReleaseComObject. Cela le rend fiable dans IIS, Azure App Service, Docker et autres environnements serveur où Office n'est pas disponible.
Lorsque vous souhaitez que le navigateur affiche une boîte de dialogue de sauvegarde de fichier au lieu de servir les octets en ligne, définissez le type de contenu de la réponse à 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.
L'exemple de base écrit des en-têtes extraits de HeaderRow.Cells, mais une exportation de production devrait également ajuster automatiquement chaque colonne pour 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 Sub btnExport_Click(sender As Object, e As EventArgs)
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Employees")
' Write column headers
Dim colCount As Integer = gvEmployees.HeaderRow.Cells.Count
For i As Integer = 0 To colCount - 1
Dim header As String = gvEmployees.HeaderRow.Cells(i).Text
worksheet.SetCellValue(0, i, header)
Next
' Write data rows
For i As Integer = 0 To gvEmployees.Rows.Count - 1
For j As Integer = 0 To gvEmployees.Rows(i).Cells.Count - 1
worksheet.SetCellValue(i + 1, j, gvEmployees.Rows(i).Cells(j).Text)
Next
Next
' Auto-size each column for readability
For col As Integer = 0 To colCount - 1
worksheet.AutoSizeColumn(col)
Next
Dim filePath As String = Server.MapPath("~/Exports/EmployeeReport.xlsx")
workbook.SaveAs(filePath)
End SubAutoSizeColumn(col) instruit IronXL de calculer la largeur optimale de la colonne en fonction de la longueur du contenu des cellules, reflétant l'action Format > Ajuster automatiquement la largeur des colonnes 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 d'autres options de style - en-têtes gras, couleurs d'arrière-plan, formats numériques - explorez le tutoriel de mise en style de cellule IronXL. Vous pouvez également fusionner des cellules pour créer des titres de rapport couvrant plusieurs colonnes.
Utilisez l'objet IStyle renvoyé par worksheet["A1"].Style (ou une plage). Définissez Font.Bold = true avant ou après avoir écrit les 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)
Dim headerRange = worksheet("A1:D1")
headerRange.Style.Font.Bold = True
headerRange.Style.BackgroundColor = "#4472C4"
headerRange.Style.Font.FontColor = "#FFFFFF"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 .
Iterer sur les lignes rendues GridView lie votre exportation à l'état visuel actuel du contrôle, qui peut être affecté par la pagination, le tri et les paramètres de visibilité des colonnes. L'exportation de la DataTable sous-jacente stockée dans ViewState produit un résultat déterministe, quel que soit le mode de 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 Sub btnExport_Click(sender As Object, e As EventArgs)
Dim sourceData As DataTable = TryCast(ViewState("EmployeeData"), DataTable)
If sourceData Is Nothing Then
Response.Write("No data available to export.")
Return
End If
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Report")
' Column headers from DataTable schema
For i As Integer = 0 To sourceData.Columns.Count - 1
worksheet.SetCellValue(0, i, sourceData.Columns(i).ColumnName)
Next
' Data rows from DataRow objects
For i As Integer = 0 To sourceData.Rows.Count - 1
For j As Integer = 0 To sourceData.Columns.Count - 1
worksheet.SetCellValue(i + 1, j, sourceData.Rows(i)(j).ToString())
Next
Next
Dim filePath As String = Server.MapPath("~/Exports/DataExport.xlsx")
workbook.SaveAs(filePath)
End SubLes noms de colonnes proviennent de DataTable.Columns[i].ColumnName, ce qui reflète le schéma de données d'origine plutôt que tout remplacement de nom d'affichage appliqué dans le modèle GridView. Les valeurs des cellules sont récupérées à partir des 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 DataTable complète exporte chaque enregistrement.
IronXL diffuse efficacement les données des classeurs pour les grands ensembles de données Excel . Pour les exportations dépassant 100 000 lignes, envisagez de regrouper les appels SetCellValue à l'intérieur d'une opération de feuille de calcul unique 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 dans le flux Response de manière progressive pour éviter de conserver le fichier entier dans la RAM du serveur.
Les gestionnaires d'exportation en production devraient envelopper les opérations IronXL dans un bloc catch et retourner un message descriptif à l'utilisateur lorsque quelque chose ne va pas. Les modes de défaillance courants incluent l'absence du répertoire ~/Exports/, les erreurs de permissions de fichier, et ViewState étant nul 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 Sub btnExport_Click(sender As Object, e As EventArgs)
Try
Dim sourceData As DataTable = TryCast(ViewState("EmployeeData"), DataTable)
If sourceData Is Nothing Then
Throw New InvalidOperationException("Session data has expired. Please reload the page.")
End If
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Employees")
For i As Integer = 0 To sourceData.Columns.Count - 1
worksheet.SetCellValue(0, i, sourceData.Columns(i).ColumnName)
Next
For i As Integer = 0 To sourceData.Rows.Count - 1
For j As Integer = 0 To sourceData.Columns.Count - 1
worksheet.SetCellValue(i + 1, j, sourceData.Rows(i)(j).ToString())
Next
Next
Dim filePath As String = Server.MapPath("~/Exports/SafeExport.xlsx")
workbook.SaveAs(filePath)
lblStatus.Text = "Export successful. File saved to server."
Catch ex As Exception
lblStatus.Text = $"Export failed: {ex.Message}"
End Try
End SubPour les applications web qui livrent le fichier en tant que téléchargement direct par le navigateur au lieu de l'enregistrer sur le disque, utilisez Response.BinaryWrite ou écrivez dans Response.OutputStream après avoir défini les en-têtes de type de contenu et de disposition. Assurez-vous que le répertoire ~/Exports/ existe et que l'identité du pool d'applications IIS a la permission d'écriture dessus.
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();Imports System.IO
' ... inside btnExport_Click after populating the worksheet ...
Dim fileBytes As Byte()
Using ms As New MemoryStream()
workbook.SaveAs(ms)
fileBytes = ms.ToArray()
End Using
Response.Clear()
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
Response.AddHeader("Content-Disposition", "attachment; filename=EmployeeData.xlsx")
Response.BinaryWrite(fileBytes)
Response.End()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 le balisage de page supplémentaire d'être ajouté après les données binaires.
Un seul WorkBook peut contenir plusieurs feuilles, ce qui est utile lorsque vous devez exporter plusieurs GridViews -- ou le même ensemble de données à différents niveaux de granularité -- 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"));Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim summary As WorkSheet = workbook.CreateWorkSheet("Summary")
Dim detail As WorkSheet = workbook.CreateWorkSheet("Detail")
' Populate summary sheet ...
' Populate detail sheet ...
workbook.SaveAs(Server.MapPath("~/Exports/FullReport.xlsx"))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 un résultat encore plus riche, IronXL fournit une prise en charge des formules Excel, un formatage conditionnel, une création de graphiques, et une intégration d'images. Ces fonctionnalités sont documentées dans la section tutoriels IronXL .
| 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 IronXL une 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 si le support du format hérité .xls est une exigence.
IronXL lit et écrit les formats .xlsx (Office Open XML), .xls (hérité BIFF8), .csv, et .tsv. Vous pouvez convertir entre les formats de fichiers Excel avec un seul appel API en changeant la valeur de l'énumération ExcelFileFormat passée à WorkBook.Create ou en chargeant un fichier existant et en le sauvegardant dans un format différent.
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:
GridView liéLes prochaines étapes logiques sont :
MemoryStream et Response.BinaryWrite afin que les utilisateurs reçoivent immédiatement le fichier sans chemin de sauvegarde côté serveur.DataTable en utilisant l'API de lecture d'IronXL pour des flux de travail d'import/export aller-retour.Pour les équipes qui développent des processus de génération de documents, IronPDF s'intègre à IronXL pour exporter directement les feuilles de calcul au format PDF. La Iron Suite regroupe IronXL avec IronPDF, IronOCR, IronBarcode et IronZIP à un prix combiné réduit.
Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes et créer des manuels bien structurés et visuellement attrayants.
IronXL fait partie de IRONSUITE
10 API .NET pour vos documents
L'API Excel dont vous avez besoin, sans tracas Interop Office.
