Comment exporter un DataGridView vers Excel en C# avec IronXL

Comment configurer un projet Windows Forms pour l'exportation vers Excel ?

Windows Forms est une bibliothèque d'interface graphique fondamentale de l'écosystème .NET , largement utilisée pour la création d'applications de bureau. Le contrôle DataGridView est l'un de ses composants les plus utilisés : il affiche, modifie et gère les données tabulaires provenant de n'importe quelle source pouvant être liée, comme un DataTable, un résultat de requête de base de données ou une liste en mémoire.

L'exportation de ces données de grille vers Excel répond à plusieurs besoins quotidiens : envoi de rapports aux parties prenantes, archivage d'instantanés à des fins d'audit ou alimentation de données dans des outils analytiques en aval. Les deux approches traditionnelles sont l'interopérabilité Microsoft Office et les bibliothèques tierces. L'interopérabilité nécessite une copie d'Excel installée sur chaque machine exécutant l'application, crée des problèmes de cycle de vie des objets COM et offre de mauvaises performances dans les déploiements sur serveur ou dans le cloud. Des bibliothèques telles IronXL , ClosedXML et Syncfusion évitent ces problèmes en écrivant directement dans le format de fichier Open XML sans aucune dépendance à Office.

Ce guide présente l'approche IronXL en C# ciblant .NET 10, bien IronXL prenne en charge .NET Framework 4.6.2 et toutes les versions modernes de .NET .

Install-Package IronXL
dotnet add package IronXL

Install-Package IronXL
dotnet add package IronXL

using IronXL;
using System.Data;

using IronXL;
using System.Data;

Comment remplir un DataGridView avec des exemples de données ?

Pour cette procédure pas à pas, le formulaire contient un DataGridView nommé DataGridView1 et un bouton nommé btnExport. La grille est remplie dans l'événement Load du formulaire avec les enregistrements des employés stockés dans un DataTable :

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

    // Define columns with the appropriate .NET type
    dt.Columns.Add("EmployeeID", typeof(int));
    dt.Columns.Add("Name", typeof(string));
    dt.Columns.Add("Department", typeof(string));
    dt.Columns.Add("Salary", typeof(decimal));

    // Add sample rows
    dt.Rows.Add(101, "Sarah Johnson", "Engineering", 85000m);
    dt.Rows.Add(102, "Michael Chen", "Marketing", 72000m);
    dt.Rows.Add(103, "Emily Davis", "Finance", 91000m);
    dt.Rows.Add(104, "James Wilson", "Engineering", 78000m);

    DataGridView1.DataSource = dt;
}

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

    // Define columns with the appropriate .NET type
    dt.Columns.Add("EmployeeID", typeof(int));
    dt.Columns.Add("Name", typeof(string));
    dt.Columns.Add("Department", typeof(string));
    dt.Columns.Add("Salary", typeof(decimal));

    // Add sample rows
    dt.Rows.Add(101, "Sarah Johnson", "Engineering", 85000m);
    dt.Rows.Add(102, "Michael Chen", "Marketing", 72000m);
    dt.Rows.Add(103, "Emily Davis", "Finance", 91000m);
    dt.Rows.Add(104, "James Wilson", "Engineering", 78000m);

    DataGridView1.DataSource = dt;
}

Chaque colonne est définie avec un type .NET spécifique afin que les comparaisons numériques et la mise en forme fonctionnent correctement par la suite. La propriété DataSource lie directement DataTable à DataGridView, et la grille affiche automatiquement toutes les lignes lorsque le formulaire s'ouvre. En production, ces données proviendraient généralement d'une requête de base de données, d'un ensemble de résultats ORM ou d'une réponse d'API REST plutôt que de valeurs codées en dur.

Comment exporter les données d'un DataGridView vers un fichier Excel avec les en-têtes de colonnes ?

La logique d'exportation se trouve dans le gestionnaire de clic du bouton. Le code crée une nouvelle feuille de calcul WorkBook, récupère la feuille de calcul par défaut, écrit les en-têtes de colonnes sur la première ligne, puis écrit chaque ligne de données en dessous :

void btnExport_Click(object sender, EventArgs e)
{
    var workbook = WorkBook.Create();
    var sheet = workbook.DefaultWorkSheet;

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

    // Write data rows starting at row index 1
    for (int row = 0; row < DataGridView1.Rows.Count; row++)
    {
        for (int col = 0; col < DataGridView1.Columns.Count; col++)
        {
            object? cellValue = DataGridView1.Rows[row].Cells[col].Value;
            if (cellValue is not null)
            {
                sheet.SetCellValue(row + 1, col, cellValue.ToString()!);
            }
        }
    }

    string outputPath = "EmployeeData.xlsx";
    workbook.SaveAs(outputPath);
    MessageBox.Show("Export complete. File saved to: " + outputPath, "Success");
}

