Icône de message
Passer au contenu du pied de page
  1. Iron Software
  2. Blog IronXL
  3. Utilisation d'IronXL
  4. Exportation Excel du jeu de données
UTILISATION D'IRONXL

Exporter un jeu de données vers Excel en C# avec IronXL | Aucune suite Office requise

Jordi Bardia
Jordi Bardia
Mis à jour:

L'exportation d'un DataSet ou d'un DataTable vers Excel en C# offre une méthode fiable pour convertir des données structurées en mémoire en fichiers tableur professionnels, sans nécessiter l'installation de Microsoft Office sur la machine cible. Que vous extrayiez des enregistrements d'une base de données SQL, créiez un DataSet par programmation ou utilisiez un DataGrid existant, IronXL gère l'ensemble du processus grâce à une API claire et intuitive. Ce guide décrit en détail tous les principaux scénarios, de l'exportation d'une seule table aux classeurs à plusieurs feuilles en passant par les résultats de requêtes de base de données en direct, en utilisant des instructions C# de haut niveau et .NET 10.

Installez IronXL une seule fois, écrivez quelques lignes de code, et vos données se trouvent dans un fichier XLSX sans aucune dépendance à Office. Les sections ci-dessous couvrent l'installation, les modèles de base, la mise en forme avancée et l'intégration de bases de données, de manière à ce que vous puissiez les copier-coller directement dans vos propres projets.

Comment installer IronXL pour l'exportation Excel ?

Avant d'écrire le moindre code d'exportation, ajoutez IronXL à votre projet via le gestionnaire de packages NuGet . Ouvrez un terminal à la racine de votre projet et exécutez la commande .NET CLI, ou utilisez la console du gestionnaire de packages dans Visual Studio avec la commande Install-Package :

dotnet add package IronXl.Excel
# Or in Visual Studio Package Manager Console:
# Install-Package IronXl.Excel
dotnet add package IronXl.Excel
# Or in Visual Studio Package Manager Console:
# Install-Package IronXl.Excel
SHELL

Après l'installation, ajoutez une instruction using de niveau supérieur pour importer l'espace de noms IronXL :

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

IronXL cible .NET 8, .NET 9 et .NET 10 ainsi que les anciennes versions de .NET Framework (4.6.2+). Aucune installation d'Office n'est requise sur aucune machine (serveur, ordinateur de bureau ou cloud). Une fois le package installé, vous pouvez créer, lire et écrire des fichiers XLSX, XLS et CSV entièrement en code managé.

Pour connaître les options d'installation détaillées, consultez le guide d'installation IronXL et la page du package NuGet pour l'historique des versions.

Comment exporter une seule table de données vers un fichier Excel ?

Le scénario le plus courant consiste à exporter une DataTable vers une seule feuille de calcul. Les classes WorkBook et WorkSheet d'IronXL correspondent naturellement au modèle objet Excel. Vous créez un classeur, ajoutez une feuille de calcul, puis parcourez les colonnes et les lignes du tableau de données.

L'exemple suivant crée une DataTable Employees en mémoire et l'écrit dans EmployeeData.xlsx :

using IronXL;
using System.Data;

// Build an in-memory DataTable
DataTable dt = new DataTable("Employees");
dt.Columns.Add("ID", typeof(int));
dt.Columns.Add("Name", typeof(string));
dt.Columns.Add("Department", typeof(string));

dt.Rows.Add(1, "John Smith", "Engineering");
dt.Rows.Add(2, "Sarah Jones", "Marketing");
dt.Rows.Add(3, "Mike Wilson", "Sales");

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

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

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

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

// Build an in-memory DataTable
DataTable dt = new DataTable("Employees");
dt.Columns.Add("ID", typeof(int));
dt.Columns.Add("Name", typeof(string));
dt.Columns.Add("Department", typeof(string));

dt.Rows.Add(1, "John Smith", "Engineering");
dt.Rows.Add(2, "Sarah Jones", "Marketing");
dt.Rows.Add(3, "Mike Wilson", "Sales");

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

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

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

