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

Comment exporter un DataTable vers Excel en C# en utilisant Interop ou IronXL

Jordi Bardia
Jordi Bardia
Publié:

Introduction à l'exportation de données vers un fichier Excel

L'exportation de données d'une base de données ou d'une application vers un fichier Excel est une nécessité fondamentale pour les organisations qui ont besoin d'analyser, de visualiser et de partager efficacement des informations. Les fichiers Excel sont largement reconnus pour leur interface conviviale, qui facilite l'interaction et l'interprétation des données par les utilisateurs. En convertissant les ensembles de données au format .XLSX, les développeurs s'assurent que les données restent accessibles et structurées, quel que soit le niveau technique de l'utilisateur. Ce processus préserve non seulement l'intégrité des données d'origine, mais permet également un transfert de données transparent entre les systèmes. Pour ce faire, les développeurs peuvent utiliser diverses bibliothèques Excel, telles qu'IronXL, EPPlus, NPOI et ClosedXML, qui leur permettent de créer, lire et manipuler des fichiers Excel par programmation, sans avoir à installer Microsoft Excel sur le serveur ou le poste client. Ces bibliothèques permettent aux utilisateurs de générer des rapports professionnels et d'exporter des données au format Excel, répondant ainsi à un large éventail de besoins métiers et analytiques.

Quelles sont les principales différences entre Interop et IronXL ?

Avant de se plonger dans le code, comprendre les différences fondamentales entre ces deux approches permet de faire le bon choix pour tout projet. La comparaison porte sur l'architecture technique, les exigences de déploiement et l'expérience pratique de développement lors de l'utilisation de scénarios d'exportation de DataTable vers Excel.

Fonctionnalité Interopérabilité Microsoft Office IronXL
Installation de bureau requise Oui – Microsoft Excel doit être installé Non – bibliothèque autonome
Assistance côté serveur Non recommandé par Microsoft Entièrement pris en charge
Support de la plateforme Windows uniquement Windows, Linux, macOS, Azure
Prise en charge de .NET Core/.NET 5 et versions ultérieures Limité Prise en charge complète (.NET 6, 7, 8, 9, 10)
Gestion des ressources Nécessite le nettoyage des objets COM Élimination standard .NET
Méthode d'installation Référence COM + Installation d'Office Installer le package via NuGet
Modèle de filetage Appartement monofilaire (STA) Opérations sécurisées pour les threads
Grands ensembles de données Processus nécessitant une mémoire importante Approche efficace basée sur les fichiers
Formats de fichiers XLSX, XLS, CSV XLSX, XLS, CSV, JSON, XML
Licence Nécessite une licence Office Licence commerciale disponible

La différence architecturale est fondamentale : Excel Interop automatise l'application Microsoft Excel elle-même via COM, tandis qu'IronXL lit et écrit directement les formats de fichiers Excel sans lancer aucun processus externe. Cette distinction a des répercussions sur tous les aspects, de l'utilisation de la mémoire à la complexité du déploiement.

Comment exporter un DataTable vers Excel C# en utilisant l'interopérabilité ?

L'approche traditionnelle utilise l'espace de noms Microsoft.Office.Interop.Excel pour automatiser directement Excel. Cette méthode nécessite l'installation de Microsoft Excel sur la machine où le code s'exécute.

Prérequis

Avant d'utiliser Interop, assurez-vous de :

  1. Microsoft Excel est installé sur les machines de développement et de déploiement.
  2. Ajoutez une référence COM à " Microsoft Excel Object Library " dans Visual Studio
  3. Incluez l'espace de noms Microsoft.Office.Interop.Excel

Exemple de code d'interopérabilité

Le code suivant montre comment exporter un DataTable vers un fichier Excel à l'aide de Microsoft Office Interop :

using Microsoft.Office.Interop.Excel;
using System.Data;
using System.Runtime.InteropServices;

// Create a sample DataTable with employee data
DataTable dt = new DataTable("Employees");
dt.Columns.Add("EmployeeID", typeof(int));
dt.Columns.Add("Name", typeof(string));
dt.Columns.Add("Department", typeof(string));
dt.Columns.Add("Salary", typeof(decimal));

// Fill the DataTable with sample rows
dt.Rows.Add(1, "John Smith", "Engineering", 75000);
dt.Rows.Add(2, "Sarah Johnson", "Marketing", 65000);
dt.Rows.Add(3, "Michael Chen", "Finance", 70000);
dt.Rows.Add(4, "Emily Davis", "Engineering", 80000);

// Initialize Excel Application object
Application excelApp = new Application
{
    Visible = false,
    DisplayAlerts = false
};

// Create new Workbook and get the active Worksheet
Workbook workbook = excelApp.Workbooks.Add();
Worksheet worksheet = (Worksheet)workbook.ActiveSheet;

