Exportation ASP.NET vers Excel : Comparaison entre IronXL , ClosedXML et EPPlus

Quelles sont les méthodes courantes pour exporter des données vers Excel dans ASP.NET Core?

Les développeurs ASP.NET Core ont plusieurs options pour ajouter des fonctionnalités d'exportation Excel. Chaque approche diffère en termes de qualité du fichier de sortie, de l'effort requis pour l'implémenter, et des implications de licence pour les projets commerciaux.

Le streaming de type MIME traditionnel est la technique la plus ancienne. Le serveur définit l'en-tête Content-Type de la réponse à application/vnd.ms-excel et écrit un tableau HTML dans le flux de sortie. Le navigateur interprète cela comme un téléchargement Excel, mais le fichier contient des balises HTML plutôt que de véritables données de feuille de calcul. Microsoft Excel détecte la discordance et affiche un avertissement de format avant d'ouvrir le fichier. Cette méthode ne peut pas prendre en charge les formules, les colonnes typées ou le formatage correct des cellules.

Les solutions basées sur des bibliothèques ajoutent un package NuGet qui construit de véritables fichiers XLSX en utilisant le format Open XML défini par Microsoft. Les options incluent IronXL, ClosedXML, et EPPlus. Tous les trois produisent des fichiers Excel valides qui s'ouvrent sans avertissements, supportent le formatage au niveau des cellules, et fonctionnent avec .NET Core. La documentation officielle .NET pour les téléchargements de fichiers couvre les mécanismes sous-jacents d'ASP.NET Core utilisés par toutes ces approches.

Le tableau ci-dessous résume les principales différences :

Comment installer IronXL dans un projet ASP.NET Core ?

Avant de rédiger du code d'exportation, ajoutez IronXL à votre projet par le biais du Gestionnaire de Packages NuGet ou du .NET CLI. IronXL n'a pas de dépendance à Microsoft Office ou interopérabilité COM, donc l'installation est simple sur tout système d'exploitation supporté par .NET.

dotnet add package IronXl.Excel

dotnet add package IronXl.Excel

Alternativement, utilisez la Console du Gestionnaire de Packages dans Visual Studio :

Install-Package IronXl.Excel

Install-Package IronXl.Excel

Une fois le package installé, ajoutez using IronXL; à tout contrôleur ou classe de service qui a besoin de générer des fichiers Excel. Aucune configuration additionnelle n'est requise pour des scénarios d'exportation de base. Pour les options de licence et de déploiement, visitez la page de licence IronXL.

Comment fonctionne l'approche traditionnelle de l'exportation de grilles de visualisation ?

Dans les WebForms hérités et certains anciens modèles MVC, les développeurs exportaient les données de GridView en les rendant sous forme HTML et en les diffusant au navigateur avec un en-tête Content-Type trompeur. L'application appelle Response.AddHeader pour définir le nom du fichier et écrit directement la sortie HTML.

// Traditional approach -- exports HTML disguised as Excel
public void ExportToExcel(object sender, EventArgs e)
{
    Response.Clear();
    Response.Buffer = true;
    Response.ContentType = "application/vnd.ms-excel";
    Response.AddHeader("content-disposition", "attachment;filename=Report.xls");
    StringWriter stringWriter = new StringWriter();
    HtmlTextWriter htmlTextWriter = new HtmlTextWriter(stringWriter);
    // Render grid content as HTML
    DataGrid1.RenderControl(htmlTextWriter);
    Response.Write(stringWriter.ToString());
    Response.End();
}

public override void VerifyRenderingInServerForm(Control control)
{
    // Required to prevent server form rendering errors
}

// Traditional approach -- exports HTML disguised as Excel
public void ExportToExcel(object sender, EventArgs e)
{
    Response.Clear();
    Response.Buffer = true;
    Response.ContentType = "application/vnd.ms-excel";
    Response.AddHeader("content-disposition", "attachment;filename=Report.xls");
    StringWriter stringWriter = new StringWriter();
    HtmlTextWriter htmlTextWriter = new HtmlTextWriter(stringWriter);
    // Render grid content as HTML
    DataGrid1.RenderControl(htmlTextWriter);
    Response.Write(stringWriter.ToString());
    Response.End();
}

public override void VerifyRenderingInServerForm(Control control)
{
    // Required to prevent server form rendering errors
}

Comment IronXL for .NET simplifie-t-il la génération de fichiers Excel en ASP.NET Core?

IronXL fournit une API pour créer de véritables fichiers XLSX sans nécessiter Microsoft Office ou interopérabilité COM. La bibliothèque construit des objets classeurs entièrement en code managé, donc elle fonctionne sur Linux, macOS, et Windows sans dépendances supplémentaires.

L'exemple suivant crée un classeur, remplit une feuille de calcul avec des données de vente, applique un format gras à la ligne d'en-tête, et diffuse le fichier au navigateur :

