Exporter un DataGridView vers Excel en C# avec IronXL

Comment IronXL et Interop se comparent-ils ?

Le tableau ci-dessous résume les principales différences entre IronXL et Microsoft Office Interop pour les scénarios d'exportation Excel :

Comment installer IronXL dans votre projet C# ?

Ouvrez la console du gestionnaire de packages dans Visual Studio et exécutez la commande suivante, ou utilisez l'interface de ligne de commande .NET :

Install-Package IronXL
dotnet add package IronXL

Install-Package IronXL
dotnet add package IronXL

Sortie de terminal montrant l'installation réussie du paquet NuGet IronXL.Excel et de ses dépendances dans un projet C#

Pour connaître les options d'installation détaillées, consultez le guide d'installation IronXL NuGet ou recherchez le package directement sur NuGet.org. Une fois installée, ajoutez using IronXL; à vos fichiers de projet C# pour accéder aux fonctionnalités d'exportation Excel de la bibliothèque. Lors du déploiement en environnement de production, appliquez votre clé de licence pour activer toutes les fonctionnalités. Vous pouvez obtenir une licence d'essai gratuite pour évaluer IronXL avant de l'acheter.

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

// Create a DataTable with sample product data
var dt = new DataTable();
dt.Columns.Add("Product ID", typeof(int));
dt.Columns.Add("Product Name", typeof(string));
dt.Columns.Add("Category", typeof(string));
dt.Columns.Add("Price", typeof(decimal));
dt.Columns.Add("Stock", typeof(int));

dt.Rows.Add(1001, "Laptop Pro", "Electronics", 1299.99m, 15);
dt.Rows.Add(1002, "Wireless Mouse", "Accessories", 29.99m, 50);
dt.Rows.Add(1003, "USB-C Cable", "Accessories", 19.99m, 100);
dt.Rows.Add(1004, "Monitor 27\"", "Electronics", 399.99m, 8);
dt.Rows.Add(1005, "Keyboard Mechanical", "Accessories", 89.99m, 25);

// Bind to DataGridView
var dataGridView1 = new DataGridView();
dataGridView1.DataSource = dt;

// Create new Excel workbook
var workbook = WorkBook.Create(ExcelFileFormat.XLSX);
var worksheet = workbook.DefaultWorkSheet;

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

// Export data rows
for (int rowIndex = 0; rowIndex < dataGridView1.Rows.Count; rowIndex++)
{
    if (!dataGridView1.Rows[rowIndex].IsNewRow)
    {
        for (int colIndex = 0; colIndex < dataGridView1.Columns.Count; colIndex++)
        {
            var cellValue = dataGridView1.Rows[rowIndex].Cells[colIndex].Value;
            if (cellValue is decimal or double or int)
                worksheet.SetCellValue(rowIndex + 1, colIndex, Convert.ToDouble(cellValue));
            else
                worksheet.SetCellValue(rowIndex + 1, colIndex, cellValue?.ToString() ?? string.Empty);
        }
    }
}

// Save the Excel file
workbook.SaveAs("DataGridViewExport.xlsx");
Console.WriteLine("Export completed successfully!");

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

// Create a DataTable with sample product data
var dt = new DataTable();
dt.Columns.Add("Product ID", typeof(int));
dt.Columns.Add("Product Name", typeof(string));
dt.Columns.Add("Category", typeof(string));
dt.Columns.Add("Price", typeof(decimal));
dt.Columns.Add("Stock", typeof(int));

dt.Rows.Add(1001, "Laptop Pro", "Electronics", 1299.99m, 15);
dt.Rows.Add(1002, "Wireless Mouse", "Accessories", 29.99m, 50);
dt.Rows.Add(1003, "USB-C Cable", "Accessories", 19.99m, 100);
dt.Rows.Add(1004, "Monitor 27\"", "Electronics", 399.99m, 8);
dt.Rows.Add(1005, "Keyboard Mechanical", "Accessories", 89.99m, 25);

// Bind to DataGridView
var dataGridView1 = new DataGridView();
dataGridView1.DataSource = dt;

// Create new Excel workbook
var workbook = WorkBook.Create(ExcelFileFormat.XLSX);
var worksheet = workbook.DefaultWorkSheet;

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

