Icône de message
Passer au contenu du pied de page
  1. IronXL
  2. Blog IronXL
  3. Utilisation d'IronXL
  4. Exportation de DataGridView C# vers Excel avec en-têtes de colonnes
UTILISATION D'IRONXL

Exportation de DataGridView C# vers Excel avec en-têtes de colonnes

Jordi Bardia
Jordi Bardia
Mis à jour:

Comment exporter un DataGridView vers Excel avec les en-têtes de colonnes en C# ?

L'exportation de données d'un contrôle DataGridView de Windows Forms vers le format Excel est une exigence courante, mais les développeurs se heurtent souvent à un obstacle frustrant : le fichier exporté ne contient pas les en-têtes de colonnes. Lorsque vous devez exporter un DataGridView vers Excel avec les en-têtes de colonnes, la solution doit préserver l'intégralité de vos données et leur mise en forme de manière fiable. Les approches traditionnelles utilisant Interopérabilité de Microsoft Office peuvent être lentes, fragiles et nécessitent l'installation de MS Excel sur chaque machine exécutant le code.

IronXL résout ce problème de manière propre. Il s'agit d'une bibliothèque Excel .NET qui permet de lire, de créer et d'écrire des fichiers Excel sans aucune dépendance à Office. Ce tutoriel vous guide à travers une solution d'exportation complète, qui gère les en-têtes de colonnes, les types de données, les cellules nulles et l'enregistrement de fichiers convivial en seulement quelques lignes de code.

À la fin, vous disposerez d'un gestionnaire de bouton Windows Forms fonctionnel qui exporte un DataGridView vers un fichier XLSX en conservant tous les en-têtes de colonnes.

Ce dont vous avez besoin avant de commencer

Avant d'écrire le moindre code, assurez-vous que les éléments suivants sont en place :

  • Visual Studio 2022 ou version ultérieure (toute édition)
  • Kit de développement logiciel .NET 10 installé
  • Un projet d'application Windows Forms ciblant .NET 10
  • Accès NuGet pour installer IronXL

Les exemples ci-dessous utilisent des instructions de niveau supérieur et la structure de projet moderne .NET 10.

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

Ouvrez la console du gestionnaire de packages NuGet dans Visual Studio et exécutez l'une des commandes suivantes. Ce package est répertorié sur la galerie NuGet et cible .NET Standard 2.0 et versions ultérieures ; il est donc compatible avec tous les projets .NET modernes.

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

Après l'installation, ajoutez les espaces de noms requis en haut de votre fichier de formulaire :

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

Ces importations donnent accès aux fonctionnalités Excel d'IronXL , aux opérations DataTable et aux contrôles Windows Forms nécessaires au processus d'exportation.

Comment configurer un contrôle DataGridView avec des exemples de données ?

Commencez par créer une application Windows Forms dans Visual Studio. Ajoutez un DataGridView nommé dataGridView1 et un Button nommé btnExport au formulaire principal via le concepteur. Remplissez ensuite la grille lors du chargement du formulaire :

