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
Mis à jour:

Pourquoi l'exportation de DataTable vers Excel est-elle importante pour les développeurs .NET ?

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, ce qui facilite l'interaction et l'interprétation des données par les utilisateurs finaux. En convertissant les ensembles de données au format .xlsx, les développeurs s'assurent que les données restent accessibles et bien structurées quel que soit le niveau technique du destinataire.

Pour les développeurs .NET , il existe deux approches courantes : Interopérabilité de Microsoft Office et les bibliothèques Excel dédiées telles que IronXL . Ce guide présente les deux méthodes à l'aide d'exemples de code C# fonctionnels, compare leurs avantages et inconvénients respectifs et explique dans quels cas chaque approche est pertinente pour les applications de production.

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.

Comparaison de Interopérabilité de Microsoft Office et IronXL pour l'exportation Excel en C#
Caractéristique Interopérabilité de 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ée 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 Paquet NuGet
Modèle de Threading Appartement monofilaire (STA) Opérations sûres 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 pris en charge 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 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 installer IronXL pour l'exportation Excel ?

L'installation IronXL via NuGet ne prend que quelques secondes. Aucun logiciel supplémentaire, installation d'Office ou configuration système n'est requis. La bibliothèque s'exécute immédiatement après son installation sous Windows, Linux et macOS, y compris sur Azure App Services, Azure Functions et les instances de conteneurs.

Ouvrez la console du gestionnaire de packages NuGet et exécutez :

Install-Package IronXL
dotnet add package IronXL
Install-Package IronXL
dotnet add package IronXL
SHELL

IronXL prend en charge .NET Framework 4.6.2+ et toutes les versions modernes de .NET jusqu'à .NET 10. Une fois installé, ajoutez using IronXL; en haut de votre fichier et vous êtes prêt à exporter.

Comment exporter un DataTable vers Excel en 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 pour l'interopérabilité

Avant d'utiliser Interop, vérifiez que :

  1. Microsoft Excel est installé sur les machines de développement et de déploiement.
  2. Une référence COM à la " bibliothèque d'objets Microsoft Excel " est ajoutée dans Visual Studio.
  3. L'espace de noms Microsoft.Office.Interop.Excel est inclus dans votre projet.

Code d'exportation interop

Le code suivant montre comment exporter un DataTable vers un fichier Excel en utilisant Interopérabilité de Microsoft Office en C# avec des instructions de niveau supérieur :

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));

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
};

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();
        }
    }

    string filePath = @"C:\Reports\EmployeeReport_Interop.xlsx";
    workbook.SaveAs(filePath);
    Console.WriteLine("Excel file created using Interop.");
}
catch (Exception ex)
{
    Console.WriteLine("Error: " + ex.Message);
}
finally
{
    // Always release COM objects to prevent orphaned Excel processes
    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;

// 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));

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
};

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();
        }
    }

    string filePath = @"C:\Reports\EmployeeReport_Interop.xlsx";
    workbook.SaveAs(filePath);
    Console.WriteLine("Excel file created using Interop.");
}
catch (Exception ex)
{
    Console.WriteLine("Error: " + ex.Message);
}
finally
{
    // Always release COM objects to prevent orphaned Excel processes
    workbook.Close();
    excelApp.Quit();
    Marshal.ReleaseComObject(worksheet);
    Marshal.ReleaseComObject(workbook);
    Marshal.ReleaseComObject(excelApp);
}
Imports Microsoft.Office.Interop.Excel
Imports System.Data
Imports System.Runtime.InteropServices

' Create a sample DataTable with employee data
Dim dt As New DataTable("Employees")
dt.Columns.Add("EmployeeID", GetType(Integer))
dt.Columns.Add("Name", GetType(String))
dt.Columns.Add("Department", GetType(String))
dt.Columns.Add("Salary", GetType(Decimal))

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
Dim excelApp As New Application With {
    .Visible = False,
    .DisplayAlerts = False
}

Dim workbook As Workbook = excelApp.Workbooks.Add()
Dim worksheet As Worksheet = CType(workbook.ActiveSheet, Worksheet)

Try
    ' Write column headers to the first row
    For i As Integer = 0 To dt.Columns.Count - 1
        worksheet.Cells(1, i + 1) = dt.Columns(i).ColumnName
    Next

    ' Write data rows starting from row 2
    For i As Integer = 0 To dt.Rows.Count - 1
        For j As Integer = 0 To dt.Columns.Count - 1
            worksheet.Cells(i + 2, j + 1) = dt.Rows(i)(j).ToString()
        Next
    Next

    Dim filePath As String = "C:\Reports\EmployeeReport_Interop.xlsx"
    workbook.SaveAs(filePath)
    Console.WriteLine("Excel file created using Interop.")