// Export data rows
for (int rowIndex = 0; rowIndex < dataGridView1.Rows.Count; rowIndex++)
{
    if (!dataGridView1.Rows[rowIndex].IsNewRow)
    {
        for (int colIndex = 0; colIndex < dataGridView1.Columns.Count; colIndex++)
        {
            var cellValue = dataGridView1.Rows[rowIndex].Cells[colIndex].Value;
            if (cellValue is decimal or double or int)
                worksheet.SetCellValue(rowIndex + 1, colIndex, Convert.ToDouble(cellValue));
            else
                worksheet.SetCellValue(rowIndex + 1, colIndex, cellValue?.ToString() ?? string.Empty);
        }
    }
}

// Save the Excel file
workbook.SaveAs("DataGridViewExport.xlsx");
Console.WriteLine("Export completed successfully!");

Imports IronXL
Imports System.Data
Imports System.Windows.Forms

' Create a DataTable with sample product data
Dim dt As New DataTable()
dt.Columns.Add("Product ID", GetType(Integer))
dt.Columns.Add("Product Name", GetType(String))
dt.Columns.Add("Category", GetType(String))
dt.Columns.Add("Price", GetType(Decimal))
dt.Columns.Add("Stock", GetType(Integer))

dt.Rows.Add(1001, "Laptop Pro", "Electronics", 1299.99D, 15)
dt.Rows.Add(1002, "Wireless Mouse", "Accessories", 29.99D, 50)
dt.Rows.Add(1003, "USB-C Cable", "Accessories", 19.99D, 100)
dt.Rows.Add(1004, "Monitor 27""", "Electronics", 399.99D, 8)
dt.Rows.Add(1005, "Keyboard Mechanical", "Accessories", 89.99D, 25)

' Bind to DataGridView
Dim dataGridView1 As New DataGridView()
dataGridView1.DataSource = dt

' Create new Excel workbook
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.DefaultWorkSheet

' Export column headers
For colIndex As Integer = 0 To dataGridView1.Columns.Count - 1
    worksheet.SetCellValue(0, colIndex, dataGridView1.Columns(colIndex).HeaderText)
Next

' Export data rows
For rowIndex As Integer = 0 To dataGridView1.Rows.Count - 1
    If Not dataGridView1.Rows(rowIndex).IsNewRow Then
        For colIndex As Integer = 0 To dataGridView1.Columns.Count - 1
            Dim cellValue = dataGridView1.Rows(rowIndex).Cells(colIndex).Value
            If TypeOf cellValue Is Decimal OrElse TypeOf cellValue Is Double OrElse TypeOf cellValue Is Integer Then
                worksheet.SetCellValue(rowIndex + 1, colIndex, Convert.ToDouble(cellValue))
            Else
                worksheet.SetCellValue(rowIndex + 1, colIndex, If(cellValue?.ToString(), String.Empty))
            End If
        Next
    End If
Next

' Save the Excel file
workbook.SaveAs("DataGridViewExport.xlsx")
Console.WriteLine("Export completed successfully!")

Comment ajouter une mise en forme Professional aux exportations Excel ?

Les exportations Excel professionnelles nécessitent souvent un formatage pour améliorer la lisibilité. IronXL offre des fonctionnalités de style telles que la personnalisation des polices, des couleurs d'arrière-plan, des bordures et de l'alignement. L'exemple ci-dessous ajoute une mise en forme d'en-tête et une alternance de couleurs de lignes :

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

// Assume dataGridView1 is already populated with data
var dataGridView1 = new DataGridView();

// (populate dataGridView1 with data as shown in the previous example)

var workbook = WorkBook.Create(ExcelFileFormat.XLSX);
var worksheet = workbook.DefaultWorkSheet;

// Set column headers with formatting
for (int colIndex = 0; colIndex < dataGridView1.Columns.Count; colIndex++)
{
    var headerCell = worksheet.GetCellAt(0, colIndex);
    headerCell.Value = dataGridView1.Columns[colIndex].HeaderText;
    headerCell.Style.Font.Bold = true;
    headerCell.Style.BackgroundColor = "#4472C4";
    headerCell.Style.Font.Color = "#FFFFFF";
    headerCell.Style.HorizontalAlignment = IronXL.Styles.HorizontalAlignment.Center;
}