workbook.SaveAs("EmployeeData.xlsx");
$vbLabelText   $csharpLabel

Sortie

Comment exporter un jeu de données vers Excel avec .NET: Guide complet avec IronXL: Image 1 - Résultat de l'exportation d'un tableau de données simple vers Excel en .NET

SetCellValue accepte int, double, string et bool -- vous obtenez donc des types de cellules Excel natifs sans conversion supplémentaire. Le modèle de boucle fonctionne pour les tables de toute taille car IronXL écrit directement en mémoire et vide sur le disque uniquement lorsque SaveAs est appelé, ce qui maintient le processus efficace même pour des milliers de lignes.

Pour une présentation plus complète des techniques de lecture et d'écriture, le tutoriel IronXL C# couvre l'ensemble des opérations sur les fichiers ainsi que ce modèle d'exportation.

Comment exporter un ensemble de données vers plusieurs feuilles de calcul Excel ?

Lorsqu'un ensemble de données contient plusieurs tables liées (comme Produits et Commandes), vous pouvez associer chaque DataTable à sa propre feuille de calcul au sein d'un même classeur. Cela permet aux destinataires de consulter toutes les données associées dans un seul fichier, sans avoir besoin d'ouvrir plusieurs documents.

La boucle ci-dessous itère sur ds.Tables et crée une feuille par tableau :

using IronXL;
using System.Data;

// Build a DataSet with two related tables
DataSet ds = new DataSet("CompanyData");

DataTable dtProducts = new DataTable("Products");
dtProducts.Columns.Add("ProductID", typeof(int));
dtProducts.Columns.Add("ProductName", typeof(string));
dtProducts.Columns.Add("Price", typeof(decimal));
dtProducts.Rows.Add(101, "Widget A", 29.99m);
dtProducts.Rows.Add(102, "Widget B", 49.99m);
ds.Tables.Add(dtProducts);

DataTable dtOrders = new DataTable("Orders");
dtOrders.Columns.Add("OrderID", typeof(int));
dtOrders.Columns.Add("Customer", typeof(string));
dtOrders.Columns.Add("Total", typeof(decimal));
dtOrders.Rows.Add(1001, "Acme Corp", 599.90m);
dtOrders.Rows.Add(1002, "Tech Inc", 299.95m);
ds.Tables.Add(dtOrders);

// Create one workbook and iterate each DataTable
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);

foreach (DataTable table in ds.Tables)
{
    WorkSheet sheet = workbook.CreateWorkSheet(table.TableName);

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

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

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

// Build a DataSet with two related tables
DataSet ds = new DataSet("CompanyData");

DataTable dtProducts = new DataTable("Products");
dtProducts.Columns.Add("ProductID", typeof(int));
dtProducts.Columns.Add("ProductName", typeof(string));
dtProducts.Columns.Add("Price", typeof(decimal));
dtProducts.Rows.Add(101, "Widget A", 29.99m);
dtProducts.Rows.Add(102, "Widget B", 49.99m);
ds.Tables.Add(dtProducts);

DataTable dtOrders = new DataTable("Orders");
dtOrders.Columns.Add("OrderID", typeof(int));
dtOrders.Columns.Add("Customer", typeof(string));
dtOrders.Columns.Add("Total", typeof(decimal));
dtOrders.Rows.Add(1001, "Acme Corp", 599.90m);
dtOrders.Rows.Add(1002, "Tech Inc", 299.95m);
ds.Tables.Add(dtOrders);

// Create one workbook and iterate each DataTable
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);