using System;
using System.Data;
using System.Windows.Forms;

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }

    private void Form1_Load(object sender, EventArgs e)
    {
        DataTable dt = new DataTable();

        // Define columns -- these names become Excel headers
        dt.Columns.Add("Product ID", typeof(int));
        dt.Columns.Add("Product Name", typeof(string));
        dt.Columns.Add("Price", typeof(decimal));
        dt.Columns.Add("Stock Quantity", typeof(int));

        // Add sample rows
        dt.Rows.Add(1001, "Laptop", 999.99m, 15);
        dt.Rows.Add(1002, "Mouse", 29.99m, 50);
        dt.Rows.Add(1003, "Keyboard", 79.99m, 30);
        dt.Rows.Add(1004, "Monitor", 299.99m, 12);
        dt.Rows.Add(1005, "Headphones", 89.99m, 25);

        // Bind data to the grid
        dataGridView1.DataSource = dt;
    }
}
using System;
using System.Data;
using System.Windows.Forms;

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }

    private void Form1_Load(object sender, EventArgs e)
    {
        DataTable dt = new DataTable();

        // Define columns -- these names become Excel headers
        dt.Columns.Add("Product ID", typeof(int));
        dt.Columns.Add("Product Name", typeof(string));
        dt.Columns.Add("Price", typeof(decimal));
        dt.Columns.Add("Stock Quantity", typeof(int));

        // Add sample rows
        dt.Rows.Add(1001, "Laptop", 999.99m, 15);
        dt.Rows.Add(1002, "Mouse", 29.99m, 50);
        dt.Rows.Add(1003, "Keyboard", 79.99m, 30);
        dt.Rows.Add(1004, "Monitor", 299.99m, 12);
        dt.Rows.Add(1005, "Headphones", 89.99m, 25);

        // Bind data to the grid
        dataGridView1.DataSource = dt;
    }
}
$vbLabelText   $csharpLabel

Les noms de colonnes définis dans les appels dt.Columns.Add(...) deviendront l'en-tête du fichier Excel exporté. Vous pouvez utiliser n'importe quelle source de données : résultat d'une requête de base de données, importation CSV ou réponse d'API stockée sous forme de DataTable. Le code d'exportation présenté plus loin fonctionne de manière identique. L'approche DataTable est particulièrement pratique car DataGridView expose une propriété DataSource qui accepte n'importe quel IList ou IBindingList, ce qui signifie que le même code d'exportation se généralise à tous les scénarios de liaison sans modification.

Si votre DataGridView est rempli à partir d'une base de données à l'aide d'un SqlDataAdapter, le DataTable contient déjà des colonnes typées. Le fait de transmettre ces valeurs typées à SetCellValue plutôt que d'appeler ToString() sur elles permet de conserver les colonnes numériques numériques dans la sortie Excel, ce qui est important pour toute utilisation ultérieure de rapports ou de tableaux croisés dynamiques.

Cela crée un DataGridView rempli de toutes les données :

C# Exportation d'un DataGridView vers Excel avec en-têtes de colonnes à l'aide IronXL: Image 1 - Exemple de données dans un DataGridView

Pour des scénarios de liaison de données plus avancés, la documentation Microsoft sur la liaison de données DataGridView fournit des exemples supplémentaires.

Comment exporter un DataGridView vers Excel tout en conservant les en-têtes de colonnes ?

La méthode d'exportation lit les en-têtes de colonne à partir de la propriété HeaderText de chaque colonne DataGridView et les écrit dans la ligne 0 de la feuille de calcul. Les lignes de données suivent à partir de la ligne 1. Associez cette méthode à l'événement de clic btnExport :