// Export data with alternating row colors
for (int rowIndex = 0; rowIndex < dataGridView1.Rows.Count; rowIndex++)
{
    if (!dataGridView1.Rows[rowIndex].IsNewRow)
    {
        for (int colIndex = 0; colIndex < dataGridView1.Columns.Count; colIndex++)
        {
            var cellValue = dataGridView1.Rows[rowIndex].Cells[colIndex].Value;
            var excelCell = worksheet.GetCellAt(rowIndex + 1, colIndex);

            if (cellValue != null)
                excelCell.Value = cellValue.ToString();

            // Apply alternating row background
            if (rowIndex % 2 == 0)
                excelCell.Style.BackgroundColor = "#F2F2F2";
        }
    }
}

// Auto-fit columns
for (int colIndex = 0; colIndex < dataGridView1.Columns.Count; colIndex++)
{
    worksheet.AutoSizeColumn(colIndex);
}

workbook.SaveAs("FormattedExport.xlsx");
Console.WriteLine("Formatted export completed successfully!");

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

// Assume dataGridView1 is already populated with data
var dataGridView1 = new DataGridView();

// (populate dataGridView1 with data as shown in the previous example)

var workbook = WorkBook.Create(ExcelFileFormat.XLSX);
var worksheet = workbook.DefaultWorkSheet;

// Set column headers with formatting
for (int colIndex = 0; colIndex < dataGridView1.Columns.Count; colIndex++)
{
    var headerCell = worksheet.GetCellAt(0, colIndex);
    headerCell.Value = dataGridView1.Columns[colIndex].HeaderText;
    headerCell.Style.Font.Bold = true;
    headerCell.Style.BackgroundColor = "#4472C4";
    headerCell.Style.Font.Color = "#FFFFFF";
    headerCell.Style.HorizontalAlignment = IronXL.Styles.HorizontalAlignment.Center;
}

// Export data with alternating row colors
for (int rowIndex = 0; rowIndex < dataGridView1.Rows.Count; rowIndex++)
{
    if (!dataGridView1.Rows[rowIndex].IsNewRow)
    {
        for (int colIndex = 0; colIndex < dataGridView1.Columns.Count; colIndex++)
        {
            var cellValue = dataGridView1.Rows[rowIndex].Cells[colIndex].Value;
            var excelCell = worksheet.GetCellAt(rowIndex + 1, colIndex);

            if (cellValue != null)
                excelCell.Value = cellValue.ToString();

            // Apply alternating row background
            if (rowIndex % 2 == 0)
                excelCell.Style.BackgroundColor = "#F2F2F2";
        }
    }
}

// Auto-fit columns
for (int colIndex = 0; colIndex < dataGridView1.Columns.Count; colIndex++)
{
    worksheet.AutoSizeColumn(colIndex);
}

workbook.SaveAs("FormattedExport.xlsx");
Console.WriteLine("Formatted export completed successfully!");

Imports IronXL
Imports System.Data
Imports System.Windows.Forms

' Assume dataGridView1 is already populated with data
Dim dataGridView1 As New DataGridView()

' (populate dataGridView1 with data as shown in the previous example)

Dim workbook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet = workbook.DefaultWorkSheet

' Set column headers with formatting
For colIndex As Integer = 0 To dataGridView1.Columns.Count - 1
    Dim headerCell = worksheet.GetCellAt(0, colIndex)
    headerCell.Value = dataGridView1.Columns(colIndex).HeaderText
    headerCell.Style.Font.Bold = True
    headerCell.Style.BackgroundColor = "#4472C4"
    headerCell.Style.Font.Color = "#FFFFFF"
    headerCell.Style.HorizontalAlignment = IronXL.Styles.HorizontalAlignment.Center
Next

' Export data with alternating row colors
For rowIndex As Integer = 0 To dataGridView1.Rows.Count - 1
    If Not dataGridView1.Rows(rowIndex).IsNewRow Then
        For colIndex As Integer = 0 To dataGridView1.Columns.Count - 1
            Dim cellValue = dataGridView1.Rows(rowIndex).Cells(colIndex).Value
            Dim excelCell = worksheet.GetCellAt(rowIndex + 1, colIndex)

            If cellValue IsNot Nothing Then
                excelCell.Value = cellValue.ToString()
            End If

            ' Apply alternating row background
            If rowIndex Mod 2 = 0 Then
                excelCell.Style.BackgroundColor = "#F2F2F2"
            End If
        Next
    End If
Next

' Auto-fit columns
For colIndex As Integer = 0 To dataGridView1.Columns.Count - 1
    worksheet.AutoSizeColumn(colIndex)
Next