foreach (DataTable table in ds.Tables)
{
    WorkSheet sheet = workbook.CreateWorkSheet(table.TableName);

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

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

workbook.SaveAs("CompanyReport.xlsx");
$vbLabelText   $csharpLabel

Sortie

Comment exporter un jeu de données vers Excel avec VB .NET: Guide complet avec IronXL: Image 2 - Fichier Excel généré avec les données exportées sous forme de feuilles de calcul séparées.

Chaque feuille de calcul porte le nom de la table de données source, ce qui simplifie la navigation dans Excel. Parce que WorkBook.Create alloue le classeur en mémoire, vous pouvez continuer à ajouter des feuilles de calcul dans la boucle sans rouvrir le fichier -- IronXL construit toute la structure XLSX avant d'écrire sur le disque.

La documentation IronXL WorkBook répertorie toutes les méthodes disponibles sur l'objet WorkBook, y compris le réarrangement des feuilles, la protection par mot de passe et l'enregistrement dans des formats autres que XLSX.

Comment ajouter une mise en forme d'en-tête aux exportations Excel ?

L'exportation de données brutes est fonctionnelle, mais l'ajout d'en-têtes en gras et de largeurs de colonnes rend le résultat immédiatement utilisable dans un contexte professionnel. IronXL expose le style des cellules et des plages via l'objet Style attaché à n'importe quelle plage WorkSheet.

L'extrait de code ci-dessous applique une mise en forme en gras à la ligne d'en-tête et ajuste automatiquement la largeur des colonnes après l'écriture des données :

using IronXL;
using System.Data;

DataTable dt = new DataTable("Sales");
dt.Columns.Add("Region", typeof(string));
dt.Columns.Add("Q1", typeof(decimal));
dt.Columns.Add("Q2", typeof(decimal));
dt.Columns.Add("Q3", typeof(decimal));
dt.Columns.Add("Q4", typeof(decimal));

dt.Rows.Add("Nonrth", 120000m, 135000m, 142000m, 158000m);
dt.Rows.Add("South", 98000m, 104000m, 112000m, 121000m);
dt.Rows.Add("East",  87000m, 93000m,  99000m,  108000m);
dt.Rows.Add("West",  145000m, 152000m, 161000m, 174000m);

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

// Write and style headers
for (int col = 0; col < dt.Columns.Count; col++)
{
    sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
    sheet["A1:E1"].Style.Font.Bold = true;
    sheet["A1:E1"].Style.Font.Height = 12;
}

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

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

DataTable dt = new DataTable("Sales");
dt.Columns.Add("Region", typeof(string));
dt.Columns.Add("Q1", typeof(decimal));
dt.Columns.Add("Q2", typeof(decimal));
dt.Columns.Add("Q3", typeof(decimal));
dt.Columns.Add("Q4", typeof(decimal));

dt.Rows.Add("Nonrth", 120000m, 135000m, 142000m, 158000m);
dt.Rows.Add("South", 98000m, 104000m, 112000m, 121000m);
dt.Rows.Add("East",  87000m, 93000m,  99000m,  108000m);
dt.Rows.Add("West",  145000m, 152000m, 161000m, 174000m);

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

// Write and style headers
for (int col = 0; col < dt.Columns.Count; col++)
{
    sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
    sheet["A1:E1"].Style.Font.Bold = true;
    sheet["A1:E1"].Style.Font.Height = 12;
}

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

workbook.SaveAs("SalesReport.xlsx");
$vbLabelText   $csharpLabel

La propriété Style.Font.Bold s'applique à l'ensemble de la plage d'en-tête dans une seule instruction. IronXL prend également en charge les couleurs d'arrière-plan (Style.BackgroundColor), les styles de bordure (Style.Border), les formats de nombre (Style.NumberFormat.FormatCode) et l'alignement horizontal (Style.HorizontalAlignment). Pour une référence complète en matière de style, consultez le guide de formatage des cellules IronXL .

Comment exporter les résultats d'une requête de base de données vers Excel ?

La connexion à une base de données SQL et l'exportation directe des résultats vers Excel couvrent un cas d'utilisation majeur dans le monde réel : les rapports planifiés, les instantanés de données et les exportations administratives. Cette approche remplit un DataSet en utilisant SqlDataAdapter, puis mappe le DataTable résultant sur une feuille de calcul IronXL .

using IronXL;
using System.Data;
using System.Data.SqlClient;

string connectionString = "Server=localhost;Database=SalesDB;Integrated Security=True;";
string query = "SELECT CustomerID, CompanyName, ContactName, Country FROM Customers";

// Fill DataSet from SQL query
DataSet ds = new DataSet();
using (SqlConnection connection = new SqlConnection(connectionString))
{
    SqlDataAdapter adapter = new SqlDataAdapter(query, connection);
    adapter.Fill(ds, "Customers");
}

DataTable dt = ds.Tables["Customers"]!;

// Create workbook and export
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("CustomerData");

// Bold header row
for (int col = 0; col < dt.Columns.Count; col++)
{
    worksheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
}
worksheet["A1:D1"].Style.Font.Bold = true;

// Write rows, handling DBNull values safely
for (int row = 0; row < dt.Rows.Count; row++)
{
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        object cellValue = dt.Rows[row][col];
        worksheet.SetCellValue(row + 1, col,
            cellValue == DBNull.Value ? "" : cellValue.ToString()!);
    }
}