void btnExport_Click(object sender, EventArgs e)
{
    var workbook = WorkBook.Create();
    var sheet = workbook.DefaultWorkSheet;

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

    // Write data rows starting at row index 1
    for (int row = 0; row < DataGridView1.Rows.Count; row++)
    {
        for (int col = 0; col < DataGridView1.Columns.Count; col++)
        {
            object? cellValue = DataGridView1.Rows[row].Cells[col].Value;
            if (cellValue is not null)
            {
                sheet.SetCellValue(row + 1, col, cellValue.ToString()!);
            }
        }
    }

    string outputPath = "EmployeeData.xlsx";
    workbook.SaveAs(outputPath);
    MessageBox.Show("Export complete. File saved to: " + outputPath, "Success");
}

L'objet WorkBook représente l'intégralité du fichier Excel en mémoire. DefaultWorkSheet renvoie la première feuille sans vous demander d'en créer une explicitement. La boucle externe écrit le texte d'en-tête de HeaderText dans la ligne zéro. La boucle imbriquée parcourt ensuite chaque ligne de données, vérifiant si la valeur est nulle avant de convertir la valeur de la cellule en chaîne de caractères. Le décalage row + 1 déplace les données sous la ligne d'en-tête. SaveAs écrit le classeur final sous forme de fichier Open XML XLSX dans le chemin spécifié.

Le fichier résultant s'ouvre dans Excel, Google Sheets ou toute application capable de lire le format XLSX. Les en-têtes de colonnes apparaissent dans la première ligne, et toutes les lignes de données suivent dans le même ordre qu'elles sont apparues dans le DataGridView.

Comment appliquer une mise en forme aux cellules du fichier Excel exporté ?

Un simple export de données est fonctionnel mais pas prêt pour la présentation. L'API de style d'IronXL vous permet d'appliquer des polices en gras, des couleurs d'arrière-plan, des couleurs de texte et des formats numériques à n'importe quelle plage de cellules avant l'enregistrement :

void ExportWithFormatting()
{
    var workbook = WorkBook.Create();
    var sheet = workbook.DefaultWorkSheet;

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

    // Style the header row: bold white text on blue background
    var headerRange = sheet.GetRange("A1:D1");
    headerRange.Style.Font.Bold = true;
    headerRange.Style.SetBackgroundColor("#4472C4");
    headerRange.Style.Font.SetColor("#FFFFFF");

    // Locate the Salary column index
    int salaryColIndex = -1;
    for (int i = 0; i < DataGridView1.Columns.Count; i++)
    {
        if (string.Equals(DataGridView1.Columns[i].HeaderText, "Salary",
            StringComparison.OrdinalIgnoreCase))
        {
            salaryColIndex = i;
            break;
        }
    }

    // Write data rows, preserving numeric types
    for (int row = 0; row < DataGridView1.Rows.Count; row++)
    {
        if (DataGridView1.Rows[row].IsNewRow) continue;

        for (int col = 0; col < DataGridView1.Columns.Count; col++)
        {
            object? cellValue = DataGridView1.Rows[row].Cells[col].Value;
            if (cellValue is null) continue;

            int targetRow = row + 1;

            if (col == salaryColIndex)
            {
                // Write salary as a true numeric decimal
                if (decimal.TryParse(cellValue.ToString(),
                    System.Globalization.NumberStyles.Number,
                    System.Globalization.CultureInfo.InvariantCulture,
                    out decimal decValue))
                {
                    sheet.SetCellValue(targetRow, col, decValue);
                }
                else
                {
                    sheet.SetCellValue(targetRow, col, cellValue.ToString()!);
                }
            }
            else
            {
                sheet.SetCellValue(targetRow, col, cellValue.ToString()!);
            }
        }
    }

    // Apply currency format to the salary column data range
    var salaryRange = sheet.GetRange("D2:D5");
    salaryRange.FormatString = "$#,##0";

    workbook.SaveAs("FormattedEmployeeData.xlsx");
}