workbook.SaveAs("FormattedExport.xlsx")
Console.WriteLine("Formatted export completed successfully!")

Cette version améliorée applique une mise en forme Professional au fichier Excel exporté. Les en-têtes sont mis en gras sur fond bleu avec une police blanche, ce qui permet de les distinguer clairement des lignes de données. Le code implémente l'alternance des couleurs de lignes à l'aide d'une opération modulo, améliorant ainsi la lisibilité des grands ensembles de données. Vous pouvez personnaliser davantage l'apparence à l'aide du guide de mise en forme des cellules IronXL ou appliquer la fonctionnalité de fusion de cellules pour étendre les colonnes d'en-tête.

La méthode AutoSizeColumn ajuste la largeur des colonnes en fonction du contenu, ce qui élimine les ajustements manuels après l'exportation. Ces options de formatage transforment une exportation de données basique en un document prêt à être présenté que les utilisateurs peuvent partager immédiatement. Consultez la section " Comment écrire des fichiers Excel avec IronXL " pour découvrir d'autres modèles de mise en forme et d'écriture de données.

Comment exporter vers plusieurs formats et ajouter des formules ?

IronXL va au-delà de l'exportation Excel de base, offrant des fonctionnalités telles que la prise en charge des formules, plusieurs feuilles de calcul et des formats de sortie alternatifs. L'exemple suivant illustre ces capacités :

using IronXL;

var workbook = WorkBook.Create(ExcelFileFormat.XLSX);
var worksheet = workbook.DefaultWorkSheet;

// (populate worksheet with DataGridView data as shown above)
int dataRowCount = 5; // Replace with actual dataGridView1.Rows.Count

// Add a SUM formula to calculate the total price column
worksheet.SetCellValue(dataRowCount + 2, 3, $"=SUM(D2:D{dataRowCount + 1})");

// Create a summary worksheet
var summarySheet = workbook.CreateWorkSheet("Summary");
summarySheet.SetCellValue(0, 0, "Total Products");
summarySheet.SetCellValue(0, 1, dataRowCount);

// Save in multiple formats
workbook.SaveAs("export.xlsx");
workbook.SaveAsCsv("export.csv");
workbook.SaveAsJson("export.json");
workbook.SaveAsXml("export.xml");

Console.WriteLine("Multi-format export completed!");

using IronXL;

var workbook = WorkBook.Create(ExcelFileFormat.XLSX);
var worksheet = workbook.DefaultWorkSheet;

// (populate worksheet with DataGridView data as shown above)
int dataRowCount = 5; // Replace with actual dataGridView1.Rows.Count

// Add a SUM formula to calculate the total price column
worksheet.SetCellValue(dataRowCount + 2, 3, $"=SUM(D2:D{dataRowCount + 1})");

// Create a summary worksheet
var summarySheet = workbook.CreateWorkSheet("Summary");
summarySheet.SetCellValue(0, 0, "Total Products");
summarySheet.SetCellValue(0, 1, dataRowCount);

// Save in multiple formats
workbook.SaveAs("export.xlsx");
workbook.SaveAsCsv("export.csv");
workbook.SaveAsJson("export.json");
workbook.SaveAsXml("export.xml");

Console.WriteLine("Multi-format export completed!");

Imports IronXL

Dim workbook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet = workbook.DefaultWorkSheet

' (populate worksheet with DataGridView data as shown above)
Dim dataRowCount As Integer = 5 ' Replace with actual dataGridView1.Rows.Count

' Add a SUM formula to calculate the total price column
worksheet.SetCellValue(dataRowCount + 2, 3, $"=SUM(D2:D{dataRowCount + 1})")

' Create a summary worksheet
Dim summarySheet = workbook.CreateWorkSheet("Summary")
summarySheet.SetCellValue(0, 0, "Total Products")
summarySheet.SetCellValue(0, 1, dataRowCount)

' Save in multiple formats
workbook.SaveAs("export.xlsx")
workbook.SaveAsCsv("export.csv")
workbook.SaveAsJson("export.json")
workbook.SaveAsXml("export.xml")

Console.WriteLine("Multi-format export completed!")

IronXL prend en charge les formules Excel, ce qui vous permet d'ajouter des calculs directement aux fichiers exportés. L'exemple ci-dessus ajoute une formule SUM pour calculer automatiquement les totaux des colonnes. Créer plusieurs feuilles de calcul aide à organiser des exportations complexes, comme séparer les données détaillées des informations sommaires. Consultez le guide pratique d'IronXL sur la création de fichiers Excel pour découvrir d'autres modèles de gestion des feuilles de calcul.