workbook.SaveAs("CustomerExport.xlsx");
Console.WriteLine("Export complete.");
using IronXL;
using System.Data;
using System.Data.SqlClient;

string connectionString = "Server=localhost;Database=SalesDB;Integrated Security=True;";
string query = "SELECT CustomerID, CompanyName, ContactName, Country FROM Customers";

// Fill DataSet from SQL query
DataSet ds = new DataSet();
using (SqlConnection connection = new SqlConnection(connectionString))
{
    SqlDataAdapter adapter = new SqlDataAdapter(query, connection);
    adapter.Fill(ds, "Customers");
}

DataTable dt = ds.Tables["Customers"]!;

// Create workbook and export
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("CustomerData");

// Bold header row
for (int col = 0; col < dt.Columns.Count; col++)
{
    worksheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
}
worksheet["A1:D1"].Style.Font.Bold = true;

// Write rows, handling DBNull values safely
for (int row = 0; row < dt.Rows.Count; row++)
{
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        object cellValue = dt.Rows[row][col];
        worksheet.SetCellValue(row + 1, col,
            cellValue == DBNull.Value ? "" : cellValue.ToString()!);
    }
}

workbook.SaveAs("CustomerExport.xlsx");
Console.WriteLine("Export complete.");
$vbLabelText   $csharpLabel

Points clés pour l'exportation de bases de données

La protection nulle (cellValue == DBNull.Value ? "" : cellValue.ToString()) prevents exceptions when the database returns NULL valeurs -- une occurrence courante avec les colonnes facultatives. La mise en forme en gras de la ligne d'en-tête permet aux destinataires du rapport de distinguer immédiatement les en-têtes des données.

Pour découvrir d'autres exemples de lecture de données Excel vers des objets C#, le tutoriel d'exportation IronXL DataTable explique comment inverser ce processus.

Comment comparer IronXL aux autres méthodes d'exportation Excel ?

Avant de choisir une bibliothèque, il est utile de comprendre comment les principales options se comparent les unes aux autres dans les domaines les plus importants pour les scénarios d'exportation de jeux de données.

Comparaison des bibliothèques d'exportation Excel pour les scénarios .NET DataSet
Approche Bureau requis Assistance XLSX API de style Feuilles multiples Performances (données volumineuses)
IronXL Non Oui Complet Oui Haut
Interopérabilité de Microsoft Office Oui Oui Complet Oui Faible
EPPlus Non Oui Partiel Oui Haut
ClosedXML Non Oui Partiel Oui Moyen
CSV (manuel) Non Non Aucune Non Très haut

Interopérabilité de Microsoft Office fonctionne uniquement sur les machines Windows sur lesquelles Office est installé, ce qui l'exclut pour les déploiements de serveurs et les fonctions cloud. IronXL, EPPlus et ClosedXML prennent tous en charge la génération côté serveur ; la principale différence réside dans l'étendue de l'API de style et du modèle de licence. La licence d'IronXL inclut une utilisation commerciale et couvre tous les frameworks cibles .NET à partir d'un seul package.

Pour les analyses comparatives et les points de référence tiers, la documentation Microsoft sur les formats de fichiers Excel et la page de projet EPPlus fournissent des informations supplémentaires pour vous aider à faire le bon choix pour votre projet.

Comment gérer de grands ensembles de données sans problèmes de mémoire ?