Catch ex As Exception
    Console.WriteLine("Error: " & ex.Message)
Finally
    ' Always release COM objects to prevent orphaned Excel processes
    workbook.Close()
    excelApp.Quit()
    Marshal.ReleaseComObject(worksheet)
    Marshal.ReleaseComObject(workbook)
    Marshal.ReleaseComObject(excelApp)
End Try
$vbLabelText   $csharpLabel

L'objet Application représente le processus Excel lui-même. Le paramètre Visible = false empêche Excel de s'ouvrir à 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.

Le bloc finally n'est pas facultatif -- il doit libérer chaque objet COM explicitement en utilisant Marshal.ReleaseComObject. Omettre cette étape laisse des processus Excel orphelins dans le Gestionnaire des tâches, consommant de la mémoire et finissant par déstabiliser le serveur. Ce modèle de nettoyage est un point faible bien connu qui rend l'interopérabilité inadaptée aux applications et services web.

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

IronXL offre une alternative moderne qui fonctionne sans aucune installation d'Office. Cette bibliothèque lit et écrit directement les fichiers Excel, ce qui la rend idéale pour les environnements serveur, les déploiements cloud et les applications multiplateformes. Consultez la documentation complète IronXL pour plus de détails sur l'API.

Code d'exportation IronXL

Le code suivant montre comment convertir un fichier DataTable en fichier Excel à l'aide de la bibliothèque IronXL et d'instructions de niveau supérieur :

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));

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
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Employees");

// Write column headers to row 0
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]);
    }
}

string filePath = @"C:\Reports\EmployeeReport_IronXL.xlsx";
workbook.SaveAs(filePath);
Console.WriteLine("Excel file created 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));

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
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Employees");

// Write column headers to row 0
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]);
    }
}

string filePath = @"C:\Reports\EmployeeReport_IronXL.xlsx";
workbook.SaveAs(filePath);
Console.WriteLine("Excel file created using IronXL.");
Imports IronXL
Imports System.Data

' Create a sample DataTable
Dim dt As New DataTable("Employees")
dt.Columns.Add("EmployeeID", GetType(Integer))
dt.Columns.Add("Name", GetType(String))
dt.Columns.Add("Department", GetType(String))
dt.Columns.Add("Salary", GetType(Decimal))

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
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim sheet As WorkSheet = workbook.CreateWorkSheet("Employees")

' Write column headers to row 0
For i As Integer = 0 To dt.Columns.Count - 1
    sheet.SetCellValue(0, i, dt.Columns(i).ColumnName)
Next

' Export DataTable rows to Excel cells
For i As Integer = 0 To dt.Rows.Count - 1
    For j As Integer = 0 To dt.Columns.Count - 1
        sheet.SetCellValue(i + 1, j, dt.Rows(i)(j))
    Next
Next

Dim filePath As String = "C:\Reports\EmployeeReport_IronXL.xlsx"
workbook.SaveAs(filePath)
Console.WriteLine("Excel file created using IronXL.")
$vbLabelText   $csharpLabel

L'approche IronXL suit une structure logique similaire, mais avec une syntaxe plus claire et sans complexité COM. 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. La bibliothèque prend également en charge le format XLS pour les systèmes anciens.

SetCellValue utilise des index basés sur 0 correspondant aux conventions .NET standard, ce qui réduit les erreurs de décalage d'une unité qui se produisent couramment lors de la conversion entre systèmes d'index. La méthode gère automatiquement la conversion de type : les valeurs entières, chaînes de caractères, décimales et DateTime sont écrites avec les types de cellules Excel appropriés.

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 ni de gestion du comptage des références COM.

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

Pour plus de détails sur la création de classeurs, consultez le guide de création de feuilles de calcul IronXL .

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 type de données (par exemple, DataTable) vers un fichier Excel. L'exemple suivant présente une fonction utilitaire qui encapsule la logique d'exportation, gère les valeurs nulles et crée automatiquement le répertoire de sortie s'il n'existe pas. Consultez la page d'exemples IronXL pour découvrir d'autres modèles.

Aide à l'exportation réutilisable IronXL

using IronXL;
using IronXl.Styles;
using System;
using System.Data;
using System.IO;

// --- ExcelExporter helper ---