try
{
    // Write column headers to the first row
    for (int i = 0; i < dt.Columns.Count; i++)
    {
        worksheet.Cells[1, i + 1] = dt.Columns[i].ColumnName;
    }
    // Write data rows starting from row 2
    for (int i = 0; i < dt.Rows.Count; i++)
    {
        for (int j = 0; j < dt.Columns.Count; j++)
        {
            worksheet.Cells[i + 2, j + 1] = dt.Rows[i][j].ToString();
        }
    }
    // Define file path and save the Excel file
    string filePath = @"C:\Reports\EmployeeReport_Interop.xlsx";
    workbook.SaveAs(filePath);
    Console.WriteLine("Excel file created successfully using Interop.");
}
catch (Exception ex)
{
    Console.WriteLine("Error exporting data to Excel: " + ex.Message);
}
finally
{
    // Close workbook and quit Excel application
    workbook.Close();
    excelApp.Quit();
    // Critical: Release COM objects to prevent memory leaks
    Marshal.ReleaseComObject(worksheet);
    Marshal.ReleaseComObject(workbook);
    Marshal.ReleaseComObject(excelApp);
}
using Microsoft.Office.Interop.Excel;
using System.Data;
using System.Runtime.InteropServices;

// Create a sample DataTable with employee data
DataTable dt = new DataTable("Employees");
dt.Columns.Add("EmployeeID", typeof(int));
dt.Columns.Add("Name", typeof(string));
dt.Columns.Add("Department", typeof(string));
dt.Columns.Add("Salary", typeof(decimal));

// Fill the DataTable with sample rows
dt.Rows.Add(1, "John Smith", "Engineering", 75000);
dt.Rows.Add(2, "Sarah Johnson", "Marketing", 65000);
dt.Rows.Add(3, "Michael Chen", "Finance", 70000);
dt.Rows.Add(4, "Emily Davis", "Engineering", 80000);

// Initialize Excel Application object
Application excelApp = new Application
{
    Visible = false,
    DisplayAlerts = false
};

// Create new Workbook and get the active Worksheet
Workbook workbook = excelApp.Workbooks.Add();
Worksheet worksheet = (Worksheet)workbook.ActiveSheet;

try
{
    // Write column headers to the first row
    for (int i = 0; i < dt.Columns.Count; i++)
    {
        worksheet.Cells[1, i + 1] = dt.Columns[i].ColumnName;
    }
    // Write data rows starting from row 2
    for (int i = 0; i < dt.Rows.Count; i++)
    {
        for (int j = 0; j < dt.Columns.Count; j++)
        {
            worksheet.Cells[i + 2, j + 1] = dt.Rows[i][j].ToString();
        }
    }
    // Define file path and save the Excel file
    string filePath = @"C:\Reports\EmployeeReport_Interop.xlsx";
    workbook.SaveAs(filePath);
    Console.WriteLine("Excel file created successfully using Interop.");
}
catch (Exception ex)
{
    Console.WriteLine("Error exporting data to Excel: " + ex.Message);
}
finally
{
    // Close workbook and quit Excel application
    workbook.Close();
    excelApp.Quit();
    // Critical: Release COM objects to prevent memory leaks
    Marshal.ReleaseComObject(worksheet);
    Marshal.ReleaseComObject(workbook);
    Marshal.ReleaseComObject(excelApp);
}
$vbLabelText   $csharpLabel

Ce code illustre le processus complet d'exportation d'une DataTable vers un fichier Excel à l'aide de Microsoft Interop. Il commence par la création d'une nouvelle DataTable nommée dt contenant les informations des employés : quatre colonnes représentant l'identifiant, le nom, le service et le salaire, des types de données courants dans les applications d'entreprise.

L'objet Application représente le processus Excel lui-même. Définir la propriété Visible = false empêche l'application Excel d'apparaître à l'écran pendant le traitement, ce qui est essentiel pour les opérations en arrière-plan. Le paramètre DisplayAlerts = false supprime les boîtes de dialogue qui interrompraient autrement les flux de travail automatisés lorsque les utilisateurs exécutent l'exportation.

Les objets Workbook et Worksheet correspondent directement à la structure de fichiers d'Excel. Un classeur est le fichier Excel lui-même (au format .XLSX ou .XLS), tandis que les feuilles de calcul sont les onglets individuels de ce fichier. Le code utilise workbook.ActiveSheet pour obtenir une référence à la feuille par défaut créée avec chaque nouveau classeur.

Comment exporter un DataTable vers Excel à l'aide d'IronXL ?

IronXL offre une alternative moderne qui fonctionne sans installation d'Office. La bibliothèque lit et écrit directement les fichiers Excel, ce qui la rend adaptée aux environnements serveur, aux déploiements cloud et aux applications multiplateformes.

Prérequis

Installez IronXL via la console du gestionnaire de packages NuGet :

Install-Package IronXL.Excel
Install-Package IronXL.Excel
SHELL

Ou utilisez le .NET CLI :

dotnet add package IronXL.Excel
dotnet add package IronXL.Excel
SHELL