La flexibilité du format est particulièrement précieuse pour les scénarios d'intégration. Si le format XLSX est la norme pour les fichiers Excel, l'exportation au format CSV offre une compatibilité universelle avec les systèmes de bases de données et les applications plus anciennes. Les formats JSON et XML facilitent l'échange de données avec les services web et les API. Vous pouvez également ouvrir des classeurs existants pour ajouter les données exportées à des feuilles de calcul existantes plutôt que de créer de nouveaux fichiers à chaque fois.

Comment IronXL simplifie-t-il votre flux de travail de développement C# ?

Le principal avantage d'IronXL est l'élimination des dépendances à Microsoft Office. Votre application fonctionne de manière cohérente, qu'elle soit déployée sur un poste de travail de développeur, une machine client ou un conteneur Docker. Cette indépendance simplifie le déploiement et réduit les problèmes de support liés aux versions et installations d'Office. Le kit de développement logiciel Open XML de Microsoft est une autre alternative sans Office, bien qu'il nécessite beaucoup plus de code répétitif que l'API de plus haut niveau d'IronXL. Pour obtenir des conseils sur le développement multiplateforme .NET 10, la documentation Microsoft .NET couvre les plateformes cibles, les modèles de déploiement et les spécificités de Windows Forms.

Le design de l'API de la bibliothèque privilégie la simplicité. Contrairement à l'approche d'Interop basée sur COM qui nécessite une suppression soignée des objets, IronXL utilise des modèles .NET standard qui semblent naturels aux développeurs C#. La prise en charge multiplateforme signifie que les fonctionnalités d'exportation conçues pour Windows Forms peuvent être réutilisées dans les applications ASP.NET Core exécutées sur des serveurs Linux. Pour un aperçu complet des fonctionnalités disponibles, consultez la page des fonctionnalités IronXL .

Vous pouvez également importer des données d'Excel pour pré-remplir votre DataGridView avant l'exportation, créant ainsi des flux de travail aller-retour dans lesquels les utilisateurs chargent des données Excel, les modifient dans la grille et exportent le résultat vers Excel. Le guide sur la lecture des fichiers Excel couvre en détail l'aspect importation.

Lors du traitement de données sensibles, IronXL prend en charge la protection par mot de passe au niveau du classeur et au niveau de la feuille de calcul. La documentation IronXL décrit les options de sécurité pour les scénarios où les fichiers exportés doivent être protégés avant leur distribution.

Vue d'ensemble des caractéristiques d'une bibliothèque Excel montrant six catégories principales : Créer, Enregistrer et Exporter, Modifier les classeurs, Travailler avec les données, Sécuriser vos classeurs et Modifier les options de mise en page

IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";

IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";

Imports IronXL

IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"

Pourquoi choisir IronXL pour l'exportation Excel en C# ?

L'exportation de données DataGridView vers Excel devient simple avec IronXL. La bibliothèque élimine les complexités traditionnelles d'Interop tout en offrant des capacités de formatage professionnel et plusieurs formats d'exportation. Son architecture adaptée aux conteneurs, ses dépendances minimales et sa compatibilité multiplateforme en font la solution idéale pour les flux de travail DevOps modernes.

La page d'accueil IronXL est le point de départ pour explorer l'intégralité de la bibliothèque. Qu'il s'agisse de créer des microservices, de déployer sur des clusters Kubernetes ou d'exécuter des fonctions sans serveur, IronXL s'intègre parfaitement aux pipelines CI/CD. Le guide pratique sur l'exportation vers Excel fournit des modèles supplémentaires pour différents scénarios d'exportation, et le guide sur l'ouverture de classeurs couvre la lecture et la modification de fichiers existants.

Commencez par une licence d'essai gratuite pour découvrir toutes les fonctionnalités. Les tutoriels et exemples de code IronXL vous aident à mettre en œuvre rapidement des solutions prêtes pour la production. Choisissez parmi des options de licence flexibles adaptées à vos besoins de déploiement, allant des licences individuelles pour développeurs aux déploiements Enterprise illimités. Pour toute question concernant la prise en main, le centre de documentation IronXL fournit des références API, des exemples de code et des conseils de dépannage.