void ExportWithFormatting()
{
    var workbook = WorkBook.Create();
    var sheet = workbook.DefaultWorkSheet;

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

    // Style the header row: bold white text on blue background
    var headerRange = sheet.GetRange("A1:D1");
    headerRange.Style.Font.Bold = true;
    headerRange.Style.SetBackgroundColor("#4472C4");
    headerRange.Style.Font.SetColor("#FFFFFF");

    // Locate the Salary column index
    int salaryColIndex = -1;
    for (int i = 0; i < DataGridView1.Columns.Count; i++)
    {
        if (string.Equals(DataGridView1.Columns[i].HeaderText, "Salary",
            StringComparison.OrdinalIgnoreCase))
        {
            salaryColIndex = i;
            break;
        }
    }

    // Write data rows, preserving numeric types
    for (int row = 0; row < DataGridView1.Rows.Count; row++)
    {
        if (DataGridView1.Rows[row].IsNewRow) continue;

        for (int col = 0; col < DataGridView1.Columns.Count; col++)
        {
            object? cellValue = DataGridView1.Rows[row].Cells[col].Value;
            if (cellValue is null) continue;

            int targetRow = row + 1;

            if (col == salaryColIndex)
            {
                // Write salary as a true numeric decimal
                if (decimal.TryParse(cellValue.ToString(),
                    System.Globalization.NumberStyles.Number,
                    System.Globalization.CultureInfo.InvariantCulture,
                    out decimal decValue))
                {
                    sheet.SetCellValue(targetRow, col, decValue);
                }
                else
                {
                    sheet.SetCellValue(targetRow, col, cellValue.ToString()!);
                }
            }
            else
            {
                sheet.SetCellValue(targetRow, col, cellValue.ToString()!);
            }
        }
    }

    // Apply currency format to the salary column data range
    var salaryRange = sheet.GetRange("D2:D5");
    salaryRange.FormatString = "$#,##0";

    workbook.SaveAs("FormattedEmployeeData.xlsx");
}

La méthode GetRange accepte la notation Excel standard (A1:D1) pour sélectionner un bloc contigu de cellules. Les paramètres Style.Font.Bold, Style.SetBackgroundColor et Style.Font.SetColor appliquent ces formats à chaque cellule de la plage sélectionnée. Pour les colonnes numériques, écrire la valeur sous la forme decimal plutôt que sous forme de chaîne de caractères permet de conserver le type de données intact, ce qui signifie qu'Excel peut appliquer correctement la mise en forme des nombres tels que $#,##0. Les cellules stockées sous forme de chaînes de caractères ne répondent pas aux codes de format numérique.

Vous pouvez étendre ce modèle pour appliquer un ombrage alterné des lignes, un ajustement automatique de la largeur des colonnes ou figer les volets en consultant la documentation de style IronXL .

Comment exporter les données d'un DataGridView au format CSV plutôt qu'XLSX ?

Certains flux de travail nécessitent une sortie CSV pour assurer la compatibilité avec les systèmes existants ou les pipelines de données légers. IronXL gère l'exportation CSV sans aucune modification de configuration supplémentaire du code principal :

void ExportToCsv()
{
    var workbook = WorkBook.Create();
    var sheet = workbook.DefaultWorkSheet;

    for (int col = 0; col < DataGridView1.Columns.Count; col++)
    {
        sheet.SetCellValue(0, col, DataGridView1.Columns[col].HeaderText);
    }

    for (int row = 0; row < DataGridView1.Rows.Count; row++)
    {
        if (DataGridView1.Rows[row].IsNewRow) continue;

        for (int col = 0; col < DataGridView1.Columns.Count; col++)
        {
            object? cell = DataGridView1.Rows[row].Cells[col].Value;
            if (cell is not null)
                sheet.SetCellValue(row + 1, col, cell.ToString()!);
        }
    }

    // Saving with a .csv extension produces a comma-separated file
    workbook.SaveAs("EmployeeData.csv");
}

void ExportToCsv()
{
    var workbook = WorkBook.Create();
    var sheet = workbook.DefaultWorkSheet;

    for (int col = 0; col < DataGridView1.Columns.Count; col++)
    {
        sheet.SetCellValue(0, col, DataGridView1.Columns[col].HeaderText);
    }

    for (int row = 0; row < DataGridView1.Rows.Count; row++)
    {
        if (DataGridView1.Rows[row].IsNewRow) continue;

        for (int col = 0; col < DataGridView1.Columns.Count; col++)
        {
            object? cell = DataGridView1.Rows[row].Cells[col].Value;
            if (cell is not null)
                sheet.SetCellValue(row + 1, col, cell.ToString()!);
        }
    }

    // Saving with a .csv extension produces a comma-separated file
    workbook.SaveAs("EmployeeData.csv");
}

La seule différence par rapport à l'exportation XLSX est l'extension de fichier transmise à SaveAs. IronXL détecte l'extension et sérialise automatiquement le classeur au format approprié. Cette cohérence signifie que votre logique d'écriture de données reste identique quel que soit le format de sortie, ce qui représente un avantage significatif par rapport aux bibliothèques qui nécessitent des chemins de code distincts pour chaque format.