private void btnExport_Click(object sender, EventArgs e)
{
    try
    {
        // Create a new Excel workbook in XLSX format
        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet worksheet = workbook.CreateWorkSheet("Exported Data");

        // Write column headers to row 0
        for (int col = 0; col < dataGridView1.Columns.Count; col++)
        {
            worksheet.SetCellValue(0, col, dataGridView1.Columns[col].HeaderText);
        }

        // Write data rows starting at row 1
        for (int row = 0; row < dataGridView1.Rows.Count; row++)
        {
            // Skip the placeholder new-row at the bottom of the grid
            if (dataGridView1.AllowUserToAddRows && row == dataGridView1.Rows.Count - 1)
                continue;

            for (int col = 0; col < dataGridView1.Columns.Count; col++)
            {
                var cellValue = dataGridView1.Rows[row].Cells[col].Value;
                if (cellValue != null)
                {
                    worksheet.SetCellValue(row + 1, col, cellValue.ToString());
                }
            }
        }

        // Prompt the user to choose a save location
        using SaveFileDialog saveFileDialog = new SaveFileDialog
        {
            Filter = "Excel Files|*.xlsx",
            FileName = "DataGridView_Export.xlsx"
        };

        if (saveFileDialog.ShowDialog() == DialogResult.OK)
        {
            workbook.SaveAs(saveFileDialog.FileName);
            MessageBox.Show("Export completed successfully!", "Success",
                            MessageBoxButtons.OK, MessageBoxIcon.Information);
        }
    }
    catch (Exception ex)
    {
        MessageBox.Show($"Export failed: {ex.Message}", "Error",
                       MessageBoxButtons.OK, MessageBoxIcon.Error);
    }
}
private void btnExport_Click(object sender, EventArgs e)
{
    try
    {
        // Create a new Excel workbook in XLSX format
        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet worksheet = workbook.CreateWorkSheet("Exported Data");

        // Write column headers to row 0
        for (int col = 0; col < dataGridView1.Columns.Count; col++)
        {
            worksheet.SetCellValue(0, col, dataGridView1.Columns[col].HeaderText);
        }

        // Write data rows starting at row 1
        for (int row = 0; row < dataGridView1.Rows.Count; row++)
        {
            // Skip the placeholder new-row at the bottom of the grid
            if (dataGridView1.AllowUserToAddRows && row == dataGridView1.Rows.Count - 1)
                continue;

            for (int col = 0; col < dataGridView1.Columns.Count; col++)
            {
                var cellValue = dataGridView1.Rows[row].Cells[col].Value;
                if (cellValue != null)
                {
                    worksheet.SetCellValue(row + 1, col, cellValue.ToString());
                }
            }
        }

        // Prompt the user to choose a save location
        using SaveFileDialog saveFileDialog = new SaveFileDialog
        {
            Filter = "Excel Files|*.xlsx",
            FileName = "DataGridView_Export.xlsx"
        };

        if (saveFileDialog.ShowDialog() == DialogResult.OK)
        {
            workbook.SaveAs(saveFileDialog.FileName);
            MessageBox.Show("Export completed successfully!", "Success",
                            MessageBoxButtons.OK, MessageBoxIcon.Information);
        }
    }
    catch (Exception ex)
    {
        MessageBox.Show($"Export failed: {ex.Message}", "Error",
                       MessageBoxButtons.OK, MessageBoxIcon.Error);
    }
}
$vbLabelText   $csharpLabel

Décomposition des étapes d'exportation

Chaque étape de la méthode sert un objectif précis :

  • WorkBook.Create : Initialise un nouveau fichier Excel en mémoire au format XLSX. Aucun fichier n'est écrit sur le disque tant que SaveAs n'est pas appelé.
  • CreateWorkSheet : Ajoute une feuille de calcul nommée pour contenir les données exportées. Le nom " Données exportées " apparaît comme étiquette d'onglet dans Excel.
  • Boucle d'en-tête de colonne : Lit dataGridView1.Columns[col].HeaderText pour chaque colonne et l'écrit à l'index de ligne 0. C'est l'étape clé qui préserve les en-têtes.
  • Boucles de lignes de données : Les boucles imbriquées parcourent chaque ligne et colonne, en utilisant row + 1 comme index de ligne Excel afin que les données commencent toujours sous la ligne d'en-tête.
  • Vérification des valeurs nulles : empêche les exceptions lorsqu'une cellule ne contient aucune valeur, ce qui est fréquent dans les données réelles.
  • SaveFileDialog : Permet aux utilisateurs de choisir le nom et la destination du fichier lors de l'exécution plutôt que de coder en dur un chemin d'accès.

Le fichier exporté ressemble à ceci :

C# Exportation de DataGridView vers Excel avec en-têtes de colonnes à l'aide IronXL: Image 2 - Fichier Excel de sortie avec les données d'exemple exportées

Comment gérez-vous les cas particuliers courants lors de l'exportation ?

Les données réelles sont rarement aussi propres qu'un jeu de données d'exemple. Voici les scénarios que vous êtes le plus susceptible de rencontrer et comment les gérer.

Cellules vides

