Exportation de DataGridView C# vers Excel : Guide complet avec mise en forme | IronXL

L'exportation des données DataGridView vers un fichier Excel est l'une des tâches les plus courantes dans le développement de Windows Forms. Lors de la création d'applications métier affichant des données tabulaires (rapports de vente, registres d'inventaire ou listes de clients), les utilisateurs s'attendent à pouvoir cliquer sur un bouton et recevoir un fichier Excel correctement formaté qu'ils peuvent partager ou analyser plus en détail. Le défi consiste à le faire proprement, sans dépendre d'une installation de Microsoft Excel sur chaque poste utilisateur, et sans se débattre avec un code de nettoyage d'interopérabilité COM qui provoque des fuites de mémoire ou des pannes silencieuses. Ce guide vous accompagne tout au long du processus d'exportation de DataGridView vers Excel en C# à l'aide IronXL , couvrant tout, de la configuration du projet à la mise en forme avancée des cellules, afin que vous obteniez un code prêt pour la production.
Comment configurer un projet Windows Forms pour l'exportation de DataGridView ?
Les approches traditionnelles d'exportation de données DataGridView reposaient sur Microsoft Interop -- vous ouvriez Ajouter une référence, naviguiez jusqu'à l'onglet COM, sélectionniez la bibliothèque d'objets Microsoft Excel et écriviez un code fragile qui appelait Marshal.ReleaseComObject pour éviter les fuites de mémoire. Ce modèle nécessite l'installation de Microsoft Excel sur chaque machine où l'application s'exécute, fonctionne lentement avec de grands ensembles de données et produit souvent des erreurs COMException dans les environnements de déploiement qui ne disposent pas de licences Office. Les propres recommandations de Microsoft concernant l'automatisation d'Office préconisent explicitement l'utilisation de bibliothèques tierces pour les scénarios côté serveur et automatisés.
IronXL supprime toutes ces dépendances. Il s'agit d'une bibliothèque .NET pure qui lit et écrit des fichiers .xlsx, .xls, .csv et .ods sans Microsoft Office ni aucun enregistrement COM. Vous l'installez via NuGet et vous pouvez commencer à écrire du code immédiatement.
Installation IronXL via NuGet
Commencez par créer un nouveau projet d'application Windows Forms dans Visual Studio ciblant .NET 10. Ajoutez un contrôle DataGridView et un Button à la surface du formulaire. Nommez le bouton btnExport et donnez-lui l'étiquette " Exporter vers Excel ". Ouvrez ensuite la console du gestionnaire de packages NuGet et exécutez :
Install-Package IronXL.Excel
Install-Package IronXL.Excel
Ajoutez les espaces de noms requis en haut de votre fichier de formulaire :
using IronXL;
using System.Data;
using IronXL;
using System.Data;
Imports IronXL
Imports System.Data
Ces deux espaces de noms couvrent tous les types IronXL dont vous avez besoin pour lire et écrire des classeurs Excel , ainsi que les types standard System.Data pour travailler avec les objets DataTable qui relient vos DataGridView au pipeline d'exportation.
Comment charger des exemples de données dans un contrôle DataGridView ?
Avant de construire la logique d'exportation, remplissez votre DataGridView avec des données représentatives. L'événement Form1_Load est l'endroit idéal pour lier un DataTable comme source de données. Dans une application réelle, vous interrogeriez une base de données ou appelleriez un service ; ici, un code dur DataTable illustre clairement la structure. La présentation du contrôle DataGridView sur Microsoft Docs fournit des informations supplémentaires sur la manière dont ce contrôle gère les sources de données.
Lier un DataTable à un DataGridView
void Form1_Load(object sender, EventArgs e)
{
DataTable dt = new DataTable();
dt.Columns.Add("ProductID", typeof(int));
dt.Columns.Add("ProductName", typeof(string));
dt.Columns.Add("Price", typeof(decimal));
dt.Columns.Add("Stock", typeof(int));
dt.Rows.Add(1, "Laptop", 999.99m, 50);
dt.Rows.Add(2, "Mouse", 29.99m, 200);
dt.Rows.Add(3, "Keyboard", 79.99m, 150);
dt.Rows.Add(4, "Monitor", 349.99m, 75);
dt.Rows.Add(5, "Webcam", 89.99m, 120);
dataGridView1.DataSource = dt;
}
void Form1_Load(object sender, EventArgs e)
{
DataTable dt = new DataTable();
dt.Columns.Add("ProductID", typeof(int));
dt.Columns.Add("ProductName", typeof(string));
dt.Columns.Add("Price", typeof(decimal));
dt.Columns.Add("Stock", typeof(int));
dt.Rows.Add(1, "Laptop", 999.99m, 50);
dt.Rows.Add(2, "Mouse", 29.99m, 200);
dt.Rows.Add(3, "Keyboard", 79.99m, 150);
dt.Rows.Add(4, "Monitor", 349.99m, 75);
dt.Rows.Add(5, "Webcam", 89.99m, 120);
dataGridView1.DataSource = dt;
}
Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
Dim dt As New DataTable()
dt.Columns.Add("ProductID", GetType(Integer))
dt.Columns.Add("ProductName", GetType(String))
dt.Columns.Add("Price", GetType(Decimal))
dt.Columns.Add("Stock", GetType(Integer))
dt.Rows.Add(1, "Laptop", 999.99D, 50)
dt.Rows.Add(2, "Mouse", 29.99D, 200)
dt.Rows.Add(3, "Keyboard", 79.99D, 150)
dt.Rows.Add(4, "Monitor", 349.99D, 75)
dt.Rows.Add(5, "Webcam", 89.99D, 120)
dataGridView1.DataSource = dt
End Sub
Ce code utilise le style d'instruction de niveau supérieur pour la signature du gestionnaire d'événements. Le DataTable comporte quatre colonnes typées -- entier, chaîne, décimal et entier -- IronXL préservera lors de l'écriture dans le classeur Excel. Le formatage des colonnes est important car IronXL écrit les colonnes numériques sous forme de cellules numériques plutôt que de texte, ce qui permet aux utilisateurs de trier et d'additionner les valeurs dans Excel sans reformatage.