bool ExportToExcel(DataTable dt, string filePath)
{
    if (dt == null || dt.Rows.Count == 0)
        return false;

    try
    {
        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet sheet = workbook.CreateWorkSheet(dt.TableName ?? "Sheet1");

        // Bold 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;
        }

        // Data rows
        for (int i = 0; i < dt.Rows.Count; i++)
        {
            for (int j = 0; j < dt.Columns.Count; j++)
            {
                var value = dt.Rows[i][j];
                sheet.SetCellValue(
                    i + 1, j,
                    (value == DBNull.Value || value == null) ? "" : value
                );
            }
        }

        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;
    }
}

// --- Usage ---

DataTable employees = new DataTable("Employees");
employees.Columns.Add("EmployeeID", typeof(int));
employees.Columns.Add("Name", typeof(string));
employees.Columns.Add("Department", typeof(string));
employees.Rows.Add(1, "John Smith", "Engineering");
employees.Rows.Add(2, "Sarah Johnson", "Marketing");

bool success = ExportToExcel(employees, @"C:\Reports\Export.xlsx");
Console.WriteLine(success ? "Export completed." : "Export failed.");
using IronXL;
using IronXl.Styles;
using System;
using System.Data;
using System.IO;

// --- ExcelExporter helper ---

bool ExportToExcel(DataTable dt, string filePath)
{
    if (dt == null || dt.Rows.Count == 0)
        return false;

    try
    {
        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet sheet = workbook.CreateWorkSheet(dt.TableName ?? "Sheet1");

        // Bold 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;
        }

        // Data rows
        for (int i = 0; i < dt.Rows.Count; i++)
        {
            for (int j = 0; j < dt.Columns.Count; j++)
            {
                var value = dt.Rows[i][j];
                sheet.SetCellValue(
                    i + 1, j,
                    (value == DBNull.Value || value == null) ? "" : value
                );
            }
        }

        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;
    }
}

// --- Usage ---

DataTable employees = new DataTable("Employees");
employees.Columns.Add("EmployeeID", typeof(int));
employees.Columns.Add("Name", typeof(string));
employees.Columns.Add("Department", typeof(string));
employees.Rows.Add(1, "John Smith", "Engineering");
employees.Rows.Add(2, "Sarah Johnson", "Marketing");

bool success = ExportToExcel(employees, @"C:\Reports\Export.xlsx");
Console.WriteLine(success ? "Export completed." : "Export failed.");
Imports IronXL
Imports IronXl.Styles
Imports System
Imports System.Data
Imports System.IO

' --- ExcelExporter helper ---

Function ExportToExcel(dt As DataTable, filePath As String) As Boolean
    If dt Is Nothing OrElse dt.Rows.Count = 0 Then
        Return False
    End If

    Try
        Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
        Dim sheet As WorkSheet = workbook.CreateWorkSheet(If(dt.TableName, "Sheet1"))

        ' Bold headers in the first row
        For i As Integer = 0 To dt.Columns.Count - 1
            Dim cell = sheet.GetCellAt(0, i)
            cell.Value = dt.Columns(i).ColumnName
            cell.Style.Font.Bold = True
        Next

        ' Data rows
        For i As Integer = 0 To dt.Rows.Count - 1
            For j As Integer = 0 To dt.Columns.Count - 1
                Dim value = dt.Rows(i)(j)
                sheet.SetCellValue(i + 1, j, If(value Is DBNull.Value OrElse value Is Nothing, "", value))
            Next
        Next

        Dim fileInfo As New FileInfo(filePath)
        If Not fileInfo.Directory.Exists Then
            fileInfo.Directory.Create()
        End If

        workbook.SaveAs(filePath)
        Return True
    Catch ex As Exception
        Console.WriteLine("Export failed: " & ex.Message)
        Return False
    End Try
End Function

' --- Usage ---

Dim employees As New DataTable("Employees")
employees.Columns.Add("EmployeeID", GetType(Integer))
employees.Columns.Add("Name", GetType(String))
employees.Columns.Add("Department", GetType(String))
employees.Rows.Add(1, "John Smith", "Engineering")
employees.Rows.Add(2, "Sarah Johnson", "Marketing")

Dim success As Boolean = ExportToExcel(employees, "C:\Reports\Export.xlsx")
Console.WriteLine(If(success, "Export completed.", "Export failed."))
$vbLabelText   $csharpLabel

L'assistant ExportToExcel accepte tout DataTable et une chaîne de chemin de fichier, renvoyant false si l'exportation échoue ou si la table est vide. Il gère les valeurs manquantes avec élégance en vérifiant la présence de DBNull.Value avant d'écrire les cellules. L'étape de création de répertoire empêche DirectoryNotFoundException de perturber les exportations planifiées vers de nouveaux chemins de dossiers -- un problème de production courant lors du déploiement dans de nouveaux environnements.