La vérification nulle (if (cellValue != null)) dans la boucle de données gère les cellules vides sans lever d'exception. Les cellules vides restent vierges dans le fichier Excel exporté, préservant ainsi la structure de la grille.

Types de données mixtes

IronXL gère automatiquement différents formats de données . Lorsque vous transmettez un nombre sous forme de chaîne de caractères via ToString(), Excel peut toujours le reconnaître comme numérique en fonction de sa valeur. Pour un contrôle précis du type, convertissez la valeur de la cellule au type approprié avant d'écrire :

if (cellValue is int intVal)
    worksheet.SetCellValue(row + 1, col, intVal);
else if (cellValue is decimal decVal)
    worksheet.SetCellValue(row + 1, col, (double)decVal);
else
    worksheet.SetCellValue(row + 1, col, cellValue?.ToString() ?? string.Empty);
if (cellValue is int intVal)
    worksheet.SetCellValue(row + 1, col, intVal);
else if (cellValue is decimal decVal)
    worksheet.SetCellValue(row + 1, col, (double)decVal);
else
    worksheet.SetCellValue(row + 1, col, cellValue?.ToString() ?? string.Empty);
$vbLabelText   $csharpLabel

Cette approche permet de conserver les colonnes numériques comme étant numériques dans Excel, afin que les formules et le tri fonctionnent correctement par la suite.

Caractères spéciaux dans les en-têtes

Les en-têtes de colonnes contenant des caractères spéciaux tels que &, <, > et des lettres accentuées sont exportés correctement. IronXL gère l'encodage automatiquement et ne nécessite aucune intervention de votre part.

Grands ensembles de données

Pour les grilles contenant des dizaines de milliers de lignes, envisagez de déplacer la logique d'exportation vers un thread d'arrière-plan afin de préserver la réactivité de l'interface utilisateur. Encapsulez la logique de boucle dans un appel et mettez à jour l'interface utilisateur à partir de la fonction de rappel terminée. La documentation de Microsoft sur la programmation asynchrone avec Task explique ce modèle en détail.

Pour d'autres scénarios tels que la mise en forme des cellules , la préservation des formules et la protection par mot de passe, la documentation IronXL les couvre en détail.

Comment se comparent les principales approches d'exportation ?

Avant de s'engager avec une bibliothèque, il est utile de comprendre les compromis entre les méthodes les plus courantes.

Comparaison des méthodes d'exportation de DataGridView vers Excel en C#
Méthode Bureau requis En-têtes de colonnes Performance Serveur sécurisé
Interopérabilité de Microsoft Office Oui Manuel Lent Non
Kit de développement logiciel OpenXml Non Manuel Rapide Oui
ClosedXML Non Manuel Bien Oui
IronXL Non Automatique Rapide Oui

Les solutions basées sur l'interopérabilité nécessitent l'installation d'Excel sur le serveur, ce qui pose un problème de licence et complexifie le déploiement. Le kit de développement logiciel OpenXml est puissant mais de bas niveau : l'écriture d'une ligne d'en-tête nécessite la construction manuelle des structures XML. IronXL et ClosedXML fournissent tous deux des API de plus haut niveau, mais le modèle WorkBook et WorkSheet d'IronXL correspond étroitement à la façon dont les développeurs conçoivent déjà les feuilles de calcul.

Comment exporter au format CSV au lieu de XLSX ?

La même méthode d'exportation s'applique lorsque vous avez besoin d'un fichier CSV au lieu d'un classeur Excel. Modifier le format et l'extension du fichier :

WorkBook csvWorkbook = WorkBook.Create(ExcelFileFormat.CSV);
WorkSheet csvSheet = csvWorkbook.CreateWorkSheet("Data");

// Headers and data loops remain identical

using SaveFileDialog dialog = new SaveFileDialog
{
    Filter = "CSV Files|*.csv",
    FileName = "DataGridView_Export.csv"
};

if (dialog.ShowDialog() == DialogResult.OK)
    csvWorkbook.SaveAs(dialog.FileName);
