Comment exporter une DataGridView vers Excel avec des en-têtes de colonne en C#

Pourquoi IronXL est-il le choix idéal ?

IronXL simplifie les opérations Excel dans les applications .NET en fournissant une API intuitive qui ne nécessite pas l'installation de Microsoft Excel. Contrairement aux solutions basées sur l'interopérabilité, IronXL fonctionne de manière indépendante, ce qui le rend idéal pour les environnements serveur et les machines sans Office.

La bibliothèque prend en charge tous les formats Excel, y compris XLSX, XLS et CSV, tout en préservant l'intégrité et la mise en forme des données tout au long du processus d'exportation. Les développeurs peuvent facilement copier des données, étendre des feuilles et supprimer ou ajouter des lignes sans avoir besoin d'Excel installé.

Configuration de votre projet Windows Forms

Commencez par créer une nouvelle application Windows Forms dans Visual Studio. Une fois votre projet prêt, installez IronXL via le gestionnaire de packages NuGet. Ouvrez la console du gestionnaire de packages et exécutez :

Install-Package IronXL.Excel

Après l'installation, ajoutez ces espaces de noms essentiels à votre formulaire :

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

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

IRON VB CONVERTER ERROR developers@ironsoftware.com

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.

Création du contrôle DataGridView avec des exemples de données

Créons une interface simple avec un contrôle DataGridView alimenté par une source de données d'exemple. Vous pouvez également importer des données à partir d'un fichier CSV ou d'une base de données ; la même approche DataTable décrite ci-dessous fonctionne pour les ensembles de données importés. Ajoutez un nouveau contrôle DataGridView et un bouton à votre formulaire via le concepteur Visual Studio, puis utilisez ce code pour configurer les données :

private void Form1_Load(object sender, EventArgs e)
{
    // Example object usage
    object obj = "Initializing DataTable"; 
    Console.WriteLine(obj);
    // Create a DataTable with sample data
    DataTable dt = new DataTable();
    // Add columns with descriptive 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 the DataTable to DataGridView Control
    dataGridView1.DataSource = dt;
}

private void Form1_Load(object sender, EventArgs e)
{
    // Example object usage
    object obj = "Initializing DataTable"; 
    Console.WriteLine(obj);
    // Create a DataTable with sample data
    DataTable dt = new DataTable();
    // Add columns with descriptive 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 the DataTable to DataGridView Control
    dataGridView1.DataSource = dt;
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Cet exemple crée un DataTable et le lie à la grille. Même avec une petite quantité de données, cette approche s'adapte bien aux tableaux plus volumineux. Les noms de colonnes définis ici deviendront les en-têtes de votre fichier Excel.

Les données d'exemple représentent un inventaire de produits simple, ce qui permet de vérifier facilement que l'exportation a fonctionné correctement. Pour les scénarios de liaison de données plus complexes, la documentation Microsoft sur la liaison de données DataGridView fournit des exemples supplémentaires.

Cela crée un DataGridView rempli avec toutes les données issues de notre code :

Comment exporter un DataGridView vers Excel avec les en-têtes de colonnes en C# : Figure 1 - Exemple de données dans un DataGridView

Mise en œuvre de l'exportation avec en-têtes de colonnes

Passons maintenant à la fonctionnalité principale : l'exportation du DataGridView vers Excel tout en préservant les en-têtes de colonnes. Ajoutez cette méthode pour gérer le clic sur le bouton d'exportation :

private void btnExport_Click(object sender, EventArgs e)
{
    // Create a new Excel workbook
    WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
    WorkSheet worksheet = workbook.CreateWorkSheet("Exported Data");
    // Export column headers
    for (int col = 0; col < dataGridView1.Columns.Count; col++)
    {
        worksheet.SetCellValue(0, col, dataGridView1.Columns[col].HeaderText);
    }
    // Export data rows
    for (int row = 0; row < dataGridView1.Rows.Count; row++)
    {
        // Skip the last empty row (used for adding new rows in DataGridView)
        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());
            }
        }
    }
    // Show save dialog
    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);
        }
    }
}

private void btnExport_Click(object sender, EventArgs e)
{
    // Create a new Excel workbook
    WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
    WorkSheet worksheet = workbook.CreateWorkSheet("Exported Data");
    // Export column headers
    for (int col = 0; col < dataGridView1.Columns.Count; col++)
    {
        worksheet.SetCellValue(0, col, dataGridView1.Columns[col].HeaderText);
    }
    // Export data rows
    for (int row = 0; row < dataGridView1.Rows.Count; row++)
    {
        // Skip the last empty row (used for adding new rows in DataGridView)
        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());
            }
        }
    }
    // Show save dialog
    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);
        }
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Cette méthode d'exportation effectue plusieurs étapes cruciales :

