Icône de message
Passer au contenu du pied de page
  1. Iron Software
  2. Blog IronXL
  3. Utilisation d'IronXL
  4. DataGridView vers Excel
UTILISATION D'IRONXL

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

Jordi Bardia
Jordi Bardia
Mis à jour:

Exportation de DataGridView C# vers Excel avec mise en forme : Guide complet : Image 1 - Exportation de DataGridView C# vers Excel avec mise en forme

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.

Commencez avec IronXL maintenant.
green arrow pointer

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. Nonmmez 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
SHELL

Ajoutez les espaces de noms requis en haut de votre fichier de formulaire :

using IronXL;
using System.Data;
using IronXL;
using System.Data;
$vbLabelText   $csharpLabel

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 des 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;
}
$vbLabelText   $csharpLabel

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.

C# DataGridView Exportation vers Excel avec mise en forme : Le guide complet : Image 2 - Interface utilisateur du formulaire

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);
    }
}
$vbLabelText   $csharpLabel

C# DataGridView Exportation vers Excel avec mise en forme : Le guide complet : Image 3 - Fichier Excel généré

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 professionnelle 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);
}
$vbLabelText   $csharpLabel

C# DataGridView Exportation vers Excel avec mise en forme : Guide complet : Image 4 - Sortie du fichier Excel formaté généré

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) à chaque ligne paire, ce qui permet aux utilisateurs de lire plus facilement dans les tableaux larges sans perdre leur place. 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"
    ));
}
$vbLabelText   $csharpLabel

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 :

Interopérabilité IronXL vs Microsoft Excel pour l'exportation de DataGridView
Capacité IronXL Microsoft Interop
Nécessite l'installation de Microsoft Excel Non Oui
Fonctionne dans des environnements serveur/cloud Oui Nonn (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 bien 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 d' 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 :

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.

Jordi Bardia
Jordi Bardia
  Discutez maintenant avec l'équipe d'ingénierie
Ingénieur logiciel
Jordi est le plus compétent en Python, C# et C++, et lorsqu'il ne met pas à profit ses compétences chez Iron Software, il programme des jeux. Partageant les responsabilités des tests de produit, du développement de produit et de la recherche, Jordi apporte une immense valeur à l'amé...
Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Essai gratuit

Iron Support Team

We're online 24 hours, 5 days a week.
Chat
Email
Call Me