L'exportation CSV est particulièrement utile lorsque le consommateur en aval est un script Python pandas , un outil d'importation en masse de bases de données ou une plateforme d'analyse qui ne peut pas lire les fichiers binaires XLSX.

Comment gérer efficacement les grands ensembles de données DataGridView ?

Pour les grilles contenant des dizaines de milliers de lignes, la performance devient un facteur à prendre en compte. Le modèle suivant réduit la pression sur la mémoire en construisant l'ensemble des données en une seule passe :

Lorsque le DataGridView est lié à un DataTable, vous pouvez charger le tableau directement dans IronXL à l'aide de la méthode WorkSheet.LoadDataTable , en contournant complètement l'itération cellule par cellule. Cette approche est plus rapide et préserve automatiquement tous les types de colonnes.

Pour les grilles non prises en charge par un DataTable, le modèle cellule par cellule présenté précédemment reste l'approche standard. Si vous devez exporter de manière asynchrone pour maintenir la réactivité de l'interface utilisateur lors d'exportations importantes, enveloppez la logique d'exportation dans un appel Task.Run et await le résultat sur un thread d'arrière-plan. Consultez la documentation sur les opérations de fichiers asynchrones pour connaître les modèles de renvoi des résultats vers le thread d'interface utilisateur.

Pourquoi IronXL est-il meilleur qu'Interopérabilité de bureau pour l'exportation de DataGridView ?

Les solutions .NET traditionnelles utilisaient Microsoft.Office.Interop.Excel pour piloter un processus Excel en cours d'exécution. Cette approche engendre plusieurs problèmes de déploiement et de fiabilité :

Chaque machine exécutant l'application doit disposer d'une copie sous licence de Microsoft Excel installée. Les environnements serveur et les conteneurs cloud ne peuvent généralement pas installer Office. L'interopérabilité COM exige la libération explicite de chaque objet afin d'éviter les fuites de mémoire et les processus Excel zombies.

• La gestion des erreurs à travers la frontière COM est verbeuse et fragile. Les performances se dégradent rapidement à mesure que le nombre de lignes augmente.

IronXL écrit directement au format de fichier OOXML sans lancer aucun processus externe. Les applications se déploient en tant qu'unités autonomes. L'API de la bibliothèque est entièrement gérée en .NET, donc le ramasse-miettes gère automatiquement la mémoire sans appels Marshal.ReleaseComObject. La vitesse est nettement supérieure car aucune communication inter-processus n'a lieu.

Pour les équipes qui évaluent des alternatives, ClosedXML est une option open source populaire. IronXL offre un ensemble de fonctionnalités plus étendu, incluant la conversion PDF , la génération de graphiques et un support commercial, qui peuvent être des facteurs déterminants dans les décisions d'achat des entreprises. Examinez les options de licence IronXL pour choisir le niveau adapté à la taille de votre équipe et à votre scénario de déploiement.

La section tutoriels IronXL couvre la lecture de fichiers Excel existants, la modification de modèles, la génération de graphiques et l'application d'une mise en forme conditionnelle — autant de fonctionnalités qui découlent naturellement du modèle d'exportation DataGridView présenté ici.

Quelles sont vos prochaines étapes ?

Vous disposez maintenant d'un code C# fonctionnel pour exporter un DataGridView vers un fichier Excel formaté à l'aide IronXL. À partir de là, considérez les directions suivantes :

• Ajouter une gestion des erreurs : Encadrer le code d'exportation dans un bloc try/catch et afficher un message convivial si le fichier est verrouillé ou si le chemin d'accès est invalide.
• Prise en charge de la sélection du chemin de fichier : Utilisez SaveFileDialog pour permettre aux utilisateurs de choisir l'emplacement et le nom du fichier de sortie lors de l'exécution.
• Charger des données réelles : remplacez l'exemple DataTable par une requête de base de données utilisant .NET ou Entity Framework.
• Lire les fichiers existants : Utilisez WorkBook.Load pour ouvrir une feuille de calcul existante et la mettre à jour au lieu d'en créer systématiquement une nouvelle.
• Exporter vers plusieurs feuilles : Créez des objets WorkSheet supplémentaires dans le même WorkBook pour organiser les ensembles de données associés
• Appliquer une mise en forme conditionnelle : mettre en évidence les cellules qui dépassent les seuils à l'aide de l'API de mise en forme conditionnelle d'IronXL
• Examinez les options de licence : un essai gratuit est disponible ; Les différents niveaux de licence couvrent les développeurs individuels jusqu'aux déploiements en entreprise.
• Consultez la documentation complète de l'API : la documentation de référence des objets IronXL recense toutes les classes et méthodes disponibles.