ASP.NET Export to Excel: IronXL vs ClosedXML vs EPPlus Compared

What Are the Common Methods to Export Data to Excel in ASP.NET Core?

ASP.NET Core developers have several paths available when adding Excel export functionality. Each approach differs in the quality of the output file, the effort required to implement it, and the licensing implications for commercial projects.

Traditional MIME type streaming is the oldest technique. The server sets the response Content-Type header to application/vnd.ms-excel and writes an HTML table to the output stream. The browser interprets this as an Excel download, but the file contains HTML markup rather than genuine spreadsheet data. Microsoft Excel detects the mismatch and displays a format warning before opening the file. This method cannot support formulas, typed columns, or proper cell formatting.

Library-based solutions add a NuGet package that constructs genuine XLSX files using the Open XML format defined by Microsoft. Options include IronXL, ClosedXML, and EPPlus. All three produce valid Excel files that open without warnings, support cell-level formatting, and work with .NET Core. The official .NET documentation for file downloads covers the underlying ASP.NET Core mechanisms used by all these approaches.

The table below summarises key differences:

How Do You Install IronXL in an ASP.NET Core Project?

Before writing any export code, add IronXL to your project through the NuGet Package Manager or the .NET CLI. IronXL has no dependency on Microsoft Office or COM interop, so installation is straightforward on any operating system supported by .NET.

dotnet add package IronXL.Excel

dotnet add package IronXL.Excel

Alternatively, use the Package Manager Console in Visual Studio:

Install-Package IronXL.Excel

Install-Package IronXL.Excel

Once the package is installed, add using IronXL; to any controller or service class that needs to generate Excel files. No additional configuration is required for basic export scenarios. For licensing and deployment options, visit the IronXL licensing page.

How Does the Traditional GridView Export Approach Work?

In legacy WebForms and some older MVC patterns, developers exported GridView data by rendering it as HTML and streaming it to the browser with a misleading Content-Type header. The application calls Response.AddHeader to set the filename and writes the HTML output directly.

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

How Does IronXL Simplify Excel File Generation in ASP.NET Core?

IronXL provides an API for creating genuine XLSX files without requiring Microsoft Office or COM interop. The library constructs workbook objects entirely in managed code, so it runs on Linux, macOS, and Windows without additional dependencies.

The following example creates a workbook, populates a worksheet with sales data, applies bold formatting to the header row, and streams the file to the browser:

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

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

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

How Does IronXL Handle DataTable and Database Integration?

Many ASP.NET Core applications fetch data from SQL Server or another relational database before exporting it. IronXL provides first-class support for loading a DataTable directly into a worksheet, eliminating the need to iterate rows manually.

The example below queries a database using ADO.NET and populates an Excel worksheet from the resulting DataTable:

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

This pattern keeps the controller lean and testable. The database query and workbook construction are clearly separated, making it straightforward to swap out the data source or add additional worksheets for summary data. For guidance on reading existing Excel files into a DataTable, see the IronXL how-to guide on reading Excel files.

How Do ClosedXML and EPPlus Compare?

ClosedXML wraps Microsoft's Open XML SDK with an accessible API. Install it from NuGet:

Install-Package ClosedXML

Install-Package ClosedXML

The following example shows a typical ClosedXML export action:

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

How Do You Choose the Right Library for Your Project?

Selecting the correct Excel export library depends on three factors: the output formats required, the licensing constraints of your project, and whether you need professional support.

Choose IronXL when your application needs multi-format output (XLSX, CSV, JSON, XML), when you are building a commercial product that requires a guaranteed support channel, or when you need advanced Excel features such as formula evaluation, cell styling, or chart generation. IronXL's documentation covers every API surface in detail, and the support team responds to licence holders directly. Review the IronXL blog for additional patterns and tutorials.

Choose ClosedXML when your project is open-source or non-commercial and requires only XLSX output. The MIT licence imposes no restrictions on redistribution, and the API is well-documented through community resources.

Choose EPPlus when an existing codebase already uses EPPlus and migrating to another library would cost more than purchasing a commercial licence.

For teams evaluating IronXL against its alternatives, the IronXL trial licence allows full-featured testing before committing to a purchase. Additional code examples for reading and writing Excel files are available on the IronXL examples page.

What Are Your Next Steps?

Now that you have reviewed the available Excel export approaches for ASP.NET Core, you can take the following steps to move forward:

• Install IronXL using dotnet add package IronXL.Excel and run through the getting started guide to create your first workbook.
• Compare code patterns by reviewing the IronXL examples page for scenarios that match your use case, such as database export, multi-sheet workbooks, or styled reports.
• Evaluate licensing by visiting the IronXL licensing page to understand the options for development, staging, and production deployments.
• Explore additional formats by testing the SaveAsCsv, SaveAsJson, and SaveAsXml methods if your application needs to export data in multiple formats from the same codebase.
• Migrate from legacy code by identifying any existing Response.ContentType = "application/vnd.ms-excel" patterns in your solution and replacing them with IronXL workbook creation, eliminating format warnings for your users.

For production deployments, purchase a licence to unlock professional support and ensure compliance with the IronXL licence terms.

Get stated with IronXL now.

Start for Free