Aucun logiciel supplémentaire, installation d'Office ou configuration système n'est requis. La bibliothèque fonctionne immédiatement après son installation sous Windows, Linux et macOS. Pour les déploiements Azure, IronXL s'exécute dans App Services, Functions et les instances de conteneurs sans configuration particulière. La bibliothèque prend en charge .NET Framework 4.6.2+ et toutes les versions modernes de .NET, y compris .NET 6, 7, 8, 9 et 10.

Exemple de code IronXL

Le code suivant montre comment convertir un DataTable en Excel à l'aide de la bibliothèque IronXL :

using IronXL;
using System.Data;

// Create a sample DataTable
DataTable dt = new DataTable("Employees");
dt.Columns.Add("EmployeeID", typeof(int));
dt.Columns.Add("Name", typeof(string));
dt.Columns.Add("Department", typeof(string));
dt.Columns.Add("Salary", typeof(decimal));

// Fill DataTable with rows of data
dt.Rows.Add(1, "John Smith", "Engineering", 75000);
dt.Rows.Add(2, "Sarah Johnson", "Marketing", 65000);
dt.Rows.Add(3, "Michael Chen", "Finance", 70000);
dt.Rows.Add(4, "Emily Davis", "Engineering", 80000);

// Create a new Excel workbook and worksheet
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Employees");

// Write column names to the first row as headers
for (int i = 0; i < dt.Columns.Count; i++)
{
    sheet.SetCellValue(0, i, dt.Columns[i].ColumnName);
}

// Export DataTable rows to Excel cells
for (int i = 0; i < dt.Rows.Count; i++)
{
    for (int j = 0; j < dt.Columns.Count; j++)
    {
        sheet.SetCellValue(i + 1, j, dt.Rows[i][j]);
    }
}

// Save to file path as xlsx format
string filePath = @"C:\Reports\EmployeeReport_IronXL.xlsx";
workbook.SaveAs(filePath);
Console.WriteLine("Excel file created successfully using IronXL.");
using IronXL;
using System.Data;

// Create a sample DataTable
DataTable dt = new DataTable("Employees");
dt.Columns.Add("EmployeeID", typeof(int));
dt.Columns.Add("Name", typeof(string));
dt.Columns.Add("Department", typeof(string));
dt.Columns.Add("Salary", typeof(decimal));

// Fill DataTable with rows of data
dt.Rows.Add(1, "John Smith", "Engineering", 75000);
dt.Rows.Add(2, "Sarah Johnson", "Marketing", 65000);
dt.Rows.Add(3, "Michael Chen", "Finance", 70000);
dt.Rows.Add(4, "Emily Davis", "Engineering", 80000);

// Create a new Excel workbook and worksheet
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Employees");

// Write column names to the first row as headers
for (int i = 0; i < dt.Columns.Count; i++)
{
    sheet.SetCellValue(0, i, dt.Columns[i].ColumnName);
}

// Export DataTable rows to Excel cells
for (int i = 0; i < dt.Rows.Count; i++)
{
    for (int j = 0; j < dt.Columns.Count; j++)
    {
        sheet.SetCellValue(i + 1, j, dt.Rows[i][j]);
    }
}

// Save to file path as xlsx format
string filePath = @"C:\Reports\EmployeeReport_IronXL.xlsx";
workbook.SaveAs(filePath);
Console.WriteLine("Excel file created successfully using IronXL.");
$vbLabelText   $csharpLabel

L'approche IronXL suit une structure logique similaire, mais avec une syntaxe plus claire et sans complexité COM. Cette bibliothèque Excel permet aux développeurs de créer, lire et écrire des fichiers tableur sans aucune dépendance à Microsoft Office. La méthode WorkBook.Create initialise un nouveau classeur au format spécifié : ExcelFileFormat.XLSX produit des fichiers Office Open XML modernes compatibles avec Excel 2007 et versions ultérieures, tandis que la bibliothèque prend également en charge le format XLS pour les systèmes plus anciens.

Sortie

Comment exporter un DataTable vers Excel en C# avec Interop ou IronXL : Image 1 - Sortie Excel

Comment exporter un DataTable vers Excel en C# avec Interop ou IronXL : Image 2 - Sortie console

La méthode CreateWorkSheet ajoute une nouvelle feuille de calcul au classeur avec le nom de tableau spécifié. Contrairement à Interop où l'on travaille d'abord avec l'objet application, IronXL travaille directement avec les structures de fichiers. Le nom de la feuille apparaît dans l'onglet situé en bas d'Excel lorsque les utilisateurs ouvrent le fichier.

Le remplissage des cellules utilise SetCellValue , qui accepte l'index de ligne, l'index de colonne et la valeur à écrire. Contrairement à l'indexation à partir de 1 d'Excel Interop, IronXL utilise des index à partir de 0, conformément aux conventions standard du framework .NET : la ligne 0 correspond à la première ligne et la colonne 0 à la première colonne. Cette cohérence avec les autres collections .NET et les colonnes DataTable réduit la charge cognitive et élimine les erreurs de décalage d'une unité qui se produisent souvent lors de la conversion entre systèmes d'indexation.

