Icône de message
Passer au contenu du pied de page
  1. Iron Software
  2. Blog IronXL
  3. Utilisation d'IronXL
  4. Exporter une table de données à l'aide d'OLEDB
UTILISATION D'IRONXL

Exporter un DataTable vers Excel en C# en utilisant OleDb ou IronXL

Jordi Bardia
Jordi Bardia
Mis à jour:

L'exportation d'un DataTable vers un fichier Excel en C# — sans aucune dépendance à Office — est simple avec la bibliothèque appropriée. Vous appelez WorkBook.Create(), écrivez les en-têtes à partir de dataTable.Columns, parcourez dataTable.Rows pour remplir les cellules, puis enregistrez avec workbook.SaveAs("output.xlsx"). Le résultat est un fichier XLSX entièrement formaté qui fonctionne sur n'importe quelle plateforme, y compris .NET 10, les conteneurs Linux et les fonctions sans serveur Azure.

Ce guide compare l'approche OleDb traditionnelle avec la méthode moderne IronXL for .NET . Vous découvrirez pourquoi le pilote OleDb crée des problèmes de déploiement et de compatibilité, et comment le remplacer par un code propre et maintenable qui gère les en-têtes de colonnes, les types de données, la mise en forme des cellules et les grands ensembles de données sans syntaxe SQL ni installation de pilote réservée à Windows.

Comment installer IronXL pour l'exportation de DataTable ?

Avant d'écrire le moindre code d'exportation, ajoutez IronXL à votre projet. Ouvrez la console du Package Manager dans Visual Studio et exécutez :

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

IronXL ne dépend d'aucune technologie Microsoft Office, du moteur de base de données Access ou d'une quelconque couche d'interopérabilité COM. Une fois le package installé, vous pouvez exécuter le même code sur Windows, Linux, macOS, Docker, Azure et AWS sans modifier une seule ligne.

Pourquoi OleDb nécessite l'installation d'un pilote