Lors de l'exportation de DataTables contenant des dizaines de milliers de lignes, il est important de maintenir une utilisation prévisible de la mémoire. Le modèle ci-dessous transmet les données d'un IDataReader au lieu de charger d'abord l'ensemble des résultats dans une DataTable. Cela évite le double coût en mémoire lié au stockage simultané du tampon de lecture et de la DataTable.

using IronXL;
using System.Data;
using System.Data.SqlClient;

string connectionString = "Server=localhost;Database=InventoryDB;Integrated Security=True;";
string query = "SELECT ProductID, SKU, Description, StockLevel, UnitCost FROM Products";

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Inventory");

using SqlConnection conn = new SqlConnection(connectionString);
conn.Open();

using SqlCommand cmd = new SqlCommand(query, conn);
using SqlDataReader reader = cmd.ExecuteReader();

// Write schema-derived headers
for (int col = 0; col < reader.FieldCount; col++)
{
    sheet.SetCellValue(0, col, reader.GetName(col));
}

// Stream rows directly into IronXL without buffering a DataTable
int excelRow = 1;
while (reader.Read())
{
    for (int col = 0; col < reader.FieldCount; col++)
    {
        sheet.SetCellValue(excelRow, col,
            reader.IsDBNull(col) ? "" : reader.GetValue(col).ToString()!);
    }
    excelRow++;
}

workbook.SaveAs("InventoryExport.xlsx");
Console.WriteLine($"Exported {excelRow - 1} rows.");
using IronXL;
using System.Data;
using System.Data.SqlClient;

string connectionString = "Server=localhost;Database=InventoryDB;Integrated Security=True;";
string query = "SELECT ProductID, SKU, Description, StockLevel, UnitCost FROM Products";

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Inventory");

using SqlConnection conn = new SqlConnection(connectionString);
conn.Open();

using SqlCommand cmd = new SqlCommand(query, conn);
using SqlDataReader reader = cmd.ExecuteReader();

// Write schema-derived headers
for (int col = 0; col < reader.FieldCount; col++)
{
    sheet.SetCellValue(0, col, reader.GetName(col));
}

// Stream rows directly into IronXL without buffering a DataTable
int excelRow = 1;
while (reader.Read())
{
    for (int col = 0; col < reader.FieldCount; col++)
    {
        sheet.SetCellValue(excelRow, col,
            reader.IsDBNull(col) ? "" : reader.GetValue(col).ToString()!);
    }
    excelRow++;
}

workbook.SaveAs("InventoryExport.xlsx");
Console.WriteLine($"Exported {excelRow - 1} rows.");
$vbLabelText   $csharpLabel

Ce modèle est recommandé lorsque le jeu de résultats peut dépasser 50 000 lignes ou lors de l'exécution dans un service aux ressources mémoire limitées. La documentation relative aux performances IronXL présente des options supplémentaires d'optimisation de la mémoire et du débit pour les exportations à volume élevé.

Enregistrement par lots au format CSV pour les exportations de très grande taille

Pour les exportations dépassant 500 000 lignes et lorsque la mémoire est extrêmement limitée, envisagez de répartir la sortie sur plusieurs classeurs ou d'exporter au format CSV :

using IronXL;

// IronXL can save any workbook as CSV
workbook.SaveAs("LargeExport.csv");
using IronXL;

// IronXL can save any workbook as CSV
workbook.SaveAs("LargeExport.csv");
$vbLabelText   $csharpLabel

Le format CSV perd la mise en forme et la prise en charge de plusieurs feuilles, mais reste valide pour les processus ETL en aval qui consomment des données brutes délimitées.

Comment enregistrer des fichiers Excel dans différents formats et à différents emplacements ?

IronXL prend en charge l'enregistrement dans le chemin de fichier, MemoryStream, et byte[] -- ce qui est important pour les applications ASP.NET renvoyant Excel comme réponse de téléchargement.

using IronXL;
using System.IO;

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Report");
sheet.SetCellValue(0, 0, "Generated Report");

// Save to file path
workbook.SaveAs("Report.xlsx");