Cette méthode gère la conversion de type automatiquement et intelligemment. Les valeurs entières, chaînes de caractères, décimales et DateTime sont écrites avec la mise en forme appropriée des cellules Excel. Une valeur décimale apparaît sous forme de nombre pouvant être utilisé dans des formules, tandis que les valeurs de date peuvent être formatées au format jj/mm/aaaa ou dans d'autres formats régionaux. La bibliothèque gère correctement les valeurs nulles et les données manquantes sans lever d'exceptions.

Remarquez l'absence totale de code de nettoyage. Les objets IronXL sont des objets .NET standard gérés par le garbage collector. Il n'y a aucun risque de processus orphelins, aucun comptage de références COM à gérer et aucune fuite de mémoire due à des modèles de suppression inappropriés. Cette simplification à elle seule élimine toute une catégorie de bogues qui affectent les solutions d'interopérabilité Excel.

Pour plus de détails sur les fonctionnalités de création Excel d'IronXL, consultez la documentation relative à la création de feuilles de calcul .

Comment créer une méthode d'exportation réutilisable ?

Les applications de production nécessitent souvent une méthode réutilisable pour exporter n'importe quel DataTable vers un fichier Excel. L'exemple de code suivant illustre une classe utilitaire qui encapsule la logique d'exportation et peut être appelée depuis des gestionnaires d'événements, comme lors de clics sur des boutons, avec des paramètres object sender .

Aide à l'exportation réutilisable IronXL

using IronXL;
using System.Data;
using System.IO;
using System;
public class ExcelExporter
{
    /// <summary>
    /// Export a DataTable to Excel file at the specified path
    /// </summary>
    public static bool ExportToExcel(DataTable dt, string filePath)
    {
        if (dt == null || dt.Rows.Count == 0)
            return false;
        try
        {
            // Create new workbook and worksheet
            WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
            WorkSheet sheet = workbook.CreateWorkSheet(dt.TableName ?? "Sheet1");
            // Write column names as headers in the first row
            for (int i = 0; i < dt.Columns.Count; i++)
            {
                var cell = sheet.GetCellAt(0, i);
                cell.Value = dt.Columns[i].ColumnName;
                cell.Style.Font.Bold = true;
            }
            // Fill cells with data values from each row
            for (int i = 0; i < dt.Rows.Count; i++)
            {
                for (int j = 0; j < dt.Columns.Count; j++)
                {
                    var value = dt.Rows[i][j];
                    // Handle missing or null values
                    if (value == DBNull.Value || value == null)
                        sheet.SetCellValue(i + 1, j, "");
                    else
                        sheet.SetCellValue(i + 1, j, value);
                }
            }
            // Validate file path and save
            FileInfo fileInfo = new FileInfo(filePath);
            if (!fileInfo.Directory.Exists)
                fileInfo.Directory.Create();
            workbook.SaveAs(filePath);
            return true;
        }
        catch (Exception ex)
        {
            Console.WriteLine("Export failed: " + ex.Message);
            return false;
        }
    }
    /// <summary>
    /// Query a DataTable and export filtered results
    /// </summary>
    public static DataTable FilterAndExport(DataTable dt, string filterExpression, string filePath)
    {
        if (dt == null)
            return dt;
        // Create filtered view and export
        DataRow[] filteredRows = dt.Select(filterExpression);
        DataTable filteredTable = dt.Clone();
        foreach (DataRow row in filteredRows)
        {
            filteredTable.ImportRow(row);
        }
        ExportToExcel(filteredTable, filePath);
        return filteredTable;
    }
    /// <summary>
    /// Export DataTable to CSV file as an alternative format
    /// </summary>
    public static string ExportToCsv(DataTable dt)
    {
        StringBuilder sb = new StringBuilder();
        // Write column headers
        string[] columnNames = dt.Columns.Cast<DataColumn>().Select(column => column.ColumnName).ToArray();
        sb.AppendLine(string.Join(",", columnNames));
        // Write data rows
        foreach (DataRow row in dt.Rows)
        {
            string[] values = row.ItemArray.Select(field => field?.ToString() ?? "").ToArray();
            sb.AppendLine(string.Join(",", values));
        }
        return sb.ToString();
    }
}
// Usage example in Windows Forms or WPF event handler
public void ExportButton_Click(object sender, EventArgs e)
{
    DataTable dt = GetEmployeeData(); // Your data source
    string filePath = @"C:\Reports\Export.xlsx";
    bool success = ExcelExporter.ExportToExcel(dt, filePath);
    if (success)
        Console.WriteLine("Export completed successfully");
}
using IronXL;
using System.Data;
using System.IO;
using System;
public class ExcelExporter
{
    /// <summary>
    /// Export a DataTable to Excel file at the specified path
    /// </summary>
    public static bool ExportToExcel(DataTable dt, string filePath)
    {
        if (dt == null || dt.Rows.Count == 0)
            return false;
        try
        {
            // Create new workbook and worksheet
            WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
            WorkSheet sheet = workbook.CreateWorkSheet(dt.TableName ?? "Sheet1");
            // Write column names as headers in the first row
            for (int i = 0; i < dt.Columns.Count; i++)
            {
                var cell = sheet.GetCellAt(0, i);
                cell.Value = dt.Columns[i].ColumnName;
                cell.Style.Font.Bold = true;
            }
            // Fill cells with data values from each row
            for (int i = 0; i < dt.Rows.Count; i++)
            {
                for (int j = 0; j < dt.Columns.Count; j++)
                {
                    var value = dt.Rows[i][j];
                    // Handle missing or null values
                    if (value == DBNull.Value || value == null)
                        sheet.SetCellValue(i + 1, j, "");
                    else
                        sheet.SetCellValue(i + 1, j, value);
                }
            }
            // Validate file path and save
            FileInfo fileInfo = new FileInfo(filePath);
            if (!fileInfo.Directory.Exists)
                fileInfo.Directory.Create();
            workbook.SaveAs(filePath);
            return true;
        }
        catch (Exception ex)
        {
            Console.WriteLine("Export failed: " + ex.Message);
            return false;
        }
    }
    /// <summary>
    /// Query a DataTable and export filtered results
    /// </summary>
    public static DataTable FilterAndExport(DataTable dt, string filterExpression, string filePath)
    {
        if (dt == null)
            return dt;
        // Create filtered view and export
        DataRow[] filteredRows = dt.Select(filterExpression);
        DataTable filteredTable = dt.Clone();
        foreach (DataRow row in filteredRows)
        {
            filteredTable.ImportRow(row);
        }
        ExportToExcel(filteredTable, filePath);
        return filteredTable;
    }
    /// <summary>
    /// Export DataTable to CSV file as an alternative format
    /// </summary>
    public static string ExportToCsv(DataTable dt)
    {
        StringBuilder sb = new StringBuilder();
        // Write column headers
        string[] columnNames = dt.Columns.Cast<DataColumn>().Select(column => column.ColumnName).ToArray();
        sb.AppendLine(string.Join(",", columnNames));
        // Write data rows
        foreach (DataRow row in dt.Rows)
        {
            string[] values = row.ItemArray.Select(field => field?.ToString() ?? "").ToArray();
            sb.AppendLine(string.Join(",", values));
        }
        return sb.ToString();
    }
}
// Usage example in Windows Forms or WPF event handler
public void ExportButton_Click(object sender, EventArgs e)
{
    DataTable dt = GetEmployeeData(); // Your data source
    string filePath = @"C:\Reports\Export.xlsx";
    bool success = ExcelExporter.ExportToExcel(dt, filePath);
    if (success)
        Console.WriteLine("Export completed successfully");
}
$vbLabelText   $csharpLabel