L'approche traditionnelle d'OleDb considère un fichier Excel comme une base de données. Vous établissez un OleDbConnection en utilisant le fournisseur Microsoft.ACE.OLEDB.12.0 (ou l'ancien Microsoft.Jet.OLEDB.4.0 pour les fichiers .xls), puis exécutez les commandes SQL CREATE TABLE et INSERT INTO sur la feuille de calcul. Cela fonctionne sur les machines de développement où Microsoft Office ou le moteur de base de données Access autonome redistribuable est déjà installé. Cependant, les environnements de production, notamment les fonctions cloud, les conteneurs Docker et les fermes de serveurs exécutant .NET 10 sans interface graphique, disposent rarement de ce pilote, et son installation nécessite des privilèges élevés et une correspondance de bits entre le pilote et votre processus.

Pourquoi les développeurs utilisent-ils encore OleDb pour les exportations Excel ?

OleDb est devenu un choix par défaut pour l'automatisation d'Excel car il faisait déjà partie du .NET Framework. Les développeurs connaissaient déjà ADO .NET, donc réutiliser OleDbConnection, OleDbCommand et OleDbDataAdapter pour écrire dans Excel semblait naturel. Aucun package tiers n'était nécessaire, et la syntaxe de type SQL pour CREATE TABLE et INSERT INTO rendait l'intention évidente pour toute personne familière avec la programmation de bases de données.

Voici le modèle traditionnel pour exporter une DataTable à l'aide d'OleDb :

using System.Data;
using System.Data.OleDb;

// Build a sample DataTable
DataTable dataTable = new DataTable("Products");
dataTable.Columns.Add("ProductID", typeof(int));
dataTable.Columns.Add("ProductName", typeof(string));
dataTable.Columns.Add("Price", typeof(decimal));
dataTable.Rows.Add(1, "Widget", 29.99m);
dataTable.Rows.Add(2, "Gadget", 49.99m);
dataTable.Rows.Add(3, "Gizmo", 19.99m);

// OleDb connection string -- file must already exist on disk
string filename = @"C:\Output\Products.xlsx";
string connectionString =
    $"Provider=Microsoft.ACE.OLEDB.12.0;Data Source={filename};" +
    "Extended Properties='Excel 12.0 Xml;HDR=YES'";

using OleDbConnection connection = new(connectionString);
connection.Open();

// Create the sheet structure with SQL DDL
string create = "CREATE TABLE [Sheet1$] (ProductID INT, ProductName CHAR(255), Price DOUBLE)";
using (var createCmd = new OleDbCommand(create, connection))
    createCmd.ExecuteNonQuery();

// Insert rows one at a time
string insert = "INSERT INTO [Sheet1$] (ProductID, ProductName, Price) VALUES (?, ?, ?)";
using OleDbCommand insertCmd = new(insert, connection);
insertCmd.Parameters.Add(new OleDbParameter("ProductID", OleDbType.Integer));
insertCmd.Parameters.Add(new OleDbParameter("ProductName", OleDbType.VarChar, 255));
insertCmd.Parameters.Add(new OleDbParameter("Price", OleDbType.Double));

foreach (DataRow row in dataTable.Rows)
{
    insertCmd.Parameters[0].Value = row["ProductID"];
    insertCmd.Parameters[1].Value = row["ProductName"];
    insertCmd.Parameters[2].Value = row["Price"];
    insertCmd.ExecuteNonQuery();
}
using System.Data;
using System.Data.OleDb;

// Build a sample DataTable
DataTable dataTable = new DataTable("Products");
dataTable.Columns.Add("ProductID", typeof(int));
dataTable.Columns.Add("ProductName", typeof(string));
dataTable.Columns.Add("Price", typeof(decimal));
dataTable.Rows.Add(1, "Widget", 29.99m);
dataTable.Rows.Add(2, "Gadget", 49.99m);
dataTable.Rows.Add(3, "Gizmo", 19.99m);

// OleDb connection string -- file must already exist on disk
string filename = @"C:\Output\Products.xlsx";
string connectionString =
    $"Provider=Microsoft.ACE.OLEDB.12.0;Data Source={filename};" +
    "Extended Properties='Excel 12.0 Xml;HDR=YES'";

using OleDbConnection connection = new(connectionString);
connection.Open();

// Create the sheet structure with SQL DDL
string create = "CREATE TABLE [Sheet1$] (ProductID INT, ProductName CHAR(255), Price DOUBLE)";
using (var createCmd = new OleDbCommand(create, connection))
    createCmd.ExecuteNonQuery();

// Insert rows one at a time
string insert = "INSERT INTO [Sheet1$] (ProductID, ProductName, Price) VALUES (?, ?, ?)";
using OleDbCommand insertCmd = new(insert, connection);
insertCmd.Parameters.Add(new OleDbParameter("ProductID", OleDbType.Integer));
insertCmd.Parameters.Add(new OleDbParameter("ProductName", OleDbType.VarChar, 255));
insertCmd.Parameters.Add(new OleDbParameter("Price", OleDbType.Double));

foreach (DataRow row in dataTable.Rows)
{
    insertCmd.Parameters[0].Value = row["ProductID"];
    insertCmd.Parameters[1].Value = row["ProductName"];
    insertCmd.Parameters[2].Value = row["Price"];
    insertCmd.ExecuteNonQuery();
}
Imports System.Data
Imports System.Data.OleDb

' Build a sample DataTable
Dim dataTable As New DataTable("Products")
dataTable.Columns.Add("ProductID", GetType(Integer))
dataTable.Columns.Add("ProductName", GetType(String))
dataTable.Columns.Add("Price", GetType(Decimal))
dataTable.Rows.Add(1, "Widget", 29.99D)
dataTable.Rows.Add(2, "Gadget", 49.99D)
dataTable.Rows.Add(3, "Gizmo", 19.99D)

' OleDb connection string -- file must already exist on disk
Dim filename As String = "C:\Output\Products.xlsx"
Dim connectionString As String = $"Provider=Microsoft.ACE.OLEDB.12.0;Data Source={filename};" &
                                 "Extended Properties='Excel 12.0 Xml;HDR=YES'"

Using connection As New OleDbConnection(connectionString)
    connection.Open()

    ' Create the sheet structure with SQL DDL
    Dim create As String = "CREATE TABLE [Sheet1$] (ProductID INT, ProductName CHAR(255), Price DOUBLE)"
    Using createCmd As New OleDbCommand(create, connection)
        createCmd.ExecuteNonQuery()
    End Using

    ' Insert rows one at a time
    Dim insert As String = "INSERT INTO [Sheet1$] (ProductID, ProductName, Price) VALUES (?, ?, ?)"
    Using insertCmd As New OleDbCommand(insert, connection)
        insertCmd.Parameters.Add(New OleDbParameter("ProductID", OleDbType.Integer))
        insertCmd.Parameters.Add(New OleDbParameter("ProductName", OleDbType.VarChar, 255))
        insertCmd.Parameters.Add(New OleDbParameter("Price", OleDbType.Double))

        For Each row As DataRow In dataTable.Rows
            insertCmd.Parameters(0).Value = row("ProductID")
            insertCmd.Parameters(1).Value = row("ProductName")
            insertCmd.Parameters(2).Value = row("Price")
            insertCmd.ExecuteNonQuery()
        Next
    End Using
End Using
$vbLabelText   $csharpLabel

Ce code insère chaque DataRow en effectuant un aller-retour distinct à la base de données. Pour les grands ensembles de données, cette boucle devient un goulot d'étranglement car OleDb ne propose aucun mécanisme d'insertion par lots. Chaque ligne déclenche un cycle complet d'analyse SQL, de liaison des paramètres et d'écriture avant de passer à la suivante.

Quelles sont les principales limitations d'OLEDB pour l'exportation Excel ?

Comprendre pourquoi OleDb présente des lacunes vous aide à justifier la migration auprès de votre équipe et à choisir le bon remplaçant.

Dépendances des pilotes et conflits de bits

Le fournisseur Microsoft.ACE.OLEDB.12.0 doit être installé séparément sur chaque machine qui exécute votre application. Si votre processus est en 64 bits mais que seul le moteur de base de données Access 32 bits est disponible (une configuration courante lorsque Microsoft Office 32 bits est installé en parallèle d'un environnement d'exécution .NET 64 bits), la connexion génère une exception à l'exécution. Microsoft documente ces limitations de compatibilité et recommande d'utiliser une architecture identique pour le pilote et le processus appelant, mais cela s'avère souvent difficile à mettre en œuvre dans les environnements mutualisés ou conteneurisés.

Aucune prise en charge multiplateforme

OleDb est une technologie exclusivement compatible avec Windows. .NET 10 prend en charge nativement Linux et macOS, et les architectures modernes exécutent de plus en plus les charges de travail applicatives dans des conteneurs Docker sur des nœuds Linux. Étant donné que l'espace de noms System.Data.OleDb génère une erreur PlatformNotSupportedException sur les systèmes d'exploitation non Windows, tout chemin de code utilisant OleDb est totalement bloqué sur ces plateformes.

Aucune possibilité de mise en forme des cellules

OleDb traite la feuille de calcul comme une table de base de données plate. Vous pouvez insérer des valeurs brutes, mais vous ne disposez d'aucun mécanisme pour appliquer des polices de cellules, des couleurs d'arrière-plan, des bordures, des formats numériques ou des largeurs de colonnes. Si votre exportation nécessite un rapport d'aspect professionnel avec une mise en forme des en-têtes de lignes, un formatage des devises ou une coloration conditionnelle, OleDb ne peut pas vous le fournir. Il vous faudrait une deuxième passe avec une bibliothèque différente ou l'objet COM Excel Interop, qui ajoute sa propre dépendance à Office.

Le fichier Excel doit déjà exister.

OleDb ne peut pas créer un nouveau classeur Excel à partir de zéro. Le fichier doit déjà exister à l'emplacement cible avant d'ouvrir la connexion. Cela nécessite soit un fichier modèle pré-rempli, soit une étape distincte pour créer le classeur à l'aide d'une autre bibliothèque, ce qui ajoute une complexité inutile au package de déploiement.

Les opérations de suppression ne sont pas prises en charge.

Le pilote OleDb pour Excel prend en charge INSERT et des opérations UPDATE limitées, mais la suppression de lignes à l'aide de DELETE FROM n'est pas prise en charge. Tout flux de travail de manipulation de données nécessitant la suppression de lignes après l'exportation doit recourir à une manipulation manuelle des fichiers ou à une recréation complète du fichier, deux opérations qui ne sont pas simples via l'interface OleDb.

Comment exporter un DataTable vers Excel avec IronXL?

IronXL remplace l'intégralité du pipeline OleDb par un modèle objet direct. Il n'y a pas de chaînes de connexion, pas de commandes SQL et aucune exigence de pilote. Vous créez un WorkBook, ajoutez un WorkSheet, et appelez SetCellValue() pour chaque cellule :

using IronXL;
using System.Data;

// Build the same DataTable
DataTable dataTable = new DataTable("Products");
dataTable.Columns.Add("ProductID", typeof(int));
dataTable.Columns.Add("ProductName", typeof(string));
dataTable.Columns.Add("Price", typeof(decimal));
dataTable.Rows.Add(1, "Widget", 29.99m);
dataTable.Rows.Add(2, "Gadget", 49.99m);
dataTable.Rows.Add(3, "Gizmo", 19.99m);

// Create a new workbook and worksheet -- no template file needed
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("Products");

// Write column headers into the first row
for (int col = 0; col < dataTable.Columns.Count; col++)
{
    worksheet.SetCellValue(0, col, dataTable.Columns[col].ColumnName);
}

// Write data rows
for (int row = 0; row < dataTable.Rows.Count; row++)
{
    for (int col = 0; col < dataTable.Columns.Count; col++)
    {
        worksheet.SetCellValue(row + 1, col, dataTable.Rows[row][col].ToString());
    }
}

workbook.SaveAs("Products.xlsx");
using IronXL;
using System.Data;

// Build the same DataTable
DataTable dataTable = new DataTable("Products");
dataTable.Columns.Add("ProductID", typeof(int));
dataTable.Columns.Add("ProductName", typeof(string));
dataTable.Columns.Add("Price", typeof(decimal));
dataTable.Rows.Add(1, "Widget", 29.99m);
dataTable.Rows.Add(2, "Gadget", 49.99m);
dataTable.Rows.Add(3, "Gizmo", 19.99m);

// Create a new workbook and worksheet -- no template file needed
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("Products");

// Write column headers into the first row
for (int col = 0; col < dataTable.Columns.Count; col++)
{
    worksheet.SetCellValue(0, col, dataTable.Columns[col].ColumnName);
}

// Write data rows
for (int row = 0; row < dataTable.Rows.Count; row++)
{
    for (int col = 0; col < dataTable.Columns.Count; col++)
    {
        worksheet.SetCellValue(row + 1, col, dataTable.Rows[row][col].ToString());
    }
}

workbook.SaveAs("Products.xlsx");
Imports IronXL
Imports System.Data

' Build the same DataTable
Dim dataTable As New DataTable("Products")
dataTable.Columns.Add("ProductID", GetType(Integer))
dataTable.Columns.Add("ProductName", GetType(String))
dataTable.Columns.Add("Price", GetType(Decimal))
dataTable.Rows.Add(1, "Widget", 29.99D)
dataTable.Rows.Add(2, "Gadget", 49.99D)
dataTable.Rows.Add(3, "Gizmo", 19.99D)

' Create a new workbook and worksheet -- no template file needed
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Products")

' Write column headers into the first row
For col As Integer = 0 To dataTable.Columns.Count - 1
    worksheet.SetCellValue(0, col, dataTable.Columns(col).ColumnName)
Next

' Write data rows
For row As Integer = 0 To dataTable.Rows.Count - 1
    For col As Integer = 0 To dataTable.Columns.Count - 1
        worksheet.SetCellValue(row + 1, col, dataTable.Rows(row)(col).ToString())
    Next
Next

workbook.SaveAs("Products.xlsx")
$vbLabelText   $csharpLabel

WorkBook.Create(ExcelFileFormat.XLSX) construit un nouveau classeur en mémoire -- aucun fichier n'a besoin d'exister au préalable. CreateWorkSheet("Products") ajoute un onglet nommé. Les boucles imbriquées reproduisent exactement le nombre de lignes et de colonnes du tableau de données, en écrivant une valeur par cellule. SaveAs() enregistre le classeur sur le disque en tant que fichier XLSX entièrement valide.

Sortie

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

Pour un examen plus approfondi des options disponibles, le guide pratique d'exportation des DataSet et DataTable couvre des surcharges supplémentaires et des modèles d'exportation par lots.

Comment ajouter une mise en forme aux cellules lors de l'exportation d'un tableau de données ?

L'une des exigences les plus courantes après une exportation de base consiste à styliser la ligne d'en-tête pour la distinguer des lignes de données. IronXL propose une API de style complète qu'OleDb ne peut égaler :

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

DataTable dataTable = new DataTable("Products");
dataTable.Columns.Add("ProductID", typeof(int));
dataTable.Columns.Add("ProductName", typeof(string));
dataTable.Columns.Add("Price", typeof(decimal));
dataTable.Rows.Add(1, "Widget", 29.99m);
dataTable.Rows.Add(2, "Gadget", 49.99m);
dataTable.Rows.Add(3, "Gizmo", 19.99m);

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("Products");

// Write and style the header row
for (int col = 0; col < dataTable.Columns.Count; col++)
{
    var headerCell = worksheet[$"{(char)('A' + col)}1"];
    headerCell.Value = dataTable.Columns[col].ColumnName;
    headerCell.Style.Font.Bold = true;
    headerCell.Style.BackgroundColor = "#4472C4";
    headerCell.Style.Font.FontColor = "#FFFFFF";
}

// Write data rows with price column formatted as currency
for (int row = 0; row < dataTable.Rows.Count; row++)
{
    for (int col = 0; col < dataTable.Columns.Count; col++)
    {
        var cell = worksheet[$"{(char)('A' + col)}{row + 2}"];
        cell.Value = dataTable.Rows[row][col].ToString();

        // Apply currency format to the Price column
        if (dataTable.Columns[col].ColumnName == "Price")
            cell.FormatString = "$#,##0.00";
    }
}

// Auto-size columns so content is not clipped
worksheet.AutoSizeColumn(0);
worksheet.AutoSizeColumn(1);
worksheet.AutoSizeColumn(2);

workbook.SaveAs("ProductsStyled.xlsx");
using IronXL;
using IronXl.Styles;
using System.Data;

DataTable dataTable = new DataTable("Products");
dataTable.Columns.Add("ProductID", typeof(int));
dataTable.Columns.Add("ProductName", typeof(string));
dataTable.Columns.Add("Price", typeof(decimal));
dataTable.Rows.Add(1, "Widget", 29.99m);
dataTable.Rows.Add(2, "Gadget", 49.99m);
dataTable.Rows.Add(3, "Gizmo", 19.99m);

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("Products");

// Write and style the header row
for (int col = 0; col < dataTable.Columns.Count; col++)
{
    var headerCell = worksheet[$"{(char)('A' + col)}1"];
    headerCell.Value = dataTable.Columns[col].ColumnName;
    headerCell.Style.Font.Bold = true;
    headerCell.Style.BackgroundColor = "#4472C4";
    headerCell.Style.Font.FontColor = "#FFFFFF";
}

// Write data rows with price column formatted as currency
for (int row = 0; row < dataTable.Rows.Count; row++)
{
    for (int col = 0; col < dataTable.Columns.Count; col++)
    {
        var cell = worksheet[$"{(char)('A' + col)}{row + 2}"];
        cell.Value = dataTable.Rows[row][col].ToString();

        // Apply currency format to the Price column
        if (dataTable.Columns[col].ColumnName == "Price")
            cell.FormatString = "$#,##0.00";
    }
}

// Auto-size columns so content is not clipped
worksheet.AutoSizeColumn(0);
worksheet.AutoSizeColumn(1);
worksheet.AutoSizeColumn(2);

workbook.SaveAs("ProductsStyled.xlsx");
Imports IronXL
Imports IronXl.Styles
Imports System.Data

Dim dataTable As New DataTable("Products")
dataTable.Columns.Add("ProductID", GetType(Integer))
dataTable.Columns.Add("ProductName", GetType(String))
dataTable.Columns.Add("Price", GetType(Decimal))
dataTable.Rows.Add(1, "Widget", 29.99D)
dataTable.Rows.Add(2, "Gadget", 49.99D)
dataTable.Rows.Add(3, "Gizmo", 19.99D)

Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Products")

' Write and style the header row
For col As Integer = 0 To dataTable.Columns.Count - 1
    Dim headerCell = worksheet($"{ChrW(AscW("A"c) + col)}1")
    headerCell.Value = dataTable.Columns(col).ColumnName
    headerCell.Style.Font.Bold = True
    headerCell.Style.BackgroundColor = "#4472C4"
    headerCell.Style.Font.FontColor = "#FFFFFF"
Next

' Write data rows with price column formatted as currency
For row As Integer = 0 To dataTable.Rows.Count - 1
    For col As Integer = 0 To dataTable.Columns.Count - 1
        Dim cell = worksheet($"{ChrW(AscW("A"c) + col)}{row + 2}")
        cell.Value = dataTable.Rows(row)(col).ToString()

        ' Apply currency format to the Price column
        If dataTable.Columns(col).ColumnName = "Price" Then
            cell.FormatString = "$#,##0.00"
        End If
    Next
Next

' Auto-size columns so content is not clipped
worksheet.AutoSizeColumn(0)
worksheet.AutoSizeColumn(1)
worksheet.AutoSizeColumn(2)

workbook.SaveAs("ProductsStyled.xlsx")
$vbLabelText   $csharpLabel

Cela génère un fichier avec une ligne d'en-tête bleue, un texte d'en-tête blanc et des valeurs de prix affichées avec un signe dollar et deux décimales. Le guide des tailles de police des cellules ainsi que les références relatives aux bordures et à l'alignement expliquent l'ensemble des options de style disponibles.

Gestion des exportations de DataTables volumineuses

Pour les ensembles de données comportant des milliers de lignes, la performance est importante. IronXL écrit toutes les valeurs de cellule en mémoire avant une seule écriture sur disque à SaveAs(), ce qui est beaucoup plus efficace que le modèle OleDb d'une ExecuteNonQuery() par ligne. Si vous devez exporter des tableaux très volumineux, le guide sur la méthode la plus rapide pour exporter des DataTables vers Excel présente des techniques de flux économes en mémoire.

Vous pouvez également regrouper la logique d'exportation avec des formules, des plages et des tableaux nommés. Le guide " Créer une feuille de calcul et écrire du code Excel en .NET " fournit des modèles complets pour la création de classeurs à plusieurs feuilles à partir de DataTables.

Comment exporter un DataTable vers Excel en ASP.NET?

Dans une application web, on diffuse généralement le classeur directement dans le navigateur plutôt que de l'enregistrer sur le disque. IronXL prend en charge cette fonctionnalité avec workbook.ToByteArray(), qui renvoie le contenu binaire que vous pouvez écrire dans une réponse HTTP :

// In an ASP.NET controller action
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("Report");

// Assume dataTable is populated from your data source
for (int col = 0; col < dataTable.Columns.Count; col++)
    worksheet.SetCellValue(0, col, dataTable.Columns[col].ColumnName);

for (int row = 0; row < dataTable.Rows.Count; row++)
    for (int col = 0; col < dataTable.Columns.Count; col++)
        worksheet.SetCellValue(row + 1, col, dataTable.Rows[row][col].ToString());

byte[] fileBytes = workbook.ToByteArray();
return File(fileBytes, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "Report.xlsx");
// In an ASP.NET controller action
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("Report");

// Assume dataTable is populated from your data source
for (int col = 0; col < dataTable.Columns.Count; col++)
    worksheet.SetCellValue(0, col, dataTable.Columns[col].ColumnName);

for (int row = 0; row < dataTable.Rows.Count; row++)
    for (int col = 0; col < dataTable.Columns.Count; col++)
        worksheet.SetCellValue(row + 1, col, dataTable.Rows[row][col].ToString());

byte[] fileBytes = workbook.ToByteArray();
return File(fileBytes, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "Report.xlsx");
' In an ASP.NET controller action
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Report")

' Assume dataTable is populated from your data source
For col As Integer = 0 To dataTable.Columns.Count - 1
    worksheet.SetCellValue(0, col, dataTable.Columns(col).ColumnName)
Next

For row As Integer = 0 To dataTable.Rows.Count - 1
    For col As Integer = 0 To dataTable.Columns.Count - 1
        worksheet.SetCellValue(row + 1, col, dataTable.Rows(row)(col).ToString())
    Next
Next

Dim fileBytes As Byte() = workbook.ToByteArray()
Return File(fileBytes, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "Report.xlsx")
$vbLabelText   $csharpLabel

Le tutoriel " Exporter des données DataTable vers Excel ASP.NET " décrit en détail le câblage complet des contrôleurs et des vues pour une application ASP.NET . Le guide DataTable vers Excel C# couvre des scénarios supplémentaires, notamment les exportations multi-feuilles et la prise en charge des DataSet.

Comparaison rapide d'OleDb et IronXL

Comparaison des fonctionnalités d'OleDb et IronXL pour l'exportation de DataTable vers Excel en C#
Capacité OleDb IronXL
Installation du pilote requise Oui (ACE.OLEDB ou Jet) Non
Multiplateforme (.NET 10 / Linux) Non Oui
Créer un nouveau classeur à partir de zéro Non Oui
Mise en forme et style des cellules Non Oui
Support de formule Non Oui
performance d'insertion par lot Rang par rang (lentement) En mémoire (rapide)
SUPPRESSION du support de ligne Non Oui
Prise en charge de Docker/conteneurs Non Oui

Comment gérez-vous les types de données de colonnes lors de l'exportation ?

Lorsqu'une colonne d'un DataTable contient des valeurs numériques ou de date, les écrire sous forme de chaînes de caractères amène Excel à traiter la cellule comme du texte, ce qui désactive le tri, le filtrage et les références de formules. IronXL préserve les types natifs lorsque vous transmettez directement la valeur plutôt que d'appeler .ToString() :

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("TypedData");

DataTable table = new DataTable();
table.Columns.Add("ID", typeof(int));
table.Columns.Add("Amount", typeof(decimal));
table.Columns.Add("Date", typeof(DateTime));
table.Rows.Add(1, 1500.75m, new DateTime(2025, 6, 15));
table.Rows.Add(2, 3200.00m, new DateTime(2025, 7, 4));

// Write headers
for (int col = 0; col < table.Columns.Count; col++)
    worksheet.SetCellValue(0, col, table.Columns[col].ColumnName);

// Write typed values -- no .ToString() conversion
for (int row = 0; row < table.Rows.Count; row++)
{
    worksheet.SetCellValue(row + 1, 0, (int)table.Rows[row]["ID"]);
    worksheet.SetCellValue(row + 1, 1, (double)(decimal)table.Rows[row]["Amount"]);
    worksheet[$"C{row + 2}"].Value = (DateTime)table.Rows[row]["Date"];
    worksheet[$"C{row + 2}"].FormatString = "yyyy-MM-dd";
}

workbook.SaveAs("TypedData.xlsx");
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("TypedData");

DataTable table = new DataTable();
table.Columns.Add("ID", typeof(int));
table.Columns.Add("Amount", typeof(decimal));
table.Columns.Add("Date", typeof(DateTime));
table.Rows.Add(1, 1500.75m, new DateTime(2025, 6, 15));
table.Rows.Add(2, 3200.00m, new DateTime(2025, 7, 4));

// Write headers
for (int col = 0; col < table.Columns.Count; col++)
    worksheet.SetCellValue(0, col, table.Columns[col].ColumnName);

// Write typed values -- no .ToString() conversion
for (int row = 0; row < table.Rows.Count; row++)
{
    worksheet.SetCellValue(row + 1, 0, (int)table.Rows[row]["ID"]);
    worksheet.SetCellValue(row + 1, 1, (double)(decimal)table.Rows[row]["Amount"]);
    worksheet[$"C{row + 2}"].Value = (DateTime)table.Rows[row]["Date"];
    worksheet[$"C{row + 2}"].FormatString = "yyyy-MM-dd";
}

workbook.SaveAs("TypedData.xlsx");
Imports System
Imports System.Data

Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("TypedData")

Dim table As New DataTable()
table.Columns.Add("ID", GetType(Integer))
table.Columns.Add("Amount", GetType(Decimal))
table.Columns.Add("Date", GetType(DateTime))
table.Rows.Add(1, 1500.75D, New DateTime(2025, 6, 15))
table.Rows.Add(2, 3200.00D, New DateTime(2025, 7, 4))

' Write headers
For col As Integer = 0 To table.Columns.Count - 1
    worksheet.SetCellValue(0, col, table.Columns(col).ColumnName)
Next

' Write typed values -- no .ToString() conversion
For row As Integer = 0 To table.Rows.Count - 1
    worksheet.SetCellValue(row + 1, 0, CInt(table.Rows(row)("ID")))
    worksheet.SetCellValue(row + 1, 1, CDbl(CDec(table.Rows(row)("Amount"))))
    worksheet($"C{row + 2}").Value = CType(table.Rows(row)("Date"), DateTime)
    worksheet($"C{row + 2}").FormatString = "yyyy-MM-dd"
Next

workbook.SaveAs("TypedData.xlsx")
$vbLabelText   $csharpLabel

Excel permet désormais de trier la colonne Montant par ordre numérique et de filtrer la colonne Date à l'aide de sélecteurs de date. Pour plus de modèles de format de données, consultez le guide de format de données de cellule . Si vous devez relire des données après l'exportation, le tutoriel Excel vers DataTable couvre l'opération inverse.

Migration du code d'exportation OleDb existant

La migration d'OleDb vers IronXL prend généralement moins de temps qu'un seul sprint. Les changements structurels sont les suivants :

  1. Supprimez toutes les références using System.Data.OleDb et les références NuGet à tout package wrapper de pilote ACE.
  2. Remplacez le bloc d'initialisation OleDbConnection par WorkBook.Create(ExcelFileFormat.XLSX).
  3. Remplacez la commande CREATE TABLE par workbook.CreateWorkSheet("SheetName").
  4. Remplacez la boucle INSERT INTO par des appels imbriqués SetCellValue(), un par cellule.
  5. Remplacez connection.Close() par workbook.SaveAs("output.xlsx").

Vous pouvez également appeler workbook.SaveAs() avec une extension .xls pour produire des fichiers au format hérité si les consommateurs en aval n'ont pas encore effectué la mise à niveau vers Excel 2007 ou une version ultérieure. Le guide de conversion des types de fichiers tableur répertorie tous les formats de sortie pris en charge.

Comment tester et obtenir une licence IronXL?

IronXL est gratuit à utiliser en développement avec une licence d'essai . Vous appliquez la clé dans le code avant le premier appel IronXL :

IronXl.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";
IronXl.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";
Imports IronXl

IronXl.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"
$vbLabelText   $csharpLabel

Le guide d'application de la clé de licence détaille toutes les options d'installation, y compris les fichiers de configuration et les variables d'environnement. Pour les déploiements dans le cloud, les pages de démarrage pour Docker et Linux couvrent les étapes de configuration spécifiques à chaque plateforme.

Microsoft documente les limitations connues du moteur de base de données Access pour les scénarios OleDb, et NuGet héberge le package IronXL avec un historique complet des versions et des statistiques de téléchargement. La documentation officielle du kit de développement logiciel Open XML (SDK) explique la spécification XLSX sous-jacente implémentée par IronXL .

Quelles sont vos prochaines étapes ?

Vous disposez désormais d'un modèle fonctionnel pour exporter une DataTable vers un fichier XLSX sans pilotes OleDb, sans syntaxe SQL et sans restrictions de plateforme. Le flux de travail principal -- WorkBook.Create(), CreateWorkSheet(), SetCellValue() dans une boucle, puis SaveAs() -- passe d'un échantillon de trois lignes à des ensembles de données comportant des centaines de milliers de lignes.

Commencez par remplacer votre exportation OleDb existante par le modèle IronXL de base présenté ci-dessus, puis ajoutez une mise en forme à l'aide de l'API de style une fois l'exportation des données vérifiée. Le guide de démarrage d' IronXL et la présentation des fonctionnalités sont de bonnes lectures pour bien comprendre l'étendue des possibilités offertes par la bibliothèque. Si vous utilisez des fichiers CSV dans le cadre du même pipeline, le guide C# DataTable vers CSV montre comment produire une sortie délimitée par des virgules à partir du même objet DataTable.

Questions Fréquemment Posées

Quelles sont les limitations de l'utilisation d'OleDb pour exporter un DataTable vers Excel en C# ?

L'exportation de DataTable vers Excel via OleDb en C# peut s'avérer frustrante en raison de son ancienneté. Les développeurs rencontrent souvent des limitations telles que des problèmes de compatibilité, des performances réduites et une gestion des erreurs plus complexe, ce qui rend les alternatives modernes comme IronXL plus intéressantes.

Comment IronXL améliore-t-il le processus d'exportation de DataTable vers Excel ?

IronXL propose une approche moderne de l'exportation de DataTable vers Excel, offrant de meilleures performances, une compatibilité étendue et un code simplifié. Il élimine les problèmes courants liés à OleDb, facilitant ainsi la gestion des exportations Excel pour les développeurs .NET .

Pourquoi devrais-je envisager de passer d'OleDb à IronXL pour les exportations de DataTable ?

Passer à IronXL pour les exportations de DataTable offre plusieurs avantages, notamment des performances améliorées, une mise en œuvre plus facile et une compatibilité accrue avec les applications .NET modernes, réduisant ainsi le temps et les efforts nécessaires au développement.

IronXL peut-il gérer plus efficacement les exportations de DataTable volumineuses qu'OleDb ?

Oui, IronXL est conçu pour gérer efficacement les exportations de DataTable volumineuses, offrant des temps de traitement plus rapides et une utilisation de la mémoire réduite par rapport à OleDb, ce qui le rend idéal pour les applications traitant d'importants ensembles de données.

IronXL est-il compatible avec les dernières versions de C# et .NET?

IronXL est entièrement compatible avec les dernières versions de C# et .NET, assurant une intégration transparente avec les applications modernes tout en fournissant des mises à jour continues pour prendre en charge les nouvelles fonctionnalités et améliorations.

Quels avantages offrent les alternatives modernes comme IronXL par rapport à la base de données OleDb traditionnelle ?

Les alternatives modernes comme IronXL offrent des avantages tels que des performances améliorées, une gestion des erreurs simplifiée, une meilleure compatibilité avec différents formats Excel et un code simplifié, ce qui peut considérablement améliorer la productivité des développeurs.

Comment IronXL gère-t-il la gestion des erreurs par rapport à OleDb ?

IronXL offre une gestion simplifiée des erreurs grâce à une gestion claire des exceptions, réduisant ainsi la complexité et les problèmes potentiels associés à OleDb, ce qui facilite le débogage et la maintenance des applications par les développeurs.

Quels sont les cas d'utilisation courants de l'exportation de DataTable vers Excel dans les applications .NET basées sur une interface utilisateur ?

Dans les applications .NET basées sur une interface utilisateur, l'exportation de DataTable vers Excel est couramment utilisée pour générer des rapports, analyser des données et manipuler les données de manière conviviale, souvent déclenchée par des gestionnaires d'événements utilisant des modèles d'envoi d'objets.

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