Comment exporter un GridView vers Excel avec mise en forme en C#

Comment installer la bibliothèque dans un projet .NET ?

Installez IronXL depuis NuGet avant d'écrire tout code d'exportation. Ouvrez la console du gestionnaire de packages et exécutez :

Install-Package IronXL
dotnet add package IronXL

Install-Package IronXL
dotnet add package IronXL

IronXL prend en charge .NET 8, .NET 9 et .NET 10, ainsi que .NET Framework 4.6.2 et versions ultérieures. Après l'installation, ajoutez les directives using suivantes à tout fichier effectuant des opérations Excel :

using IronXL;
using IronXl.Styles;

using IronXL;
using IronXl.Styles;

Aucun environnement d'exécution supplémentaire ni interopérabilité Office n'est requis. La bibliothèque génère des fichiers binaires XLSX natifs qui s'ouvrent sans problème dans Microsoft Excel, LibreOffice Calc et Google Sheets.

Comment exporter un contrôle DataGridView Windows Forms vers Excel en conservant la mise en forme des cellules ?

Les applications Windows Forms utilisent le contrôle DataGridView plutôt que le contrôle Web GridView. Le modèle d'exportation est le même dans les deux cas : extraire les valeurs des lignes et des cellules, créer un classeur IronXL, appliquer des styles, puis enregistrer ou diffuser le résultat.

L'approche la plus fiable consiste à convertir la propriété DataSource du contrôle en DataTable afin d'éviter d'itérer sur les lignes visuelles, qui peuvent être filtrées ou paginées :

using IronXL;
using IronXl.Styles;
using System;
using System.Data;
using System.IO;
using System.Windows.Forms;

DataTable dt = (DataTable)dataGridView1.DataSource;

WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workBook.DefaultWorkSheet;

// Header row -- bold, blue background, white text
for (int col = 0; col < dt.Columns.Count; col++)
{
    sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
    var cell = sheet.GetCellAt(0, col);
    cell.Style.Font.Bold = true;
    cell.Style.SetBackgroundColor("#4472C4");
    cell.Style.Font.Color = "#FFFFFF";
    cell.Style.BottomBorder.Type = BorderType.Thin;
}

// Data rows -- alternating row color
for (int row = 0; row < dt.Rows.Count; row++)
{
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        string value = dt.Rows[row][col]?.ToString() ?? string.Empty;
        sheet.SetCellValue(row + 1, col, value);

        var cell = sheet.GetCellAt(row + 1, col);
        cell.Style.SetBackgroundColor(row % 2 == 0 ? "#D6DCE5" : "#FFFFFF");
        cell.Style.BottomBorder.Type = BorderType.Thin;
    }
}

// Save via dialog
using var saveDialog = new SaveFileDialog
{
    Filter = "Excel Files|*.xlsx",
    FileName = "GridViewExport.xlsx"
};

if (saveDialog.ShowDialog() == DialogResult.OK)
{
    workBook.SaveAs(saveDialog.FileName);
    MessageBox.Show("Export successful.", "Export",
        MessageBoxButtons.OK, MessageBoxIcon.Information);
}

using IronXL;
using IronXl.Styles;
using System;
using System.Data;
using System.IO;
using System.Windows.Forms;

DataTable dt = (DataTable)dataGridView1.DataSource;

WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workBook.DefaultWorkSheet;

// Header row -- bold, blue background, white text
for (int col = 0; col < dt.Columns.Count; col++)
{
    sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
    var cell = sheet.GetCellAt(0, col);
    cell.Style.Font.Bold = true;
    cell.Style.SetBackgroundColor("#4472C4");
    cell.Style.Font.Color = "#FFFFFF";
    cell.Style.BottomBorder.Type = BorderType.Thin;
}

// Data rows -- alternating row color
for (int row = 0; row < dt.Rows.Count; row++)
{
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        string value = dt.Rows[row][col]?.ToString() ?? string.Empty;
        sheet.SetCellValue(row + 1, col, value);

        var cell = sheet.GetCellAt(row + 1, col);
        cell.Style.SetBackgroundColor(row % 2 == 0 ? "#D6DCE5" : "#FFFFFF");
        cell.Style.BottomBorder.Type = BorderType.Thin;
    }
}

// Save via dialog
using var saveDialog = new SaveFileDialog
{
    Filter = "Excel Files|*.xlsx",
    FileName = "GridViewExport.xlsx"
};

if (saveDialog.ShowDialog() == DialogResult.OK)
{
    workBook.SaveAs(saveDialog.FileName);
    MessageBox.Show("Export successful.", "Export",
        MessageBoxButtons.OK, MessageBoxIcon.Information);
}