Cette classe d'assistance illustre plusieurs modèles prêts pour la production. La méthode ExportToExcel accepte n'importe quel DataTable et une chaîne de chemin de fichier, et renvoie false si l'exportation échoue ou si le tableau est vide. La méthode gère correctement les valeurs manquantes en vérifiant la présence de DBNull.Value avant d'écrire dans les cellules.

La méthode FilterAndExport montre comment interroger une DataTable à l'aide d'expressions de filtre avant l'exportation ; cela est utile lorsque les utilisateurs ont besoin d'exporter uniquement des enregistrements spécifiques. La méthode renvoie la DataTable filtrée afin que le code appelant puisse l'utiliser pour un traitement supplémentaire.

La méthode ExportToCsv utilise un StringBuilder pour générer efficacement un fichier CSV comme alternative au format Excel. Bien qu'IronXL gère nativement l'exportation CSV, cet exemple illustre la méthode manuelle à des fins pédagogiques.

L'exemple de gestionnaire d'événements montre comment ces méthodes s'intègrent aux applications Windows Forms ou WPF où object sender et EventArgs sont des paramètres standard. Certains développeurs familiers avec ClosedXML pourraient reconnaître des modèles similaires utilisant new XLWorkbook() , mais l'API d'IronXL offre des fonctionnalités équivalentes avec une prise en charge de formats supplémentaires.

Comment les deux approches gèrent-elles la mise en forme des cellules ?

Les exportations Excel professionnelles nécessitent souvent une mise en forme : titres en gras, cellules colorées, bordures et formats numériques. Les deux bibliothèques prennent en charge la mise en forme, mais leur implémentation diffère considérablement.

Mise en forme avec Interop