using IronXL;
using Microsoft.AspNetCore.Mvc;

public class ExportController : Controller
{
    [HttpPost]
    public IActionResult ExportReport()
    {
        // Create workbook and worksheet
        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet worksheet = workbook.CreateWorkSheet("Sales Data");

        // Add header row
        worksheet["A1"].Value = "Product";
        worksheet["B1"].Value = "Quantity";
        worksheet["C1"].Value = "Revenue";

        // Populate data rows
        worksheet["A2"].Value = "Widget A";
        worksheet["B2"].Value = 150;
        worksheet["C2"].Value = 4500.00;
        worksheet["A3"].Value = "Widget B";
        worksheet["B3"].Value = 230;
        worksheet["C3"].Value = 6900.00;

        // Apply bold formatting to headers
        var headerRange = worksheet["A1:C1"];
        headerRange.Style.Font.Bold = true;

        // Stream file to browser
        byte[] fileBytes = workbook.ToByteArray();
        string filename = $"SalesReport_{DateTime.Nonw:yyyyMMdd}.xlsx";
        return File(fileBytes,
            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            filename);
    }
}

using IronXL;
using Microsoft.AspNetCore.Mvc;

public class ExportController : Controller
{
    [HttpPost]
    public IActionResult ExportReport()
    {
        // Create workbook and worksheet
        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet worksheet = workbook.CreateWorkSheet("Sales Data");

        // Add header row
        worksheet["A1"].Value = "Product";
        worksheet["B1"].Value = "Quantity";
        worksheet["C1"].Value = "Revenue";

        // Populate data rows
        worksheet["A2"].Value = "Widget A";
        worksheet["B2"].Value = 150;
        worksheet["C2"].Value = 4500.00;
        worksheet["A3"].Value = "Widget B";
        worksheet["B3"].Value = 230;
        worksheet["C3"].Value = 6900.00;

        // Apply bold formatting to headers
        var headerRange = worksheet["A1:C1"];
        headerRange.Style.Font.Bold = true;

        // Stream file to browser
        byte[] fileBytes = workbook.ToByteArray();
        string filename = $"SalesReport_{DateTime.Nonw:yyyyMMdd}.xlsx";
        return File(fileBytes,
            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            filename);
    }
}

// Export as CSV instead of XLSX
workbook.SaveAsCsv("output.csv");

// Export as CSV instead of XLSX
workbook.SaveAsCsv("output.csv");

Comment IronXL gère-t-il DataTable et l'intégration de la base de données ?

De nombreuses applications ASP.NET Core extraient des données de SQL Server ou d'une autre base de données relationnelle avant de les exporter. IronXL fournit un support de premier ordre pour charger un DataTable directement dans une feuille de travail, éliminant le besoin d'itérer manuellement les lignes.

L'exemple ci-dessous interroge une base de données via ADO.NET et remplit une feuille de calcul Excel à partir du DataTable résultant :

using IronXL;
using System.Data;
using System.Data.SqlClient;
using Microsoft.AspNetCore.Mvc;

public class ReportController : Controller
{
    private readonly string _connectionString;

    public ReportController(IConfiguration config)
    {
        _connectionString = config.GetConnectionString("DefaultConnection");
    }

    [HttpGet]
    public IActionResult DownloadReport()
    {
        DataTable table = new DataTable();

        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            string query = "SELECT OrderId, CustomerName, Total, OrderDate FROM Orders";
            using SqlDataAdapter adapter = new SqlDataAdapter(query, connection);
            adapter.Fill(table);
        }

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

        // Write column headers from DataTable schema
        for (int col = 0; col < table.Columns.Count; col++)
        {
            worksheet[0, col].Value = table.Columns[col].ColumnName;
        }

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

        byte[] fileBytes = workbook.ToByteArray();
        return File(fileBytes,
            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            "Orders.xlsx");
    }
}

using IronXL;
using System.Data;
using System.Data.SqlClient;
using Microsoft.AspNetCore.Mvc;

public class ReportController : Controller
{
    private readonly string _connectionString;

    public ReportController(IConfiguration config)
    {
        _connectionString = config.GetConnectionString("DefaultConnection");
    }

    [HttpGet]
    public IActionResult DownloadReport()
    {
        DataTable table = new DataTable();

        using (SqlConnection connection = new SqlConnection(_connectionString))
        {
            string query = "SELECT OrderId, CustomerName, Total, OrderDate FROM Orders";
            using SqlDataAdapter adapter = new SqlDataAdapter(query, connection);
            adapter.Fill(table);
        }

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

        // Write column headers from DataTable schema
        for (int col = 0; col < table.Columns.Count; col++)
        {
            worksheet[0, col].Value = table.Columns[col].ColumnName;
        }

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

        byte[] fileBytes = workbook.ToByteArray();
        return File(fileBytes,
            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            "Orders.xlsx");
    }
}

