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 disposent de plusieurs options pour ajouter une fonctionnalité d'exportation Excel. Chaque approche diffère par la qualité du fichier de sortie, l'effort requis pour sa mise en œuvre et les implications en matière de licences pour les projets commerciaux.

Le flux de types MIME traditionnel est la technique la plus ancienne. Le serveur définit l'en-tête Content-Type de la réponse sur 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 du balisage HTML plutôt que de véritables données de feuille de calcul. Microsoft Excel détecte l'incompatibilité et affiche un avertissement de format avant d'ouvrir le fichier. Cette méthode ne prend pas en charge les formules, les colonnes saisies ni la mise en forme correcte des cellules.

Les solutions basées sur une bibliothèque ajoutent un package NuGet qui construit de véritables fichiers XLSX utilisant le format Open XML défini par Microsoft. Les options incluent IronXL, ClosedXML et EPPlus. Tous trois produisent des fichiers Excel valides qui s'ouvrent sans avertissement, prennent en charge la mise en forme au niveau des cellules et fonctionnent avec .NET Core. La documentation officielle .NET relative aux téléchargements de fichiers décrit les mécanismes sous-jacents 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 d'écrire le moindre code d'exportation, ajoutez IronXL à votre projet via le gestionnaire de packages NuGet ou l'interface de ligne de commande .NET . IronXL ne dépend pas de Microsoft Office ni de l'interopérabilité COM, son installation est donc simple sur tout système d'exploitation pris en charge par .NET.

dotnet add package IronXl.Excel

dotnet add package IronXl.Excel

Vous pouvez également utiliser 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; à toute classe de contrôleur ou de service qui doit générer des fichiers Excel. Aucune configuration supplémentaire n'est requise pour les scénarios d'exportation de base. Pour connaître les options de licence et de déploiement , consultez la page de licence IronXL .

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

Dans les anciennes versions de WebForms et certains modèles MVC plus anciens, les développeurs exportaient les données de GridView en les rendant au format 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
}

' Traditional approach -- exports HTML disguised as Excel
Public Sub ExportToExcel(sender As Object, e As EventArgs)
    Response.Clear()
    Response.Buffer = True
    Response.ContentType = "application/vnd.ms-excel"
    Response.AddHeader("content-disposition", "attachment;filename=Report.xls")
    Dim stringWriter As New StringWriter()
    Dim htmlTextWriter As New HtmlTextWriter(stringWriter)
    ' Render grid content as HTML
    DataGrid1.RenderControl(htmlTextWriter)
    Response.Write(stringWriter.ToString())
    Response.End()
End Sub

Public Overrides Sub VerifyRenderingInServerForm(control As Control)
    ' Required to prevent server form rendering errors
End Sub

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

IronXL propose une API permettant de créer des fichiers XLSX authentiques sans nécessiter Microsoft Office ni l'interopérabilité COM. La bibliothèque construit les objets classeur entièrement en code managé, ce qui lui permet de fonctionner sous 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 une mise en forme en gras à la ligne d'en-tête et transmet 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.Now: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.Now:yyyyMMdd}.xlsx";
        return File(fileBytes,
            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
            filename);
    }
}

Imports IronXL
Imports Microsoft.AspNetCore.Mvc