Les titres en gras sont appliqués à l'aide de cell.Style.Font.Bold = true, ce qui produit un résultat d'aspect professionnel sans configuration supplémentaire. Ce modèle est facile à étendre : ajoutez des couleurs de fond, des bordures ou un ajustement automatique de la largeur des colonnes pour correspondre aux normes de reporting de votre organisation.

Pour travailler avec de grands ensembles de données, le guide de performance IronXL couvre les stratégies d'écriture en masse qui minimisent l'allocation de mémoire. La bibliothèque prend également en charge l'exportation d'un DataSet -- une collection d'objets DataTable associés -- vers plusieurs feuilles de calcul dans un seul classeur, ce qui est utile pour les rapports à plusieurs feuilles.

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

Les exportations Excel Professional 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 en termes de verbosité et de fiabilité.

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 headers with light blue background and bold font
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;
    cell.Style.SetBackgroundColor("#ADD8E6");
    cell.Style.BottomBorder.SetColor("#000000");
    cell.Style.BottomBorder.Type = BorderType.Thin;
}

// Write data rows
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]);
    }
}

workbook.SaveAs(@"C:\Reports\FormattedReport_IronXL.xlsx");
Console.WriteLine("Formatted Excel file created.");
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 headers with light blue background and bold font
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;
    cell.Style.SetBackgroundColor("#ADD8E6");
    cell.Style.BottomBorder.SetColor("#000000");
    cell.Style.BottomBorder.Type = BorderType.Thin;
}

// Write data rows
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]);
    }
}

workbook.SaveAs(@"C:\Reports\FormattedReport_IronXL.xlsx");
Console.WriteLine("Formatted Excel file created.");
Imports IronXL
Imports IronXl.Styles
Imports System.Data

Dim dt As New DataTable("Sales")
dt.Columns.Add("Product", GetType(String))
dt.Columns.Add("Revenue", GetType(Decimal))
dt.Rows.Add("Widget A", 15000.50D)
dt.Rows.Add("Widget B", 22500.75D)

Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim sheet As WorkSheet = workbook.CreateWorkSheet("Sales")

' Write headers with light blue background and bold font
For i As Integer = 0 To dt.Columns.Count - 1
    Dim 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
Next

' Write data rows
For i As Integer = 0 To dt.Rows.Count - 1
    For j As Integer = 0 To dt.Columns.Count - 1
        sheet.SetCellValue(i + 1, j, dt.Rows(i)(j))
    Next
Next

workbook.SaveAs("C:\Reports\FormattedReport_IronXL.xlsx")
Console.WriteLine("Formatted Excel file created.")
$vbLabelText   $csharpLabel

L'API de style d'IronXL utilise un modèle objet propre. Les valeurs de couleur acceptent les codes hexadécimaux standard tels que #ADD8E6 (bleu clair), ce qui simplifie l'harmonisation avec l'image de marque de l'entreprise sans conversion entre les systèmes de couleurs. BorderType.Thin et BorderType.Thick couvrent les scénarios de frontière standard sans nécessiter de recherches d'énumération.

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

Pour toutes les options de style, y compris les formats numériques, la mise en forme conditionnelle et la fusion de cellules, consultez le guide de style de cellule IronXL et la documentation sur les bordures et l'alignement .

Complexité du formatage interop

L'équivalent Interop accède aux objets individuels Range et définit des propriétés comme Font.Bold, Interior.Color et Borders.LineStyle. Chaque accès à une propriété est un appel interprocessus COM, ce qui engendre une surcharge et augmente le risque d'exceptions si Excel ne répond plus. Les valeurs de couleur nécessitent une conversion (System.Drawing.ColorTranslator.ToOle), et chaque bloc de style doit être suivi de la chaîne de nettoyage COM standard (au minimum trois appels Marshal.ReleaseComObject).

Cette verbosité devient problématique lorsqu'il s'agit d'appliquer une mise en forme conditionnelle, des largeurs de colonnes ou des formats numériques à de grandes feuilles de calcul. IronXL gère les mêmes scénarios avec moins de lignes de code et sans risque de laisser des processus Excel actifs après un plantage.

Quelles sont les meilleures pratiques pour l'exportation Excel en .NET?

L'adoption de pratiques cohérentes pour toutes les routines d'exportation réduit les bogues, améliore la maintenabilité et facilite le test et le déploiement de votre code.

Conventions de nommage et de chemin