WorkBook csvWorkbook = WorkBook.Create(ExcelFileFormat.CSV);
WorkSheet csvSheet = csvWorkbook.CreateWorkSheet("Data");

// Headers and data loops remain identical

using SaveFileDialog dialog = new SaveFileDialog
{
    Filter = "CSV Files|*.csv",
    FileName = "DataGridView_Export.csv"
};

if (dialog.ShowDialog() == DialogResult.OK)
    csvWorkbook.SaveAs(dialog.FileName);
$vbLabelText   $csharpLabel

L'exportation au format CSV est utile lorsque le système utilisateur ne prend pas en charge le format XLSX ou lorsque la taille du fichier est un problème pour les très grands ensembles de données.

Comment mettre en forme la ligne d'en-tête dans le fichier exporté ?

Les données exportées sont plus lisibles lorsque la ligne d'en-tête est visuellement distincte. IronXL propose des options de style de cellule qui vous permettent d'appliquer du texte en gras, une couleur d'arrière-plan et une taille de police après avoir saisi les valeurs d'en-tête :

// Write headers and apply bold styling
for (int col = 0; col < dataGridView1.Columns.Count; col++)
{
    string cellAddress = worksheet.GetCellAddress(0, col);
    worksheet[cellAddress].Value = dataGridView1.Columns[col].HeaderText;
    worksheet[cellAddress].Style.Font.Bold = true;
    worksheet[cellAddress].Style.SetBackgroundColor("#4472C4");
    worksheet[cellAddress].Style.Font.FontColor = "#FFFFFF";
}
// Write headers and apply bold styling
for (int col = 0; col < dataGridView1.Columns.Count; col++)
{
    string cellAddress = worksheet.GetCellAddress(0, col);
    worksheet[cellAddress].Value = dataGridView1.Columns[col].HeaderText;
    worksheet[cellAddress].Style.Font.Bold = true;
    worksheet[cellAddress].Style.SetBackgroundColor("#4472C4");
    worksheet[cellAddress].Style.Font.FontColor = "#FFFFFF";
}
$vbLabelText   $csharpLabel

Une ligne d'en-tête stylisée rend le fichier exporté immédiatement utilisable pour la création de rapports, sans que le destinataire ait à appliquer manuellement la mise en forme. Pour une liste complète des propriétés de style, consultez la référence de style des cellules IronXL .

Comment bénéficier d'un essai gratuit ?

IronXL propose un essai gratuit qui vous permet de tester toutes les fonctionnalités, y compris les flux de travail d'exportation présentés dans cet article. Installez le package à l'aide de l'une des commandes NuGet indiquées ci-dessus, générez une clé d'essai sur la page de licences IronXL et configurez-la dans votre application avant le premier appel à la bibliothèque :

IronXl.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";
IronXl.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";
$vbLabelText   $csharpLabel

La version d'essai génère des fichiers Excel entièrement fonctionnels et ne restreint pas les fonctionnalités disponibles. Pour le déploiement en production, les options de licence couvrent les développeurs individuels, les équipes et la redistribution sans redevance.

Pour des scénarios d'exportation similaires, découvrez comment IronXL gère l'exportation directe de DataTables vers Excel , la lecture de fichiers Excel dans des DataGridViews et la création de graphiques à partir de données exportées .

Choisir la stratégie d'exportation adaptée à votre cas d'utilisation

La méthode d'exportation cellule par cellule, simple et directe, présentée tout au long de ce tutoriel, convient à la plupart des applications Windows Forms. Si votre DataGridView est lié à un DataTable, vous pouvez également transmettre directement le DataTable au convertisseur DataTable vers feuille de calcul d'IronXL, qui gère automatiquement la ligne d'en-tête. Choisissez l'approche directe DataTable lorsque la disposition de vos colonnes est fixe et que vous souhaitez le chemin de code le plus court possible. Choisissez l'approche manuelle cellule par cellule lorsque vous avez besoin d'une logique conditionnelle par cellule, par exemple pour mettre en évidence les cellules dont la valeur se situe en dehors d'une plage acceptable, ou pour mapper explicitement les types pouvant être nuls avant l'écriture.