1. Création du classeur : WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX) initialise un nouveau fichier Excel en mémoire
2. Ajout d'une feuille de calcul : La méthode CreateWorkSheet ajoute une feuille nommée pour contenir vos données.
3. Exportation des en-têtes : La première boucle parcourt les colonnes du DataGridView, extrait la propriété HeaderText et l'écrit dans la ligne 0.
4. Exportation des données : Les boucles imbriquées traitent chaque cellule du tableau, avec une vérification des valeurs nulles pour éviter les erreurs.
5. Enregistrement convivial : la boîte de dialogue Enregistrer le fichier permet à l'utilisateur de choisir l'emplacement et le nom du fichier.

La clé pour préserver les en-têtes réside dans l'accès à la propriété dataGridView1.Columns[i].HeaderText, qui contient le texte d'affichage de chaque en-tête de colonne. Vous pouvez ajouter un commentaire au-dessus de chaque étape d'exportation pour en clarifier l'objectif à l'intention des autres développeurs ou pour la maintenance future.

Comment exporter un DataGridView vers Excel avec les en-têtes de colonnes en C# : Figure 2 - Fichier Excel généré avec les données d'exemple exportées

Gestion des scénarios d'exportation de données de fichiers Excel courants

Lorsque vous travaillez avec des données réelles, vous rencontrerez divers scénarios qui nécessitent

traitement spécial du feu :

• Cellules vides : La vérification des valeurs nulles dans notre code empêche les erreurs lorsque les cellules ne contiennent aucune donnée. Les cellules vides apparaissent comme des cellules blanches dans Excel, préservant ainsi la structure de la grille.
• Types de données mixtes : IronXL gère automatiquement différents formats de données . Dans Excel, les nombres restent numériques, ce qui permet d'effectuer des calculs, tandis que le texte reste sous forme de chaînes de caractères.
• Caractères spéciaux : Les en-têtes de colonnes contenant des caractères spéciaux s'exportent correctement. IronXL gère l'encodage automatiquement, préservant des caractères comme &, <, > et les lettres accentuées.

Des erreurs peuvent survenir lors de l'exportation de documents. Utilisez try-catch-finally pour une gestion robuste :

try 
{
    // Export code here
}
catch (Exception ex)
{
    MessageBox.Show($"Export failed: {ex.Message}", "Error", 
                   MessageBoxButtons.OK, MessageBoxIcon.Error);
}

try 
{
    // Export code here
}
catch (Exception ex)
{
    MessageBox.Show($"Export failed: {ex.Message}", "Error", 
                   MessageBoxButtons.OK, MessageBoxIcon.Error);
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

IronXL préserve les détails de votre feuille Excel tels que la mise en forme, les en-têtes et les caractères spéciaux. Pour des scénarios plus avancés, vous pouvez consulter la documentation d'IronXL comme référence pour des tâches telles que la sécurité des fichiers, le style des cellules ou la préservation des formules .

Conclusion

L'exportation de DataGridView vers Excel avec les en-têtes de colonnes est simple avec IronXL. La bibliothèque gère les opérations complexes sur les fichiers Excel pendant que vous vous concentrez sur la logique de votre application. Que vous choisissiez l'exportation directe cellule par cellule ou l'approche DataTable, vos en-têtes de colonnes seront parfaitement transférés vers Excel. Cela permet de convertir facilement les données de votre DataGridView au format Excel sans perdre d'en-têtes informatifs ni de données.

Nous espérons que cet article vous a aidé à mettre en œuvre une solution fiable pour vos besoins d'exportation de DataGridView, et que vous pouvez désormais utiliser en toute confiance les compétences acquises ici pour exporter vos DataGridView au format Excel. Si vous recherchez une solution fiable pour exporter un DataGridView C# vers Excel avec en-têtes de colonnes, IronXL offre une méthode simple et sans dépendances pour y parvenir.

Prêt à l'intégrer à votre projet ? Commencez par un essai gratuit d'IronXL pour découvrir toutes ses fonctionnalités. Pour une utilisation en production, les licences sont proposées à des tarifs compétitifs avec une assistance complète incluse.