Le DataGridView génère automatiquement une ligne d'en-tête de colonne à partir des noms de colonnes DataTable. Lors de l'exportation, vous souhaitez que la ligne d'en-tête soit conservée dans le fichier Excel, ce qui signifie que votre code d'exportation doit gérer les en-têtes séparément des lignes de données ; la section suivante traite précisément de ce sujet.
Pour une utilisation en production, le même modèle s'applique que le DataTable provienne d'Entity Framework, de Dapper, d'ADO .NET ou de toute autre couche d'accès aux données. La liaison DataGridView est découplée du code d'exportation, vous pouvez donc changer la source de données sans toucher à la logique d'exportation.
Comment exporter les données d'un DataGridView vers un fichier Excel ?
La logique d'exportation principale s'exécute dans le gestionnaire de clic sur le bouton. IronXL fournit une méthode LoadFromDataTable sur WorkSheet qui gère automatiquement le mappage colonne-cellule. L'approche la plus propre extrait un DataTable du DataGridView et le transmet directement. Le SDK Open XML, qui sous-tend le format .xlsx, est documenté par Microsoft et confirme pourquoi les solutions .NET pures comme IronXL surpassent Interop pour la génération programmatique.
Gestionnaire d'exportation par clic sur le bouton
void btnExport_Click(object sender, EventArgs e)
{
try
{
DataTable dt = new DataTable();
foreach (DataGridViewColumn column in dataGridView1.Columns)
dt.Columns.Add(column.HeaderText);
foreach (DataGridViewRow row in dataGridView1.Rows)
{
if (row.IsNewRow) continue;
DataRow dataRow = dt.NewRow();
for (int i = 0; i < dataGridView1.Columns.Count; i++)
dataRow[i] = row.Cells[i].Value ?? DBNull.Value;
dt.Rows.Add(dataRow);
}
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.DefaultWorkSheet;
worksheet.Name = "Product Data";
worksheet.LoadFromDataTable(dt, true);
string outputPath = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.Desktop),
"DataGridViewExport.xlsx"
);
workbook.SaveAs(outputPath);
MessageBox.Show($"Exported successfully to:\n{outputPath}", "Export Complete",
MessageBoxButtons.OK, MessageBoxIcon.Information);
}
catch (Exception ex)
{
MessageBox.Show($"Export failed: {ex.Message}", "Error",
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
void btnExport_Click(object sender, EventArgs e)
{
try
{
DataTable dt = new DataTable();
foreach (DataGridViewColumn column in dataGridView1.Columns)
dt.Columns.Add(column.HeaderText);
foreach (DataGridViewRow row in dataGridView1.Rows)
{
if (row.IsNewRow) continue;
DataRow dataRow = dt.NewRow();
for (int i = 0; i < dataGridView1.Columns.Count; i++)
dataRow[i] = row.Cells[i].Value ?? DBNull.Value;
dt.Rows.Add(dataRow);
}
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.DefaultWorkSheet;
worksheet.Name = "Product Data";
worksheet.LoadFromDataTable(dt, true);
string outputPath = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.Desktop),
"DataGridViewExport.xlsx"
);
workbook.SaveAs(outputPath);
MessageBox.Show($"Exported successfully to:\n{outputPath}", "Export Complete",
MessageBoxButtons.OK, MessageBoxIcon.Information);
}
catch (Exception ex)
{
MessageBox.Show($"Export failed: {ex.Message}", "Error",
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
Imports System
Imports System.Data
Imports System.IO
Imports System.Windows.Forms
Public Sub btnExport_Click(sender As Object, e As EventArgs)
Try
Dim dt As New DataTable()
For Each column As DataGridViewColumn In dataGridView1.Columns
dt.Columns.Add(column.HeaderText)
Next
For Each row As DataGridViewRow In dataGridView1.Rows
If row.IsNewRow Then Continue For
Dim dataRow As DataRow = dt.NewRow()
For i As Integer = 0 To dataGridView1.Columns.Count - 1
dataRow(i) = If(row.Cells(i).Value, DBNull.Value)
Next
dt.Rows.Add(dataRow)
Next
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.DefaultWorkSheet
worksheet.Name = "Product Data"
worksheet.LoadFromDataTable(dt, True)
Dim outputPath As String = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.Desktop),
"DataGridViewExport.xlsx"
)
workbook.SaveAs(outputPath)
MessageBox.Show($"Exported successfully to:{Environment.NewLine}{outputPath}", "Export Complete",
MessageBoxButtons.OK, MessageBoxIcon.Information)
Catch ex As Exception
MessageBox.Show($"Export failed: {ex.Message}", "Error",
MessageBoxButtons.OK, MessageBoxIcon.Error)
End Try
End Sub

L'appel LoadFromDataTable(dt, true) prend le DataTable et un indicateur booléen qui indique à IronXL d'écrire les noms de colonnes comme première ligne Excel -- ceux-ci deviennent vos cellules d'en-tête. Le classeur est enregistré sur le Bureau de l'utilisateur en utilisant Environment.SpecialFolder.Desktop plutôt qu'un chemin codé en dur, ce qui rend le code portable entre les comptes d'utilisateurs.
Le null vérification (?? DBNull.Value) prevents a NullReferenceException lorsqu'une cellule ne contient aucune valeur. Ceci est important pour les données réelles où les champs optionnels peuvent être vides. IronXL écrit DBNull comme une cellule vide plutôt que la chaîne "DBNull", de sorte que la sortie reste propre.
Pour plus de détails sur la lecture des données à partir de fichiers Excel dans un DataGridView, consultez la documentation IronXL DataTable , qui couvre l'opération inverse et comment convertir Excel en DataSet pour les classeurs à plusieurs feuilles.
Comment appliquer une mise en forme Professional au fichier Excel exporté ?
Les données brutes d'un fichier Excel sont fonctionnelles, mais une sortie formatée professionnellement (en-têtes en gras, largeurs de colonnes adaptées au contenu, couleurs de fond de lignes alternées) fait toute la différence entre un outil auquel les utilisateurs font confiance et un outil qu'ils exportent et reformatent immédiatement à la main. IronXL propose une API de style de cellule riche qui couvre les polices, les couleurs, les bordures, les formats numériques et l'alignement. La spécification OOXML pour les styles de feuilles de calcul définit le format sous-jacent IronXL écrit, vous assurant ainsi que la sortie s'ouvre correctement dans toute application compatible.
Application des styles d'en-tête et alternance des couleurs de lignes
void ExportWithFormatting(object sender, EventArgs e)
{
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.DefaultWorkSheet;
worksheet.Name = "Formatted Export";
string[] headers = { "ID", "Product Name", "Price", "Stock" };
// Write and style header row
for (int col = 0; col < headers.Length; col++)
{
char colLetter = (char)('A' + col);
string cellAddress = $"{colLetter}1";
worksheet.SetCellValue(0, col, headers[col]);
worksheet[cellAddress].Style.Font.Bold = true;
worksheet[cellAddress].Style.Font.Height = 12;
worksheet[cellAddress].Style.SetBackgroundColor("#4472C4");
worksheet[cellAddress].Style.Font.Color = "#FFFFFF";
worksheet[cellAddress].Style.HorizontalAlignment =
IronXL.Styles.HorizontalAlignment.Center;
}
// Write data rows with alternating background colors
int rowIndex = 1;
foreach (DataGridViewRow row in dataGridView1.Rows)
{
if (row.IsNewRow) continue;
for (int col = 0; col < dataGridView1.Columns.Count; col++)
{
worksheet.SetCellValue(rowIndex, col,
row.Cells[col].Value?.ToString() ?? string.Empty);
}
if (rowIndex % 2 == 0)
{
string rangeAddress = $"A{rowIndex + 1}:D{rowIndex + 1}";
worksheet[rangeAddress].Style.SetBackgroundColor("#D6DCE5");
}
rowIndex++;
}
// Format the Price column as currency
worksheet["C2:C100"].Style.Format = "$#,##0.00";
// Auto-fit column widths
worksheet.AutoSizeColumn(0);
worksheet.AutoSizeColumn(1);
worksheet.AutoSizeColumn(2);
worksheet.AutoSizeColumn(3);
string outputPath = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.Desktop),
"FormattedExport.xlsx"
);
workbook.SaveAs(outputPath);
MessageBox.Show("Formatted export complete.", "Done",
MessageBoxButtons.OK, MessageBoxIcon.Information);
}
void ExportWithFormatting(object sender, EventArgs e)
{
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.DefaultWorkSheet;
worksheet.Name = "Formatted Export";
string[] headers = { "ID", "Product Name", "Price", "Stock" };
// Write and style header row
for (int col = 0; col < headers.Length; col++)
{
char colLetter = (char)('A' + col);
string cellAddress = $"{colLetter}1";
worksheet.SetCellValue(0, col, headers[col]);
worksheet[cellAddress].Style.Font.Bold = true;
worksheet[cellAddress].Style.Font.Height = 12;
worksheet[cellAddress].Style.SetBackgroundColor("#4472C4");
worksheet[cellAddress].Style.Font.Color = "#FFFFFF";
worksheet[cellAddress].Style.HorizontalAlignment =
IronXL.Styles.HorizontalAlignment.Center;
}
// Write data rows with alternating background colors
int rowIndex = 1;
foreach (DataGridViewRow row in dataGridView1.Rows)
{
if (row.IsNewRow) continue;
for (int col = 0; col < dataGridView1.Columns.Count; col++)
{
worksheet.SetCellValue(rowIndex, col,
row.Cells[col].Value?.ToString() ?? string.Empty);
}
if (rowIndex % 2 == 0)
{
string rangeAddress = $"A{rowIndex + 1}:D{rowIndex + 1}";
worksheet[rangeAddress].Style.SetBackgroundColor("#D6DCE5");
}
rowIndex++;
}
// Format the Price column as currency
worksheet["C2:C100"].Style.Format = "$#,##0.00";
// Auto-fit column widths
worksheet.AutoSizeColumn(0);
worksheet.AutoSizeColumn(1);
worksheet.AutoSizeColumn(2);
worksheet.AutoSizeColumn(3);
string outputPath = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.Desktop),
"FormattedExport.xlsx"
);
workbook.SaveAs(outputPath);
MessageBox.Show("Formatted export complete.", "Done",
MessageBoxButtons.OK, MessageBoxIcon.Information);
}
Option Strict On
Sub ExportWithFormatting(sender As Object, e As EventArgs)
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.DefaultWorkSheet
worksheet.Name = "Formatted Export"
Dim headers As String() = {"ID", "Product Name", "Price", "Stock"}
' Write and style header row
For col As Integer = 0 To headers.Length - 1
Dim colLetter As Char = ChrW(AscW("A"c) + col)
Dim cellAddress As String = $"{colLetter}1"
worksheet.SetCellValue(0, col, headers(col))
worksheet(cellAddress).Style.Font.Bold = True
worksheet(cellAddress).Style.Font.Height = 12
worksheet(cellAddress).Style.SetBackgroundColor("#4472C4")
worksheet(cellAddress).Style.Font.Color = "#FFFFFF"
worksheet(cellAddress).Style.HorizontalAlignment = IronXL.Styles.HorizontalAlignment.Center
Next
' Write data rows with alternating background colors
Dim rowIndex As Integer = 1
For Each row As DataGridViewRow In dataGridView1.Rows
If row.IsNewRow Then Continue For
For col As Integer = 0 To dataGridView1.Columns.Count - 1
worksheet.SetCellValue(rowIndex, col, If(row.Cells(col).Value?.ToString(), String.Empty))
Next
If rowIndex Mod 2 = 0 Then
Dim rangeAddress As String = $"A{rowIndex + 1}:D{rowIndex + 1}"
worksheet(rangeAddress).Style.SetBackgroundColor("#D6DCE5")
End If
rowIndex += 1
Next
' Format the Price column as currency
worksheet("C2:C100").Style.Format = "$#,##0.00"
' Auto-fit column widths
worksheet.AutoSizeColumn(0)
worksheet.AutoSizeColumn(1)
worksheet.AutoSizeColumn(2)
worksheet.AutoSizeColumn(3)
Dim outputPath As String = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Desktop), "FormattedExport.xlsx")
workbook.SaveAs(outputPath)
MessageBox.Show("Formatted export complete.", "Done", MessageBoxButtons.OK, MessageBoxIcon.Information)
End Sub