Public Class ExportController
    Inherits Controller

    <HttpPost>
    Public Function ExportReport() As IActionResult
        ' Create workbook and worksheet
        Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
        Dim worksheet As 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.0
        worksheet("A3").Value = "Widget B"
        worksheet("B3").Value = 230
        worksheet("C3").Value = 6900.0

        ' Apply bold formatting to headers
        Dim headerRange = worksheet("A1:C1")
        headerRange.Style.Font.Bold = True

        ' Stream file to browser
        Dim fileBytes As Byte() = workbook.ToByteArray()
        Dim filename As String = $"SalesReport_{DateTime.Now:yyyyMMdd}.xlsx"
        Return File(fileBytes, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", filename)
    End Function
End Class

// 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 l'intégration de DataTable et des bases de données ?

De nombreuses applications ASP.NET Core récupèrent des données depuis SQL Server ou une autre base de données relationnelle avant de les exporter. IronXL offre une prise en charge de premier ordre pour charger un DataTable directement dans une feuille de calcul, éliminant ainsi le besoin d'itérer manuellement les lignes.

L'exemple ci-dessous interroge une base de données à l'aide d' .NET et remplit une feuille de calcul Excel à partir du résultat.

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

Imports IronXL
Imports System.Data
Imports System.Data.SqlClient
Imports Microsoft.AspNetCore.Mvc

Public Class ReportController
    Inherits Controller

    Private ReadOnly _connectionString As String

    Public Sub New(config As IConfiguration)
        _connectionString = config.GetConnectionString("DefaultConnection")
    End Sub

    <HttpGet>
    Public Function DownloadReport() As IActionResult
        Dim table As New DataTable()

        Using connection As New SqlConnection(_connectionString)
            Dim query As String = "SELECT OrderId, CustomerName, Total, OrderDate FROM Orders"
            Using adapter As New SqlDataAdapter(query, connection)
                adapter.Fill(table)
            End Using
        End Using

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

        ' Write column headers from DataTable schema
        For col As Integer = 0 To table.Columns.Count - 1
            worksheet(0, col).Value = table.Columns(col).ColumnName
        Next

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

        Dim fileBytes As Byte() = workbook.ToByteArray()
        Return File(fileBytes, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "Orders.xlsx")
    End Function
End Class

Ce modèle permet de conserver un contrôleur simple et testable. La requête de base de données et la construction du classeur sont clairement séparées, ce qui facilite le remplacement de la source de données ou l'ajout de feuilles de calcul supplémentaires pour les données récapitulatives. Pour obtenir des conseils sur la lecture de fichiers Excel existants dans un DataTable, consultez le guide pratique IronXL sur la lecture de fichiers Excel .

Comment ClosedXML et EPPlus se comparent-ils?

ClosedXML encapsule le kit de développement logiciel Open XML de Microsoft avec une API accessible. Installez-le depuis NuGet:

Install-Package ClosedXML

Install-Package ClosedXML

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

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

Imports ClosedXML.Excel
Imports Microsoft.AspNetCore.Mvc
Imports System.IO

Public Class ExportController
    Inherits Controller

    <HttpGet>
    Public Function ExportWithClosedXML() As IActionResult
        Using workbook As New XLWorkbook()
            Dim 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 stream As New MemoryStream()
                workbook.SaveAs(stream)
                Return File(stream.ToArray(), "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "export.xlsx")
            End Using
        End Using
    End Function
End Class

Comment choisir la bibliothèque adaptée à votre projet ?

Le choix de la bibliothèque d'exportation Excel appropriée dépend de trois facteurs : les formats de sortie requis, les contraintes de licence de votre projet et votre besoin d'assistance Professional .

Choisissez IronXL lorsque votre application nécessite une sortie multiformat (XLSX, CSV, JSON, XML), lorsque vous développez un produit commercial qui requiert un canal de support garanti, ou lorsque vous avez besoin de fonctionnalités Excel avancées telles que l'évaluation de formules, la mise en forme de cellules ou la génération de graphiques. La documentation d'IronXL couvre en détail chaque interface API, et l'équipe d'assistance répond directement aux détenteurs de licence. Consultez le blog IronXL pour découvrir d'autres modèles et tutoriels.

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

Choisissez EPPlus lorsqu'une base de code existante utilise déjà EPPlus et que la migration vers une autre bibliothèque coûterait plus cher que l'achat d'une licence commerciale.

Pour les équipes qui évaluent IronXL par rapport à ses alternatives, la licence d'essai IronXL permet de tester toutes les fonctionnalités avant de s'engager dans un achat. Des exemples de code supplémentaires pour la lecture et l'écriture de fichiers Excel sont disponibles sur la page d'exemples IronXL .

Quelles sont vos prochaines étapes ?

Maintenant que vous avez passé en revue les méthodes d'exportation Excel disponibles pour ASP.NET Core, vous pouvez suivre les étapes suivantes :

• Installez IronXL en utilisant dotnet add package IronXl.Excel et suivez le guide de démarrage pour créer votre premier classeur.
• Comparez les modèles de code en consultant la page d'exemples IronXL pour trouver des scénarios correspondant à votre cas d'utilisation, tels que l'exportation de bases de données, les classeurs à plusieurs feuilles ou les rapports stylisés.
• Évaluez les options de licence en consultant la page de licences IronXL afin de comprendre les possibilités offertes pour les déploiements en développement, en préproduction et 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 de la même base de code.
• Migrez à partir du code hérité en identifiant tous les modèles Response.ContentType = "application/vnd.ms-excel" existants dans votre solution et en les remplaçant par la création de classeurs IronXL , éliminant ainsi les avertissements de format pour vos utilisateurs.

Pour les déploiements en production, achetez une licence pour bénéficier d'un support Professional et garantir la conformité aux termes de la licence IronXL .

Commencez avec IronXL maintenant.

Commencer gratuitement