WorkBook.Create initialise un nouveau classeur en mémoire au format XLSX. DefaultWorkSheet renvoie la première feuille, que vous pouvez renommer via sa propriété Name avant d'enregistrer. SetCellValue accepte les chaînes de caractères, les entiers, les nombres à virgule flottante et les valeurs DateTime -- IronXL sélectionne automatiquement le type de cellule approprié.

Le motif de couleur de ligne alternée -- row % 2 == 0 sélectionne #D6DCE5, sinon #FFFFFF -- reflète le style de tableau à lignes en bandes intégré à Excel. Vous pouvez utiliser n'importe quel code couleur hexadécimal à six caractères correspondant au système de conception de votre application.

Comment exporter un contrôle GridView ASP.NET vers Excel et diffuser le fichier vers le navigateur ?

Les applications web nécessitent un mécanisme de diffusion différent. Au lieu d'écrire sur le système de fichiers, vous sérialisez le classeur en un MemoryStream et l'écrivez dans la réponse HTTP avec les en-têtes appropriés afin que le navigateur le traite comme un téléchargement de fichier.

L'étape préliminaire importante pour les GridViews paginées : désactiver la pagination (AllowPaging = false) et relier la source de données avant l'exportation afin que chaque enregistrement, et pas seulement la page actuelle, soit capturé.

using IronXL;
using IronXl.Styles;
using System;
using System.Data;
using System.IO;
using System.Web.UI;

// Disable paging so all rows are captured
GridView1.AllowPaging = false;
GridView1.DataBind();

DataTable dt = (DataTable)GridView1.DataSource;

WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workBook.DefaultWorkSheet;

// Header row
for (int col = 0; col < dt.Columns.Count; col++)
{
    sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
    var cell = sheet.GetCellAt(0, col);
    cell.Style.Font.Bold = true;
    cell.Style.SetBackgroundColor("#2E75B6");
    cell.Style.Font.Color = "#FFFFFF";
    cell.Style.HorizontalAlignment = HorizontalAlignment.Center;
    cell.Style.BottomBorder.Type = BorderType.Medium;
}

// Data rows
for (int row = 0; row < dt.Rows.Count; row++)
{
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        sheet.SetCellValue(row + 1, col, dt.Rows[row][col]?.ToString() ?? string.Empty);
        var cell = sheet.GetCellAt(row + 1, col);
        cell.Style.SetBackgroundColor(row % 2 == 0 ? "#DEEAF1" : "#FFFFFF");
        cell.Style.BottomBorder.Type = BorderType.Thin;
        cell.Style.LeftBorder.Type = BorderType.Thin;
        cell.Style.RightBorder.Type = BorderType.Thin;
    }
}

// Stream to browser
byte[] fileBytes = workBook.ToByteArray();
Response.Clear();
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
Response.AddHeader("content-disposition", "attachment; filename=GridViewExport.xlsx");
Response.BinaryWrite(fileBytes);
Response.End();

using IronXL;
using IronXl.Styles;
using System;
using System.Data;
using System.IO;
using System.Web.UI;

// Disable paging so all rows are captured
GridView1.AllowPaging = false;
GridView1.DataBind();

DataTable dt = (DataTable)GridView1.DataSource;

WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workBook.DefaultWorkSheet;

// Header row
for (int col = 0; col < dt.Columns.Count; col++)
{
    sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
    var cell = sheet.GetCellAt(0, col);
    cell.Style.Font.Bold = true;
    cell.Style.SetBackgroundColor("#2E75B6");
    cell.Style.Font.Color = "#FFFFFF";
    cell.Style.HorizontalAlignment = HorizontalAlignment.Center;
    cell.Style.BottomBorder.Type = BorderType.Medium;
}

// Data rows
for (int row = 0; row < dt.Rows.Count; row++)
{
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        sheet.SetCellValue(row + 1, col, dt.Rows[row][col]?.ToString() ?? string.Empty);
        var cell = sheet.GetCellAt(row + 1, col);
        cell.Style.SetBackgroundColor(row % 2 == 0 ? "#DEEAF1" : "#FFFFFF");
        cell.Style.BottomBorder.Type = BorderType.Thin;
        cell.Style.LeftBorder.Type = BorderType.Thin;
        cell.Style.RightBorder.Type = BorderType.Thin;
    }
}

// Stream to browser
byte[] fileBytes = workBook.ToByteArray();
Response.Clear();
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
Response.AddHeader("content-disposition", "attachment; filename=GridViewExport.xlsx");
Response.BinaryWrite(fileBytes);
Response.End();