using Microsoft.Office.Interop.Excel;
using System.Data;
using System.Runtime.InteropServices;
DataTable dt = new DataTable("Sales");
dt.Columns.Add("Product", typeof(string));
dt.Columns.Add("Revenue", typeof(decimal));
dt.Rows.Add("Widget A", 15000.50m);
dt.Rows.Add("Widget B", 22500.75m);
Application excelApp = new Application();
Workbook workbook = excelApp.Workbooks.Add();
Worksheet worksheet = (Worksheet)workbook.ActiveSheet;
// Write column headers with formatting to first row
for (int i = 0; i < dt.Columns.Count; i++)
{
    Range headerCell = worksheet.Cells[1, i + 1];
    headerCell.Value = dt.Columns[i].ColumnName;
    headerCell.Font.Bold = true;
    headerCell.Interior.Color = System.Drawing.ColorTranslator.ToOle(System.Drawing.Color.LightBlue);
    headerCell.Borders.LineStyle = XlLineStyle.xlContinuous;
}
// Write data values to cells
for (int i = 0; i < dt.Rows.Count; i++)
{
    for (int j = 0; j < dt.Columns.Count; j++)
    {
        worksheet.Cells[i + 2, j + 1] = dt.Rows[i][j];
    }
}
string filePath = @"C:\Reports\FormattedReport_Interop.xlsx";
workbook.SaveAs(filePath);
workbook.Close();
excelApp.Quit();
Marshal.ReleaseComObject(worksheet);
Marshal.ReleaseComObject(workbook);
Marshal.ReleaseComObject(excelApp);
using Microsoft.Office.Interop.Excel;
using System.Data;
using System.Runtime.InteropServices;
DataTable dt = new DataTable("Sales");
dt.Columns.Add("Product", typeof(string));
dt.Columns.Add("Revenue", typeof(decimal));
dt.Rows.Add("Widget A", 15000.50m);
dt.Rows.Add("Widget B", 22500.75m);
Application excelApp = new Application();
Workbook workbook = excelApp.Workbooks.Add();
Worksheet worksheet = (Worksheet)workbook.ActiveSheet;
// Write column headers with formatting to first row
for (int i = 0; i < dt.Columns.Count; i++)
{
    Range headerCell = worksheet.Cells[1, i + 1];
    headerCell.Value = dt.Columns[i].ColumnName;
    headerCell.Font.Bold = true;
    headerCell.Interior.Color = System.Drawing.ColorTranslator.ToOle(System.Drawing.Color.LightBlue);
    headerCell.Borders.LineStyle = XlLineStyle.xlContinuous;
}
// Write data values to cells
for (int i = 0; i < dt.Rows.Count; i++)
{
    for (int j = 0; j < dt.Columns.Count; j++)
    {
        worksheet.Cells[i + 2, j + 1] = dt.Rows[i][j];
    }
}
string filePath = @"C:\Reports\FormattedReport_Interop.xlsx";
workbook.SaveAs(filePath);
workbook.Close();
excelApp.Quit();
Marshal.ReleaseComObject(worksheet);
Marshal.ReleaseComObject(workbook);
Marshal.ReleaseComObject(excelApp);
$vbLabelText   $csharpLabel

Le code de formatage Interop accède aux objets Range individuels et définit des propriétés telles que Font.Bold , Interior.Color et Borders.LineStyle . Chaque accès à une propriété est un appel interprocessus COM, ce qui ajoute une surcharge et augmente le risque d'exceptions si Excel ne répond plus.

Mise en forme avec IronXL

using IronXL;
using IronXL.Styles;
using System.Data;
DataTable dt = new DataTable("Sales");
dt.Columns.Add("Product", typeof(string));
dt.Columns.Add("Revenue", typeof(decimal));
dt.Rows.Add("Widget A", 15000.50m);
dt.Rows.Add("Widget B", 22500.75m);
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Sales");
// Write column headers with formatting to first row
for (int i = 0; i < dt.Columns.Count; i++)
{
    sheet.SetCellValue(0, i, dt.Columns[i].ColumnName);
    var cell = sheet.GetCellAt(0, i);
    cell.Value = dt.Columns[i].ColumnName;
    cell.Style.Font.Bold = true;
    cell.Style.SetBackgroundColor("#ADD8E6");
    cell.Style.BottomBorder.SetColor("#000000");
    cell.Style.BottomBorder.Type = BorderType.Thin;
}
// Write data rows with values from DataTable
for (int i = 0; i < dt.Rows.Count; i++)
{
    for (int j = 0; j < dt.Columns.Count; j++)
    {
        sheet.SetCellValue(i + 1, j, dt.Rows[i][j]);
    }
}
string filePath = @"C:\Reports\FormattedReport_IronXL.xlsx";
workbook.SaveAs(filePath);
using IronXL;
using IronXL.Styles;
using System.Data;
DataTable dt = new DataTable("Sales");
dt.Columns.Add("Product", typeof(string));
dt.Columns.Add("Revenue", typeof(decimal));
dt.Rows.Add("Widget A", 15000.50m);
dt.Rows.Add("Widget B", 22500.75m);
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Sales");
// Write column headers with formatting to first row
for (int i = 0; i < dt.Columns.Count; i++)
{
    sheet.SetCellValue(0, i, dt.Columns[i].ColumnName);
    var cell = sheet.GetCellAt(0, i);
    cell.Value = dt.Columns[i].ColumnName;
    cell.Style.Font.Bold = true;
    cell.Style.SetBackgroundColor("#ADD8E6");
    cell.Style.BottomBorder.SetColor("#000000");
    cell.Style.BottomBorder.Type = BorderType.Thin;
}
// Write data rows with values from DataTable
for (int i = 0; i < dt.Rows.Count; i++)
{
    for (int j = 0; j < dt.Columns.Count; j++)
    {
        sheet.SetCellValue(i + 1, j, dt.Rows[i][j]);
    }
}
string filePath = @"C:\Reports\FormattedReport_IronXL.xlsx";
workbook.SaveAs(filePath);
$vbLabelText   $csharpLabel