// Save as XLS (legacy format)
workbook.SaveAs("Report.xls");

// Save to MemoryStream for HTTP response
using MemoryStream ms = new MemoryStream();
workbook.SaveAs(ms);
byte[] fileBytes = ms.ToArray();
// fileBytes can be returned from an ASP.NET controller action
using IronXL;
using System.IO;

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Report");
sheet.SetCellValue(0, 0, "Generated Report");

// Save to file path
workbook.SaveAs("Report.xlsx");

// Save as XLS (legacy format)
workbook.SaveAs("Report.xls");

// Save to MemoryStream for HTTP response
using MemoryStream ms = new MemoryStream();
workbook.SaveAs(ms);
byte[] fileBytes = ms.ToArray();
// fileBytes can be returned from an ASP.NET controller action
$vbLabelText   $csharpLabel

Pour ASP.NET Core, renvoyez File(fileBytes, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "Report.xlsx") depuis l'action de votre contrôleur pour déclencher un téléchargement dans le navigateur. Le guide Excel IronXL ASP.NET présente le modèle d'intégration complet du contrôleur.

Pour les bibliothèques alternatives .NET Excel, le SDK Open XML constitue la base open source sur laquelle de nombreuses bibliothèques s'appuient.

Formats de sortie pris en charge

IronXL enregistre dans les formats suivants sans aucune dépendance supplémentaire :

  • XLSX -- Format OpenXML, compatible avec Excel 2007 et versions ultérieures
  • XLS -- Format binaire hérité, compatible avec Excel 97-2003
  • CSV -- Valeurs séparées par des virgules, format universellement pris en charge
  • TSV -- Valeurs séparées par des tabulations
  • JSON -- Exportation de données structurées

Changez de format en modifiant l'extension du fichier dans le chemin SaveAs ou en utilisant la méthode surchargée qui accepte une valeur d'énumération ExcelFileFormat.

Comment vérifier que le fichier Excel exporté est correct ?

Après l'exportation, vous pouvez relire le fichier avec IronXL pour vérifier le nombre de lignes, contrôler ponctuellement les valeurs ou exécuter des assertions automatisées dans un projet de test :

using IronXL;

WorkBook loaded = WorkBook.Load("EmployeeData.xlsx");
WorkSheet sheet = loaded.WorkSheets[0];

// Verify row count (header row + data rows)
int totalRows = sheet.Rows.Count();
Console.WriteLine($"Rows in file: {totalRows}");

// Spot-check specific cell values
string header = sheet["A1"].StringValue;
string firstEmployee = sheet["A2"].StringValue;

Console.WriteLine($"Header: {header}, First row: {firstEmployee}");
using IronXL;

WorkBook loaded = WorkBook.Load("EmployeeData.xlsx");
WorkSheet sheet = loaded.WorkSheets[0];

// Verify row count (header row + data rows)
int totalRows = sheet.Rows.Count();
Console.WriteLine($"Rows in file: {totalRows}");

// Spot-check specific cell values
string header = sheet["A1"].StringValue;
string firstEmployee = sheet["A2"].StringValue;

Console.WriteLine($"Header: {header}, First row: {firstEmployee}");
$vbLabelText   $csharpLabel

Ce modèle de vérification est particulièrement utile dans les suites de tests d'intégration où l'exactitude des exportations doit être confirmée avant l'envoi des fichiers à des systèmes externes. Le tutoriel de lecture IronXL présente l'ensemble des opérations de lecture disponibles après le chargement d'un fichier.

Pour en savoir plus sur les modèles DataSet et DataTable dans .NET, la documentation Microsoft DataSet couvre en détail le modèle objet .NET .

Quelles sont vos prochaines étapes ?