Response.AddHeader avec content-disposition: attachment force une boîte de dialogue de téléchargement de fichier dans tous les navigateurs modernes. Le type MIME application/vnd.openxmlformats-officedocument.spreadsheetml.sheet est le type enregistré pour les fichiers XLSX et empêche le navigateur de tenter d'afficher le contenu binaire en ligne.

Pour les applications ASP.NET Core , remplacez Response.BinaryWrite par File(fileBytes, contentType, fileName) dans une action de contrôleur -- la logique de création du classeur est identique.

// Assume "DueDate" is column index 3 and "Amount" is column index 4
DateTime today = DateTime.Today;

for (int row = 0; row < dt.Rows.Count; row++)
{
    // Highlight past-due dates
    if (dt.Columns.Contains("DueDate") && dt.Rows[row]["DueDate"] != DBNull.Value)
    {
        DateTime dueDate = Convert.ToDateTime(dt.Rows[row]["DueDate"]);
        var dueDateCell = sheet.GetCellAt(row + 1, 3);
        if (dueDate < today)
        {
            dueDateCell.Style.SetBackgroundColor("#FF0000");
            dueDateCell.Style.Font.Color = "#FFFFFF";
            dueDateCell.Style.Font.Bold = true;
        }
    }

    // Highlight amounts below threshold
    if (dt.Columns.Contains("Amount") && dt.Rows[row]["Amount"] != DBNull.Value)
    {
        decimal amount = Convert.ToDecimal(dt.Rows[row]["Amount"]);
        var amountCell = sheet.GetCellAt(row + 1, 4);
        if (amount < 100m)
        {
            amountCell.Style.SetBackgroundColor("#FFC000");
        }
    }
}

// Assume "DueDate" is column index 3 and "Amount" is column index 4
DateTime today = DateTime.Today;

for (int row = 0; row < dt.Rows.Count; row++)
{
    // Highlight past-due dates
    if (dt.Columns.Contains("DueDate") && dt.Rows[row]["DueDate"] != DBNull.Value)
    {
        DateTime dueDate = Convert.ToDateTime(dt.Rows[row]["DueDate"]);
        var dueDateCell = sheet.GetCellAt(row + 1, 3);
        if (dueDate < today)
        {
            dueDateCell.Style.SetBackgroundColor("#FF0000");
            dueDateCell.Style.Font.Color = "#FFFFFF";
            dueDateCell.Style.Font.Bold = true;
        }
    }

    // Highlight amounts below threshold
    if (dt.Columns.Contains("Amount") && dt.Rows[row]["Amount"] != DBNull.Value)
    {
        decimal amount = Convert.ToDecimal(dt.Rows[row]["Amount"]);
        var amountCell = sheet.GetCellAt(row + 1, 4);
        if (amount < 100m)
        {
            amountCell.Style.SetBackgroundColor("#FFC000");
        }
    }
}

Comment définir la largeur des colonnes et figer la ligne d'en-tête ?

Un fichier Excel exporté avec un formatage professionnel comprend des largeurs de colonnes appropriées et une ligne d'en-tête fixe afin que les noms de colonnes restent visibles lorsque les utilisateurs font défiler de grands ensembles de données.

IronXL expose la largeur des colonnes via l'accesseur de colonnes WorkSheet et le gel de l'en-tête via la méthode FreezeRows :

// Auto-size columns 0 through the last column index
for (int col = 0; col < dt.Columns.Count; col++)
{
    // Set column width in character units (1 unit ≈ one default character width)
    sheet.SetColumnWidth(col, 20);
}

// Freeze the first row (index 0) so the header stays visible while scrolling
sheet.FreezeRows(1);

// Optionally set row height for the header (in points)
sheet.SetRowHeight(0, 20);

// Auto-size columns 0 through the last column index
for (int col = 0; col < dt.Columns.Count; col++)
{
    // Set column width in character units (1 unit ≈ one default character width)
    sheet.SetColumnWidth(col, 20);
}

// Freeze the first row (index 0) so the header stays visible while scrolling
sheet.FreezeRows(1);

// Optionally set row height for the header (in points)
sheet.SetRowHeight(0, 20);

Pour une utilisation en production, il est conseillé de calculer la largeur en fonction du nombre maximal de caractères dans chaque colonne plutôt que d'utiliser une valeur fixe. Parcourez les valeurs de la colonne DataTable, mesurez la longueur de la chaîne et multipliez par un facteur de largeur de caractère approprié à la taille de police choisie.

Vous pouvez également appliquer une couleur d'arrière-plan aux cellules Excel en utilisant C# indépendamment de la logique de regroupement des lignes pour une approche de style plus précise.