Le code de formatage utilise plusieurs techniques. La ligne d'en-tête a un fond bleu (#4472C4) avec du texte blanc, une police en gras de 12 points et un alignement centré - un style de feuille de calcul d'entreprise standard. Les lignes de données alternent entre le blanc et le gris clair (#D6DCE5) toutes les lignes paires, ce qui facilite la lecture des tableaux larges sans perdre le fil. La colonne Prix utilise le format monétaire intégré d'Excel ($#,##0.00), de sorte que les valeurs s'affichent avec des signes dollar et deux décimales dans la feuille de calcul sans modifier les données numériques sous-jacentes. AutoSizeColumn ajuste chaque colonne à sa valeur la plus longue afin qu'aucun contenu ne soit tronqué.
Vous pouvez étendre ce modèle davantage avec la mise en forme des bordures de cellules , la mise en forme conditionnelle et les règles de validation des données . Pour les rapports qui doivent respecter un modèle d'entreprise, vous pouvez également définir la mise en page et la zone d'impression afin que le fichier exporté soit prêt à imprimer sans ajustement.
Comment gérez-vous les grands ensembles de données et l'optimisation des performances ?
Lorsqu'un DataGridView est lié à des milliers de lignes, l'itération cellule par cellule devient sensiblement lente. Deux optimisations améliorent considérablement les performances. Tout d'abord, utilisez LoadFromDataTable au lieu des appels par cellule SetCellValue. Deuxièmement, si votre source de données est un DataTable, transmettez-la directement à IronXL plutôt que d'extraire les valeurs à travers les lignes DataGridView :
void ExportLargeDataset(DataTable sourceTable)
{
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.DefaultWorkSheet;
// Direct DataTable load -- fastest path for large data
worksheet.LoadFromDataTable(sourceTable, true);
// Apply header styling after load
int colCount = sourceTable.Columns.Count;
for (int col = 0; col < colCount; col++)
{
char colLetter = (char)('A' + col);
worksheet[$"{colLetter}1"].Style.Font.Bold = true;
worksheet[$"{colLetter}1"].Style.SetBackgroundColor("#4472C4");
worksheet[$"{colLetter}1"].Style.Font.Color = "#FFFFFF";
}
workbook.SaveAs(Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.Desktop),
"LargeExport.xlsx"
));
}
void ExportLargeDataset(DataTable sourceTable)
{
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.DefaultWorkSheet;
// Direct DataTable load -- fastest path for large data
worksheet.LoadFromDataTable(sourceTable, true);
// Apply header styling after load
int colCount = sourceTable.Columns.Count;
for (int col = 0; col < colCount; col++)
{
char colLetter = (char)('A' + col);
worksheet[$"{colLetter}1"].Style.Font.Bold = true;
worksheet[$"{colLetter}1"].Style.SetBackgroundColor("#4472C4");
worksheet[$"{colLetter}1"].Style.Font.Color = "#FFFFFF";
}
workbook.SaveAs(Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.Desktop),
"LargeExport.xlsx"
));
}
Option Strict On
Sub ExportLargeDataset(sourceTable As DataTable)
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.DefaultWorkSheet
' Direct DataTable load -- fastest path for large data
worksheet.LoadFromDataTable(sourceTable, True)
' Apply header styling after load
Dim colCount As Integer = sourceTable.Columns.Count
For col As Integer = 0 To colCount - 1
Dim colLetter As Char = ChrW(AscW("A"c) + col)
worksheet($"{colLetter}1").Style.Font.Bold = True
worksheet($"{colLetter}1").Style.SetBackgroundColor("#4472C4")
worksheet($"{colLetter}1").Style.Font.Color = "#FFFFFF"
Next
workbook.SaveAs(Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.Desktop),
"LargeExport.xlsx"
))
End Sub
Pour les ensembles de données contenant plus de 10 000 lignes, l'exécution de l'exportation sur un thread d'arrière-plan préserve la réactivité de l'interface utilisateur. Encapsulez la logique d'exportation dans Task.Run et renvoyez le rappel MessageBox.Show vers le thread d'interface utilisateur à l'aide de Invoke. IronXL est sûr pour les opérations d'écriture sur des instances séparées WorkBook, vous pouvez donc exécuter plusieurs exportations simultanément si nécessaire.
Ressources supplémentaires pour la performance :
Comment comparer IronXL à Microsoft Interop pour l'exportation de DataGridView ?
De nombreux développeurs commencent par Microsoft Excel Interop car il est fourni avec Office et ne nécessite aucun package supplémentaire. Cependant, l'interopérabilité engendre des coûts concrets qui se manifestent rapidement dans les environnements de production. Le tableau suivant résume les principales différences :
| Capacité | IronXL | Microsoft Interop |
|---|---|---|
| Nécessite l'installation de Microsoft Excel | Non | Oui |
| Fonctionne dans des environnements serveur/cloud | Oui | Non (non pris en charge par Microsoft) |
| Nettoyage des objets COM requis | Non | Oui (Marshal.ReleaseComObject) |
| Performances avec de grands ensembles de données | Rapide (pur .NET) | Lent (surcharge de traitement COM) |
| Méthode d'installation | NuGet | Référence COM / Installation d'Office |
| Versions .NET prises en charge | .NET 4.6.2 -- .NET 10 | .NET Framework uniquement (limité) |
| Prise en charge des formats XLSX, CSV et ODS | Oui | XLSX/XLS uniquement via Excel |
La documentation de Microsoft met en garde contre l'utilisation d'Office Interop sur les serveurs ou dans les comptes de service, en raison de problèmes de stabilité et de licences. IronXL fonctionne correctement dans Azure App Service, sur les hôtes de services Windows, dans les conteneurs Docker et dans tout autre environnement sans interface graphique où l'exécution d'une application de bureau comme Excel n'est pas possible.
Pour les équipes utilisant déjà Interop et souhaitant migrer, l'API d'IronXL correspond suffisamment pour que la plupart des opérations WorkBook et WorkSheet se traduisent directement. Le guide de migration IronXL couvre les modèles d'interopérabilité courants et leurs équivalents IronXL .
Quelles sont vos prochaines étapes ?
L'exportation des données DataGridView vers Excel à l'aide IronXL ne nécessite qu'une installation de package NuGet et quelques lignes de code, remplaçant l'approche fragile d'interopérabilité COM par une solution propre et maintenable qui fonctionne dans n'importe quel environnement de déploiement. Les techniques présentées ici (exportation de base, sortie formatée, optimisation pour les grands ensembles de données et tableau comparatif) vous fournissent tout le nécessaire pour intégrer cette fonctionnalité dans une application Windows Forms en production.
À partir d'ici, explorez ces fonctionnalités connexes :
- Créer des fichiers Excel à partir de zéro en C# : générer des classeurs par programmation sans source de données.
- Lire des fichiers Excel dans un DataTable : l'opération inverse pour importer des données Excel dans votre application
- Appliquer une mise en forme conditionnelle : surligner automatiquement les cellules en fonction de leurs valeurs
- Définir les données du graphique dans Excel -- intégrer les graphiques dans les classeurs exportés
- Protéger par mot de passe les fichiers Excel — sécuriser les rapports exportés avant leur diffusion
- Exporter au format CSV -- lorsque les destinataires ont besoin d'un format de fichier plat au lieu de
.xlsx
Démarrez un essai gratuit IronXL pour tester l'ensemble des fonctionnalités dans votre projet, ou consultez les options de licence IronXL lorsque vous serez prêt pour un déploiement en production.
Questions Fréquemment Posées
Comment puis-je exporter les données de DataGridView vers Excel en C# ?
Installez IronXL via NuGet, extrayez un DataTable de votre DataGridView, créez un WorkBook et un WorkSheet, appelez worksheet.LoadFromDataTable(dt, true), puis enregistrez avec workbook.SaveAs.
Quelles sont les options de formatage disponibles lors de l'exportation de DataGridView vers Excel ?
IronXL prend en charge les polices en gras, les couleurs d'arrière-plan, les couleurs de police, l'alignement horizontal, les formats numériques (tels que les devises), le dimensionnement automatique des colonnes, les styles de bordure et la mise en forme conditionnelle.
Ai-je besoin de Microsoft Excel pour exporter les données de DataGridView ?
Non. IronXL est une bibliothèque .NET pure qui génère des fichiers Excel sans nécessiter Microsoft Office ni aucun enregistrement COM sur la machine.
Puis-je styliser les en-têtes lors de l'exportation de DataGridView vers Excel ?
Oui. Après avoir écrit la ligne d'en-tête, accédez à chaque cellule d'en-tête par son adresse et définissez les propriétés Style.Font.Bold, Style.SetBackgroundColor et Style.Font.Color.
Comment appliquer des couleurs de ligne alternées dans Excel lors de l'exportation à partir de DataGridView ?
Suivez l'index de la ligne lorsque vous parcourez les lignes du DataGridView, et pour les lignes paires, appliquez un style de plage à l'aide de worksheet[rangeAddress].Style.SetBackgroundColor avec la couleur hexadécimale de votre choix.
Comment gérer les grands ensembles de données lors de l'exportation d'un DataGridView vers Excel ?
Transmettez directement le DataTable sous-jacent à worksheet.LoadFromDataTable au lieu de parcourir les cellules une par une. Pour les très grands ensembles de données, exécutez l'exportation sur un thread d'arrière-plan à l'aide de Task.Run.
Comment IronXL se compare-t-il à Microsoft Excel Interop pour l'exportation de DataGridView ?
IronXL ne nécessite pas Microsoft Excel, fonctionne dans les environnements serveur et cloud, ne requiert aucun code de nettoyage COM et offre des performances nettement supérieures avec les grands ensembles de données.