L'API de style d'IronXL utilise une syntaxe fluide et intuitive que les développeurs .NET trouveront familière. La propriété Style permet d'accéder aux paramètres de police, aux couleurs d'arrière-plan et aux bordures grâce à un modèle objet clair. Les valeurs de couleur acceptent les codes hexadécimaux standard comme #ADD8E6 (bleu clair), ce qui facilite le respect de l'image de marque ou des spécifications de conception de l'entreprise sans conversion entre les systèmes de couleurs.

Sortie

Comment exporter un DataTable vers Excel en C# en utilisant Interop ou IronXL : Image 3 - Mise en forme avec la sortie IronXL

La syntaxe d'accès aux cellules sheet[row, col] permet un accès direct aux cellules individuelles sans créer d'objets supplémentaires ni de références de plage. Cette approche réduit la verbosité du code et élimine les formalités requises par les API basées sur COM. Définir plusieurs propriétés de style sur une même cellule est simple : chaque affectation de propriété modifie directement l'apparence de la cellule.

La configuration des bordures illustre la conception pratique d'IronXL. Plutôt que de manipuler des valeurs d'énumération qui nécessitent des recherches dans la documentation, les développeurs utilisent BorderType.Thin pour les bordures standard ou BorderType.Thick pour les bordures accentuées. La méthode SetColor accepte les codes de couleur hexadécimaux pour la coloration des bordures, assurant ainsi la cohérence avec la spécification de la couleur d'arrière-plan.

Pour des options de mise en forme complètes, notamment les formats numériques, la mise en forme conditionnelle et les techniques de style avancées, consultez la documentation sur le style des cellules et le guide d'alignement des bordures .

Meilleures pratiques pour l'exportation

Pour garantir une exportation fluide et fiable des données vers Excel, il est important de suivre les bonnes pratiques tout au long du processus de développement. Utilisez toujours un chemin d'accès et une convention d'appellation cohérents pour le fichier Excel exporté afin de simplifier et de rendre plus prévisible la gestion des fichiers. Mettez en œuvre une gestion robuste des erreurs en interceptant les exceptions, par exemple en utilisant catch (Exception ex) , et en renvoyant false ou en fournissant un retour d'information significatif si une erreur se produit lors de l'exportation. Pour les grands ensembles de données, envisagez d'utiliser le SDK OpenXML, qui offre une méthode performante et économe en mémoire pour écrire des données dans des fichiers Excel sans les contraintes liées à l'automatisation de Microsoft Excel. Des bibliothèques comme ClosedXML simplifient encore davantage le processus d'exportation, en fournissant des API intuitives qui contribuent à garantir que votre code fonctionne efficacement et est facile à maintenir. En respectant ces bonnes pratiques, les développeurs peuvent créer des routines d'exportation à la fois fiables et évolutives, fournissant des données précises dans des fichiers Excel, quelle que soit la taille ou la complexité de l'ensemble de données.

Quand faut-il choisir chaque approche ?

Le choix approprié dépend des exigences spécifiques du projet, de l'environnement de déploiement et des considérations de maintenance à long terme lorsque vous devez exporter des données DataTable vers des fichiers Excel.

Choisissez Microsoft Office Excel Interop lorsque :

  • Travailler avec des systèmes existants sur lesquels Office est déjà installé et qui dépendent de l'interopérabilité
  • Besoin de fonctionnalités Excel avancées telles que les macros, les tableaux croisés dynamiques ou l'automatisation des graphiques, qui nécessitent le modèle objet d'application Excel complet
  • Création d'applications de bureau où les utilisateurs ont Microsoft Excel installé et où l'application fonctionne de manière interactive L'environnement de déploiement est entièrement contrôlé, exclusivement sous Windows, et les licences Office sont déjà disponibles.
  • Automatisation des modèles Excel existants contenant des formules complexes ou du code VBA

Choisissez IronXL lorsque :

  • Création d'applications web, d'API REST ou de services en arrière-plan qui génèrent des exportations de fichiers Excel
  • Déploiement dans des environnements cloud tels qu'Azure App Services, AWS Lambda ou des conteneurs Docker
  • Nécessite une prise en charge multiplateforme pour les déploiements sous Windows, Linux ou macOS
  • Utilisation de .NET Framework 4.6.2+ ou de versions .NET modernes où la prise en charge de l'interopérabilité est limitée
  • Besoin d'une gestion des ressources fiable et prévisible, sans soucis de nettoyage COM
  • Éviter la dépendance des licences Office vis-à-vis des serveurs de production
  • Création d'applications multi-locataires où la génération de fichiers Excel isolés est essentielle
  • Traitement efficace de grands ensembles de données sans la surcharge liée à la communication interprocessus COM
  • Nécessité d'exporter vers plusieurs formats, notamment XLSX, XLS, CSV, JSON et XML