Comment exporter un DataTable vers Excel sans contrôle GridView ?

De nombreuses applications .NET remplissent des données via des appels de service ou des requêtes de base de données et les stockent dans un DataTable sans jamais les lier à un contrôle d'interface utilisateur. Vous pouvez exporter un DataTable directement vers Excel sans instancier du tout un GridView.

Il s'agit du chemin le plus efficace pour les tâches en arrière-plan, les rapports planifiés et les points de terminaison d'API qui doivent produire des fichiers Excel sur le serveur :

using IronXL;
using IronXl.Styles;
using System.Data;

public static byte[] DataTableToExcelBytes(DataTable dt, string sheetName = "Report")
{
    WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
    WorkSheet sheet = workBook.CreateWorkSheet(sheetName);

    // Header
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
        var cell = sheet.GetCellAt(0, col);
        cell.Style.Font.Bold = true;
        cell.Style.SetBackgroundColor("#4472C4");
        cell.Style.Font.Color = "#FFFFFF";
    }

    // Data
    for (int row = 0; row < dt.Rows.Count; row++)
    {
        for (int col = 0; col < dt.Columns.Count; col++)
        {
            sheet.SetCellValue(row + 1, col, dt.Rows[row][col]?.ToString() ?? string.Empty);
        }
    }

    return workBook.ToByteArray();
}

using IronXL;
using IronXl.Styles;
using System.Data;

public static byte[] DataTableToExcelBytes(DataTable dt, string sheetName = "Report")
{
    WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
    WorkSheet sheet = workBook.CreateWorkSheet(sheetName);

    // Header
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
        var cell = sheet.GetCellAt(0, col);
        cell.Style.Font.Bold = true;
        cell.Style.SetBackgroundColor("#4472C4");
        cell.Style.Font.Color = "#FFFFFF";
    }

    // Data
    for (int row = 0; row < dt.Rows.Count; row++)
    {
        for (int col = 0; col < dt.Columns.Count; col++)
        {
            sheet.SetCellValue(row + 1, col, dt.Rows[row][col]?.ToString() ?? string.Empty);
        }
    }

    return workBook.ToByteArray();
}

Cette méthode renvoie un byte[] que vous pouvez écrire sur disque, diffuser à partir d'un point de terminaison API, joindre à un e-mail ou mettre en cache en mémoire. Pour des techniques connexes, consultez le guide sur l'exportation d'un DataTable vers Excel et le tutoriel sur la méthode la plus rapide pour exporter un DataTable vers Excel .

Comment gérez-vous les grands ensembles de données et les performances ?

L'exportation de dizaines de milliers de lignes vers Excel exige une attention particulière à l'allocation de mémoire. La création d'un nouvel objet de type cellule pour chaque cellule d'une grande grille constitue le goulot d'étranglement le plus courant en termes de performances. Réutilisez les définitions de style autant que possible en appliquant les styles aux objets de plage plutôt qu'aux cellules individuelles :

Pour les GridViews paginées, définissez toujours AllowPaging = false et reliez avant d'exporter. La pagination limite le nombre de lignes visibles dans le contrôle, de sorte qu'une exportation paginée ne capture que la page actuelle plutôt que l'ensemble des données, ce qui est une source fréquente de bogues d'exportation incomplète.

Vous pouvez également consulter le guide sur l'exportation d'une liste d'objets vers Excel en C# pour des modèles qui fonctionnent avec des collections fortement typées plutôt qu'avec des lignes non typées DataTable.

Comment exporter un GridView dans ASP.NET Core ou Blazor?

Les applications ASP.NET Core et Blazor ne disposent pas d'un contrôle Web Forms, mais le défi sous-jacent en matière d'exportation de données est le même : prendre une collection d'objets ou un objet, créer un classeur stylisé et fournir un fichier. Le code de création du classeur est identique ; Seul le mode de livraison change.

Dans une application Blazor , déclencher le téléchargement d'un fichier via l'interopérabilité JavaScript :

// In a Blazor component or service
using IronXL;
using System.Data;
using Microsoft.JSInterop;

