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, édite et gère des données tabulaires à partir de n'importe quelle source liée telle qu'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.Excel

using IronXL;
using System.Data;

using IronXL;
using System.Data;

Imports IronXL
Imports System.Data

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

Pour ce tutoriel, le formulaire contient un DataGridView nommé DataGridView1 et un bouton nommé btnExport. La grille est remplie lors de l'événement Load du formulaire avec des enregistrements d'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;
}

Option Strict On



Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
    Dim dt As New DataTable()

    ' Define columns with the appropriate .NET type
    dt.Columns.Add("EmployeeID", GetType(Integer))
    dt.Columns.Add("Name", GetType(String))
    dt.Columns.Add("Department", GetType(String))
    dt.Columns.Add("Salary", GetType(Decimal))

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

    DataGridView1.DataSource = dt
End Sub

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 le DataTable directement au DataGridView, et la grille rend 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 un nouveau WorkBook, récupère la feuille de calcul par défaut, écrit les en-têtes de colonne 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");
}

Private Sub btnExport_Click(sender As Object, e As EventArgs)
    Dim workbook = WorkBook.Create()
    Dim sheet = workbook.DefaultWorkSheet

    ' Write column headers to row index 0
    For col As Integer = 0 To DataGridView1.Columns.Count - 1
        sheet.SetCellValue(0, col, DataGridView1.Columns(col).HeaderText)
    Next

    ' Write data rows starting at row index 1
    For row As Integer = 0 To DataGridView1.Rows.Count - 1
        For col As Integer = 0 To DataGridView1.Columns.Count - 1
            Dim cellValue As Object = DataGridView1.Rows(row).Cells(col).Value
            If cellValue IsNot Nothing Then
                sheet.SetCellValue(row + 1, col, cellValue.ToString())
            End If
        Next
    Next

    Dim outputPath As String = "EmployeeData.xlsx"
    workbook.SaveAs(outputPath)
    MessageBox.Show("Export complete. File saved to: " & outputPath, "Success")
End Sub

L'objet WorkBook représente l'intégralité du fichier Excel en mémoire. DefaultWorkSheet renvoie la première feuille sans nécessiter que vous en créiez 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 terminé comme un fichier Open XML XLSX à l'emplacement 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 colonne apparaissent dans la première ligne, et toutes les lignes de données suivent dans le même ordre qu'elles apparaissent 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");
}

Option Strict On



Sub ExportWithFormatting()
    Dim workbook = WorkBook.Create()
    Dim sheet = workbook.DefaultWorkSheet

    ' Write column headers
    For col As Integer = 0 To DataGridView1.Columns.Count - 1
        sheet.SetCellValue(0, col, DataGridView1.Columns(col).HeaderText)
    Next

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

    ' Locate the Salary column index
    Dim salaryColIndex As Integer = -1
    For i As Integer = 0 To DataGridView1.Columns.Count - 1
        If String.Equals(DataGridView1.Columns(i).HeaderText, "Salary", StringComparison.OrdinalIgnoreCase) Then
            salaryColIndex = i
            Exit For
        End If
    Next

    ' Write data rows, preserving numeric types
    For row As Integer = 0 To DataGridView1.Rows.Count - 1
        If DataGridView1.Rows(row).IsNewRow Then Continue For

        For col As Integer = 0 To DataGridView1.Columns.Count - 1
            Dim cellValue As Object = DataGridView1.Rows(row).Cells(col).Value
            If cellValue Is Nothing Then Continue For

            Dim targetRow As Integer = row + 1

            If col = salaryColIndex Then
                ' Write salary as a true numeric decimal
                Dim decValue As Decimal
                If Decimal.TryParse(cellValue.ToString(), Globalization.NumberStyles.Number, Globalization.CultureInfo.InvariantCulture, decValue) Then
                    sheet.SetCellValue(targetRow, col, decValue)
                Else
                    sheet.SetCellValue(targetRow, col, cellValue.ToString())
                End If
            Else
                sheet.SetCellValue(targetRow, col, cellValue.ToString())
            End If
        Next
    Next

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

    workbook.SaveAs("FormattedEmployeeData.xlsx")
End Sub

La méthode GetRange accepte la notation Excel standard (A1:D1) pour sélectionner un bloc contigu de cellules. Configurer Style.Font.Bold, Style.SetBackgroundColor, et Style.Font.SetColor applique ces formats à chaque cellule de la plage sélectionnée. Pour les colonnes numériques, écrire la valeur comme un decimal plutôt qu'une chaîne conserve le type de données intact, ce qui signifie qu'Excel peut appliquer correctement le formatage des nombres tel 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 une alternance de teinte des rangées, un ajustement automatique de la largeur des colonnes ou figer des 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");
}

Sub ExportToCsv()
    Dim workbook = WorkBook.Create()
    Dim sheet = workbook.DefaultWorkSheet

    For col As Integer = 0 To DataGridView1.Columns.Count - 1
        sheet.SetCellValue(0, col, DataGridView1.Columns(col).HeaderText)
    Next

    For row As Integer = 0 To DataGridView1.Rows.Count - 1
        If DataGridView1.Rows(row).IsNewRow Then Continue For

        For col As Integer = 0 To DataGridView1.Columns.Count - 1
            Dim cell As Object = DataGridView1.Rows(row).Cells(col).Value
            If cell IsNot Nothing Then
                sheet.SetCellValue(row + 1, col, cell.ToString())
            End If
        Next
    Next

    ' Saving with a .csv extension produces a comma-separated file
    workbook.SaveAs("EmployeeData.csv")
End Sub

Le seul changement 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 en utilisant la méthode WorkSheet.LoadDataTable, en contournant entièrement l'itération cellule par cellule. Cette approche est plus rapide et préserve automatiquement tous les types de colonnes.

Pour les grilles non basées sur un DataTable, le modèle cellule par cellule montré précédemment reste l'approche standard. Si vous devez exporter de manière asynchrone pour garder l'interface utilisateur réactive pendant les grandes exportations, encapsulez la logique d'exportation dans un appel Task.Run et await le résultat sur un thread en 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 traditionnelles .NET 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 par .NET, donc le ramasse-miettes gère la mémoire automatiquement 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 large, y compris la conversion de PDF, la génération de graphiques, et un support commercial, qui peuvent être des facteurs dans les décisions d'achat d'entreprise. 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 avez maintenant du code C# fonctionnel pour exporter un DataGridView vers un fichier Excel formaté en utilisant IronXL. À partir de là, considérez les directions suivantes :

• Ajoutez une gestion des erreurs : Enveloppez le code d'exportation dans un bloc try/catch et affichez un message convivial si le fichier est verrouillé ou si le chemin est invalide
• Soutenir la sélection du chemin de fichier : Utilisez SaveFileDialog pour laisser les utilisateurs choisir l'emplacement et le nom du fichier de sortie à l'exécution
• Charger des données réelles : Remplacez l'échantillon DataTable par une requête de base de données en utilisant ADO.NET ou Entity Framework
• Lire les fichiers existants : utilisez WorkBook.Load pour ouvrir un tableur existant et le mettre à jour au lieu d'en créer un nouveau à chaque fois.
• Exporter vers plusieurs feuilles : Créez des objets WorkSheet supplémentaires dans le même WorkBook pour organiser les jeux de données connexes
• 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 Enterprise.
• 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.