Utilisez une convention de nommage cohérente pour les fichiers exportés : {ReportName}_{Timestamp}.xlsx. Des noms de fichiers prévisibles simplifient le nettoyage et l'archivage automatisés. Stockez le répertoire de sortie dans la configuration de l'application plutôt que de coder en dur les chemins -- cela évite DirectoryNotFoundException lors du déploiement dans de nouveaux environnements.

Gestion des erreurs

Encapsulez toute la logique d'exportation dans des blocs try-catch et consignez les exceptions avec suffisamment de contexte pour diagnostiquer l'échec. Pour les exportations planifiées, envisagez de renvoyer un objet résultat plutôt que de lever des exceptions, afin que le service appelant puisse réessayer ou alerter les opérateurs sans planter. L'assistant ExportToExcel ci-dessus illustre ce modèle avec une valeur de retour bool.

Gestion de Grands Jeux de Données

Pour les ensembles de données comportant plus de 50 000 lignes, traitez les données par lots afin d'éviter la saturation de la mémoire. IronXL prend en charge l'écriture progressive, et le SDK OpenXML offre un flux de bas niveau pour les fichiers très volumineux. Évitez complètement Interop pour les grands ensembles de données : son modèle en mémoire entraîne des ralentissements importants à grande échelle.

Déploiement multiplateforme

Si l'application s'exécute sous Linux ou macOS (par exemple dans des conteneurs Docker ou Azure Linux App Services), IronXL est la seule option viable. L'interopérabilité n'est pas possible en dehors de Windows car elle dépend du serveur COM d'Excel. Utilisez le guide de déploiement multiplateforme .NET pour vérifier que toutes les dépendances sont disponibles sur l'environnement d'exécution cible.

Essai

Les tests unitaires de la logique d'exportation doivent vérifier que le fichier de sortie existe, qu'il contient le nombre de lignes attendu et qu'il utilise les noms de colonnes corrects. La méthode WorkBook.Load d'IronXL permet de relire facilement les fichiers exportés dans les tests sans lancer Excel. Consultez le guide de lecture IronXL pour des exemples.

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.

Choisissez Microsoft Office Excel Interop lorsque :

  • Travailler avec des systèmes existants qui reposent déjà sur l'interopérabilité et la migration n'est pas envisageable.
  • Les fonctionnalités avancées d'Excel, telles que les macros, les tableaux croisés dynamiques ou l'automatisation des graphiques, nécessitent le modèle objet complet de l'application Excel.
  • Développement 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à en place.
  • Automatisation des modèles Excel existants contenant des formules complexes intégrées 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 avec .NET Framework 4.6.2+ ou des versions .NET modernes où la prise en charge de l'interopérabilité est limitée.
  • Besoin d'une gestion des ressources fiable sans soucis de nettoyage COM.
  • Éviter la dépendance des licences Office aux serveurs de production.
  • Développement d'applications multi-locataires nécessitant la génération de fichiers Excel isolés.
  • 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.

Explorez les tutoriels IronXL pour découvrir d'autres scénarios, notamment la lecture de fichiers Excel existants , l'utilisation de formules et la gestion de plusieurs feuilles de calcul .

Quelles sont vos prochaines étapes ?

L'exportation d'un DataTable vers un fichier Excel est une exigence fondamentale pour les applications .NET qui traitent des données commerciales. Que la source soit une requête de base de données, un DataSet avec plusieurs tables liées ou une collection en mémoire construite dynamiquement, le bon choix de bibliothèque détermine la flexibilité de déploiement et la maintenabilité à long terme.

L'interopérabilité Microsoft Office Excel a servi les développeurs pendant des années, mais 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 la rendent de plus en plus impraticable pour le développement d'applications modernes.

IronXL propose une alternative plus propre qui remédie à ces limitations. Grâce à une installation NuGet simple, une prise en charge multiplateforme couvrant Windows, Linux et macOS, et des API simples qui suivent les conventions .NET , 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.

Pour commencer, installez IronXL à partir de NuGet, copiez l'un des exemples de code ci-dessus et exécutez une exportation rapide à partir d'un test DataTable. Le guide de démarrage rapide IronXL couvre les scénarios les plus courants en quelques minutes. Lorsque vous serez prêt pour la production, consultez la page des licences IronXL pour trouver l'option qui correspond à la taille de votre équipe et à votre modèle de déploiement. Pour approfondir vos connaissances, consultez la documentation complète de l'API IronXL et le dépôt GitHub IronXL pour des exemples de la communauté.

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

Équipe de soutien Iron

Nous sommes en ligne 24 heures sur 24, 5 jours sur 7.
Chat
Email
Appelez-moi