public async Task ExportToExcelAsync(DataTable dt, IJSRuntime js)
{
    WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
    WorkSheet sheet = workBook.DefaultWorkSheet;

    for (int col = 0; col < dt.Columns.Count; col++)
    {
        sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
        var cell = sheet.GetCellAt(0, col);
        cell.Style.Font.Bold = true;
        cell.Style.SetBackgroundColor("#4472C4");
        cell.Style.Font.Color = "#FFFFFF";
    }

    for (int row = 0; row < dt.Rows.Count; row++)
    {
        for (int col = 0; col < dt.Columns.Count; col++)
        {
            sheet.SetCellValue(row + 1, col, dt.Rows[row][col]?.ToString() ?? string.Empty);
        }
    }

    byte[] fileBytes = workBook.ToByteArray();
    string base64 = Convert.ToBase64String(fileBytes);
    await js.InvokeVoidAsync("downloadFileFromBase64", base64, "GridViewExport.xlsx",
        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
}

// In a Blazor component or service
using IronXL;
using System.Data;
using Microsoft.JSInterop;

public async Task ExportToExcelAsync(DataTable dt, IJSRuntime js)
{
    WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
    WorkSheet sheet = workBook.DefaultWorkSheet;

    for (int col = 0; col < dt.Columns.Count; col++)
    {
        sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
        var cell = sheet.GetCellAt(0, col);
        cell.Style.Font.Bold = true;
        cell.Style.SetBackgroundColor("#4472C4");
        cell.Style.Font.Color = "#FFFFFF";
    }

    for (int row = 0; row < dt.Rows.Count; row++)
    {
        for (int col = 0; col < dt.Columns.Count; col++)
        {
            sheet.SetCellValue(row + 1, col, dt.Rows[row][col]?.ToString() ?? string.Empty);
        }
    }

    byte[] fileBytes = workBook.ToByteArray();
    string base64 = Convert.ToBase64String(fileBytes);
    await js.InvokeVoidAsync("downloadFileFromBase64", base64, "GridViewExport.xlsx",
        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
}

La description complète du modèle de téléchargement Blazor se trouve dans le tutoriel " Exportation Blazor vers Excel " . Pour une approche avec un contrôleur ASP.NET Core , consultez le tutoriel sur l'exportation Excel ASP.NET Core .

Pourquoi une bibliothèque Excel native produit-elle des exportations plus propres que HtmlTextWriter ?

La technique d'exportation ASP.NET traditionnelle -- surchargeant VerifyRenderingInServerForm, créant un StringWriter et HtmlTextWriter, et écrivant le contrôle rendu dans la réponse -- produit un document HTML avec une extension .xls. Microsoft Excel ouvre ces fichiers avec un avertissement de compatibilité car le fichier n'est pas au format binaire Excel ou OOXML. Les styles sont limités au CSS en ligne qu'Excel interprète partiellement. La mise en forme conditionnelle est impossible. Les utilisateurs de plateformes autres que Windows ou utilisant LibreOffice constatent une qualité d'affichage dégradée.

IronXL écrit directement au format de feuille de calcul Open XML (OOXML). Le résultat est un fichier .xlsx correct -- identique à celui qu'Excel crée lui-même -- qui s'ouvre sans avertissements dans Excel, LibreOffice, Google Sheets et Numbers sur macOS. La mise en forme est encodée sous forme de styles de feuille de calcul, et non d'attributs HTML, ce qui lui permet de survivre aux allers-retours et à l'affichage multiplateforme.

La documentation officielle de Microsoft sur le kit de développement logiciel Open XML explique le format sous-jacent produit par IronXL . La spécification OOXML, maintenue par ECMA International, définit la norme qui garantit la compatibilité entre les applications. La documentation du contrôle GridView ASP.NET sur Microsoft Docs décrit le modèle de contrôle à partir duquel les modèles d'exportation ci-dessus sont lus.

Quelles sont vos prochaines étapes ?

Vous disposez désormais des modèles nécessaires pour exporter les données GridView et DataGridView vers des fichiers XLSX correctement formatés à l'aide d' IronXL , couvrant les modèles de distribution Windows Forms, ASP.NET Web Forms, ASP.NET Core et Blazor .

Pour aller plus loin :

• Commencez un essai gratuit d' IronXL pour tester toutes les fonctionnalités de formatage et d'exportation avec vos propres données.
• Consultez la documentation IronXL pour obtenir la référence complète de l'API, y compris les tableaux croisés dynamiques, les graphiques et la validation des données.
• Explorez la création de rapports Excel en C# pour combiner les modèles d'exportation ci-dessus avec des résumés et des graphiques calculés.
• Consultez la section " Lecture de fichiers Excel en C# " pour connaître le flux de travail d'importation complémentaire lorsque votre application doit également utiliser des feuilles de calcul téléchargées.
• Pour les exportations au format CSV en plus des exportations XLSX, consultez le tutoriel C# sur l'exportation vers CSV .
• Si vous exportez des données d'un DataGridView avec les en-têtes de colonnes comme première ligne, consultez le guide dédié DataGridView vers Excel avec en-têtes de colonnes .