Ce modèle garde le contrôleur allégé et testable. La requête de la base de données et la construction du classeur sont clairement séparées, rendant aisé de changer la source de données ou d'ajouter des feuilles de travail supplémentaires pour les données résumées. Pour des conseils sur la lecture de fichiers Excel existants dans un DataTable, voir le guide IronXL sur la lecture de fichiers Excel.

Comment ClosedXML et EPPlus se comparent-ils?

ClosedXML enveloppe le SDK Open XML de Microsoft avec une API accessible. Installez-le depuis NuGet :

Install-Package ClosedXML

Install-Package ClosedXML

L'exemple suivant montre une action typique d'exportation ClosedXML :

using ClosedXML.Excel;
using Microsoft.AspNetCore.Mvc;

public class ExportController : Controller
{
    [HttpGet]
    public IActionResult ExportWithClosedXML()
    {
        using var workbook = new XLWorkbook();
        var worksheet = workbook.AddWorksheet("Data");
        worksheet.Cell(1, 1).Value = "Name";
        worksheet.Cell(1, 2).Value = "Amount";
        worksheet.Cell(2, 1).Value = "Alpha";
        worksheet.Cell(2, 2).Value = 1200;

        using var stream = new MemoryStream();
        workbook.SaveAs(stream);
        return File(stream.ToArray(),
            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            "export.xlsx");
    }
}

using ClosedXML.Excel;
using Microsoft.AspNetCore.Mvc;

public class ExportController : Controller
{
    [HttpGet]
    public IActionResult ExportWithClosedXML()
    {
        using var workbook = new XLWorkbook();
        var worksheet = workbook.AddWorksheet("Data");
        worksheet.Cell(1, 1).Value = "Name";
        worksheet.Cell(1, 2).Value = "Amount";
        worksheet.Cell(2, 1).Value = "Alpha";
        worksheet.Cell(2, 2).Value = 1200;

        using var stream = new MemoryStream();
        workbook.SaveAs(stream);
        return File(stream.ToArray(),
            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            "export.xlsx");
    }
}

Comment choisir la bonne bibliothèque pour votre projet ?

Choisir la bonne bibliothèque d'exportation Excel dépend de trois facteurs : les formats de sortie requis, les contraintes de licence de votre projet, et si vous avez besoin d'un support professionnel.

Choisissez IronXL lorsque votre application nécessite une sortie multi-format (XLSX, CSV, JSON, XML), lorsque vous construisez un produit commercial qui nécessite un canal de support garanti, ou lorsque vous avez besoin de fonctions Excel avancées telles que l'évaluation de formules, le style des cellules, ou la génération de graphiques. La documentation d'IronXL couvre en détail chaque surface API, et l'équipe de support répond directement aux titulaires de licence. Consultez le blog IronXL pour des motifs supplémentaires et des tutoriels.

Choisissez ClosedXML lorsque votre projet est open-source ou non-commercial et nécessite uniquement une sortie XLSX. La licence MIT n'impose aucune restriction sur la redistribution, et l'API est bien documentée grâce aux ressources communautaires.

Choisissez EPPlus lorsque une base de code existante utilise déjà EPPlus et que migrer vers une autre bibliothèque coûterait plus cher que d'acheter une licence commerciale.

Pour les équipes évaluant IronXL par rapport à ses alternatives, la licence d'essai IronXL permet un test complet des fonctionnalités avant de s'engager dans un achat. Des exemples de code supplémentaires pour lire et écrire des fichiers Excel sont disponibles sur la page d'exemples IronXL.

Quelles sont vos prochaines étapes ?

Maintenant que vous avez passé en revue les approches d'exportation Excel disponibles pour ASP.NET Core, vous pouvez suivre les étapes suivantes pour aller de l'avant :

• Installez IronXL en utilisant dotnet add package IronXl.Excel et parcourez le guide de démarrage pour créer votre premier classeur.
• Comparez les motifs de code en consultant la page des exemples IronXL pour des scénarios correspondant à votre cas d'utilisation, tels que l'exportation de bases de données, les classeurs multi-feuilles ou les rapports stylisés.
• Évaluez la licence en visitant la page de licence IronXL pour comprendre les options de développement, de mise en scène, et de déploiements en production.
• Explorez des formats supplémentaires en testant les méthodes SaveAsCsv, SaveAsJson, et SaveAsXml si votre application a besoin d'exporter des données dans plusieurs formats à partir du même code source.
• Migrez du code hérité en identifiant les motifs existants Response.ContentType = "application/vnd.ms-excel" dans votre solution et en les remplaçant par la création de classeurs IronXL, éliminant les avertissements de format pour vos utilisateurs.

Pour les déploiements en production, achetez une licence pour débloquer le support professionnel et garantir la conformité avec les termes de la licence IronXL.

Commencez avec IronXL maintenant.

Commencer gratuitement