Les tutoriels IronXL fournissent des exemples supplémentaires couvrant des scénarios courants, notamment la lecture de fichiers Excel existants , l'utilisation de formules et la gestion de plusieurs feuilles de calcul . La bibliothèque prend également en charge l'utilisation des objets DataSet lorsque vous devez exporter plusieurs tables liées vers différentes feuilles.

Conclusion

L'exportation d'un DataTable vers un fichier Excel est une exigence fondamentale pour les applications .NET qui traitent des données d'entreprise. Que vous ayez besoin d'exporter des données à partir d'une requête de base de données, de créer des rapports à partir d'un DataSet ou de convertir des colonnes de DataTable en feuilles Excel formatées, le choix de la bibliothèque appropriée est important.

Bien que Microsoft Office Excel Interop ait servi les développeurs pendant des années, sa dépendance à l'installation d'Office, la complexité de COM, les scénarios de serveur non pris en charge et les défis liés à la gestion des ressources le rendent de plus en plus impraticable pour le développement d'applications modernes. Les problèmes tels que les blocs catch (Exception ex) remplis de code de nettoyage COM et les solutions de contournement pour les références manquantes sont des points sensibles courants.

IronXL propose une alternative plus propre et plus fiable qui répond directement à ces limitations. Grâce à Install-Package simple via NuGet, une prise en charge multiplateforme couvrant Windows, Linux et macOS, et des API simples qui suivent les conventions du .NET Framework, il élimine les maux de tête liés au déploiement et les pièges de gestion des ressources qui affectent les solutions d'interopérabilité Excel. Les exemples de code de cet article démontrent que la réalisation de la même tâche d'exportation de DataTable vers Excel nécessite un effort de développement similaire, mais IronXL offre des résultats sans les frais généraux d'exploitation et de maintenance.

Prêt à simplifier la génération de fichiers Excel dans les projets .NET ? Essayez gratuitement IronXL et constatez la différence dans votre flux de travail de développement. Pour le déploiement en production et les licences d'équipe, explorez les options de licence qui correspondent aux besoins de votre organisation.

Questions Fréquemment Posées

Quel est le principal avantage d'utiliser IronXL plutôt qu'Excel Interop pour exporter des DataTables en C# ?

IronXL offre une méthode plus simple et plus efficace pour exporter des DataTables vers Excel en C# sans nécessiter l'installation d'Excel sur le serveur.

IronXL peut-il gérer les grands DataTables lors de l'exportation vers Excel ?

Oui, IronXL est optimisé pour la performance et peut gérer de grands DataTables, garantissant une exportation rapide et fiable vers des fichiers Excel.

Ai-je besoin de Microsoft Excel installé pour utiliser IronXL afin d'exporter des données ?

Non, IronXL ne nécessite pas l'installation de Microsoft Excel, ce qui le rend idéal pour les applications côté serveur.

En quoi IronXL simplifie-t-il le processus d'exportation de DataTables par rapport à Interop ?

IronXL simplifie le processus en éliminant la configuration complexe et les dépendances associées à l'interopérabilité, en fournissant une API simple pour l'exportation des DataTables.

IronXL est-il compatible avec .NET Core pour l'exportation de DataTables vers Excel ?

Oui, IronXL est entièrement compatible avec .NET Core, ce qui vous permet d'exporter des DataTables vers Excel dans des applications multiplateformes.

Dans quels formats de fichiers IronXL peut-il exporter DataTables ?

IronXL peut exporter les DataTables vers différents formats de fichiers Excel, notamment XLSX, XLS et CSV.

IronXL prend-il en charge la mise en forme et le style des feuilles Excel ?

Oui, IronXL prend en charge des options de style et de mise en forme avancées, vous permettant de créer des feuilles Excel soignées à partir de DataTables.

Puis-je utiliser IronXL pour automatiser les tâches liées à Excel en C# ?

Oui, IronXL peut être utilisé pour automatiser un large éventail de tâches liées à Excel, de l'exportation de DataTables aux opérations complexes d'analyse de données.

Existe-t-il une courbe d'apprentissage pour les développeurs qui découvrent IronXL ?

IronXL est conçu pour être intuitif et facile à apprendre, avec une documentation complète et de nombreux exemples pour aider les développeurs à démarrer rapidement.

Quelles sont les options de licence pour utiliser IronXL dans un projet commercial ?

IronXL propose différentes options de licence pour répondre aux besoins des différents projets, notamment des licences perpétuelles et des licences par abonnement pour une utilisation commerciale.

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