Pour les scénarios côté serveur tels que les contrôleurs ASP.NET Core qui génèrent des rapports Excel téléchargeables, la même API IronXL s'applique. La seule différence est la cible de sauvegarde : au lieu de SaveAs(filePath), appelez workbook.ToByteArray() et écrivez les octets dans la réponse HTTP avec un type de contenu de application/vnd.openxmlformats-officedocument.spreadsheetml.sheet. Les en-têtes de colonnes sont transférés de manière identique, que la sortie soit dirigée vers un fichier ou un flux.

Questions Fréquemment Posées

Comment puis-je exporter les données de DataGridView vers Excel en C# ?

Utilisez la bibliothèque IronXL pour créer un classeur Excel, parcourez les colonnes du contrôle DataGridView pour écrire les en-têtes jusqu'à la ligne 0, puis parcourez les lignes de données et écrivez les valeurs des cellules à partir de la ligne 1. Enregistrez le classeur avec la commande Enregistrer sous.

Quel est l'avantage d'utiliser IronXL pour l'exportation de données ?

IronXL propose une API de haut niveau pour les opérations Excel, ne nécessitant aucune installation de Microsoft Office. Elle gère les en-têtes, les types de données et les formats de fichiers sans manipulation manuelle du XML.

Est-il possible de conserver les en-têtes de colonne lors de l'exportation de DataGridView vers Excel ?

Oui. Lisez la propriété HeaderText de chaque colonne DataGridView et écrivez-la dans la ligne 0 de la feuille de calcul IronXL avant d'écrire les lignes de données.

Ai-je besoin d'une version d'essai pour commencer à utiliser IronXl.Excel pour l'exportation vers Excel ?

Une version d'essai gratuite est disponible et donne accès à toutes les fonctionnalités. Installez le package NuGet , générez une clé d'essai et définissez la propriété `IronXL avant d'effectuer tout appel à la bibliothèque.

IronXL peut-il gérer de grands ensembles de données DataGridView lors de l'exportation vers Excel ?

Oui. Pour les très grandes grilles, exécutez l'exportation sur un thread d'arrière-plan à l'aide de Task.Run afin de maintenir la réactivité de l'interface utilisateur pendant IronXL écrit les données.

Quelles sont les étapes pour exporter DataGridView vers Excel en utilisant IronXl.Excel ?

Installez IronXL, créez un classeur et une feuille de calcul, parcourez les colonnes du DataGridView pour écrire les en-têtes à la ligne 0, parcourez les lignes pour écrire les données à partir de la ligne 1, puis appelez SaveAs pour écrire le fichier.

Pourquoi choisir IronXL plutôt que d'autres bibliothèques pour l'exportation vers Excel ?

IronXL ne nécessite aucune installation d'Office, fonctionne sur des serveurs et fournit une API WorkBook/WorkSheet propre qui correspond naturellement à la façon dont les développeurs conçoivent les feuilles de calcul, avec une documentation solide et un support actif.

Existe-t-il une assistance pour résoudre les problèmes liés à IronXL ?

Oui. IronXL fournit une documentation API détaillée, des exemples de code et un support technique direct pour les clients disposant d'une licence.

Puis-je personnaliser le processus d'exportation Excel avec IronXL ?

Oui. Après avoir saisi les données, vous pouvez appliquer des polices en gras, des couleurs d'arrière-plan, des bordures et des formats numériques à n'importe quelle plage de cellules grâce à l'API Style d'IronXL.

IronXL prend-il en charge l'exportation de données vers d'autres formats qu'Excel ?

Oui. IronXL prend en charge les formats XLSX, XLS, CSV et TSV. Pour changer de format, il suffit de modifier la valeur de l'énumération ExcelFileFormat transmise à WorkBook.Create.

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