Vous disposez désormais de modèles fonctionnels pour tous les principaux scénarios d'exportation de DataSet vers Excel en C# : d'une seule DataTable à des classeurs à plusieurs feuilles, en passant par les exportations pilotées par base de données, les en-têtes formatés et le streaming de données volumineuses. Voici comment procéder à l'étape suivante en fonction de votre objectif :

  • Essayez IronXL gratuitement -- Commencez par une licence d'essai gratuite et exécutez les exemples ci-dessus avec vos propres données avant de vous engager dans la production.
  • Consultez la documentation complète de l'API : la documentation de référence de l'objet IronXL couvre toutes les méthodes relatives aux objets WorkBook, WorkSheet et aux plages de cellules.
  • Explorez les tutoriels d'exportation connexes : le guide C# DataTable vers Excel couvre le flux de travail inverse, c'est-à-dire la lecture d'Excel dans des objets DataTable.
  • Consultez les options de mise en forme : la documentation de mise en forme des cellules IronXL présente les formats de nombres, les bordures, les couleurs d'arrière-plan et les options d'alignement.
  • Vérifiez les licences -- Pour les déploiements en production, consultez la page des licences IronXL pour choisir entre les options Développeur, Organisation et Sans redevance.
  • Comparer avec les autres outils Iron Software -- Si votre projet nécessite également la génération de PDF ou la reconnaissance optique de caractères (OCR), la suite de produits Iron Software vous permet de regrouper plusieurs bibliothèques à un prix réduit.

En vous appuyant sur les modèles présentés ici, vous pouvez intégrer l'automatisation des tâches planifiées, les points de terminaison de téléchargement ASP.NET Core et les pipelines de sortie multiformats, le tout en C# managé — sans Office, sans COM, sans dépendances d'exécution autres que le package NuGet .

Questions Fréquemment Posées

Comment exporter un DataSet vers Excel en C# ?

Vous pouvez exporter un DataSet vers Excel en C# en utilisant la bibliothèque IronXL , qui fournit une API basée sur le code pour créer, modifier et manipuler des fichiers Excel sans avoir besoin de Microsoft Office.

Ai-je besoin d'installer Microsoft Office pour utiliser IronXL ?

Non, IronXL ne nécessite pas l'installation de Microsoft Office sur la machine pour exporter ou manipuler des fichiers Excel.

Quels types de données puis-je exporter avec IronXL?

IronXL vous permet d'exporter des données structurées telles que des DataTables et des DataSets vers des fichiers Excel, ainsi que des données provenant de SqlDataReader et d'autres sources .NET .

IronXL peut-il gérer la création et la modification de fichiers Excel ?

Oui, IronXL offre des fonctionnalités permettant de créer, modifier et manipuler des fichiers Excel par programmation en C#.

IronXL est-il adapté aux applications côté serveur et dans le cloud ?

Oui, IronXL est idéal pour les applications côté serveur et les fonctions cloud qui ont besoin de générer des fichiers Excel sans installation d'Office.

Quels sont les avantages de l'utilisation IronXL pour l'exportation d'ensembles de données ?

IronXL gère la création et la manipulation de fichiers Excel sans dépendances externes comme Microsoft Office, prend en charge les formats XLSX, XLS et CSV, et fonctionne sur tous les frameworks cibles .NET .

Peut-on utiliser IronXL dans ASP.NET Core pour renvoyer un fichier Excel à télécharger ?

Oui, IronXL peut enregistrer des classeurs dans un MemoryStream, et le tableau d'octets résultant peut être renvoyé par une action de contrôleur ASP.NET Core sous forme de téléchargement de fichier.

IronXL prend-il en charge les grands ensembles de données ?

Oui, IronXL peut diffuser des données directement depuis SqlDataReader sans mettre en mémoire tampon une DataTable complète, ce qui permet de maintenir une utilisation prévisible de la mémoire pour les grands ensembles de résultats.

Quels sont les formats Excel pris en charge par IronXL pour l'enregistrement ?

IronXL prend en charge l'enregistrement aux formats XLSX, XLS, CSV, TSV et JSON sans aucune dépendance supplémentaire.

Puis-je appliquer une mise en forme comme des titres en gras lors de l'exportation vers Excel ?

Oui, IronXL fournit une API de style sur les plages de cellules pour la mise en gras, les couleurs d'arrière-plan, les bordures, les formats de nombres et l'alignement.

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

Articles connexes

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

Iron Support Team

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