Ícono de mensaje
Saltar al pie de página
  1. Iron Software
  2. Blog de IronXL
  3. Usando IronXL
  4. Exportar vista de cuadrícula a Excel XLSX
USANDO IRONXL

Cómo exportar GridView a Excel XLSX en C# con IronXL

Curtis Chau
Curtis Chau
Actualizado:

Exportación de datos desde un GridView ASP.NET a un archivo de Excel

Puede exportar un GridView de ASP.NET a un archivo Excel XLSX en C# instalando IronXL, creando un WorkBook, iterando sobre las filas de GridView, escribiendo cada valor de celda en la posición correspondiente de la hoja de trabajo, y guardando el libro de trabajo en el disco o en el flujo de respuesta HTTP. Este enfoque no requiere la instalación de Microsoft Office en el servidor y funciona de forma fiable en aplicaciones web de .NET Framework, .NET Core y .NET 5 hasta .NET 10.

La exportación de datos de GridView a Excel es un requisito estándar en los proyectos empresariales de formularios web ASP.NET. Los usuarios necesitan extraer datos tabulares del navegador y pasarlos a hojas de cálculo para la elaboración de informes, el análisis sin conexión y el archivo. El desafío es cerrar la brecha entre el control del lado del servidor GridView y un archivo .xlsx correctamente estructurado, sin introducir dependencias de Office Interop que fallan en entornos de servidores web.

Esta guía lo lleva a través de tres patrones de exportación progresivamente más ricos: una exportación mínima fila por fila, una exportación con encabezados y datos con ajuste automático de columnas, y una exportación impulsada por DataTable que evita completamente el HTML renderizado. Cada ejemplo utiliza código compatible con sentencias de nivel superior de C# y la API de IronXL.

¿Cómo se instala IronXL en un proyecto ASP.NET?

Abre la Consola de Administrador de Paquetes en Visual Studio y ejecuta:

Install-Package IronXL.Excel

Alternativamente, haga clic derecho en el proyecto en Explorador de Soluciones, elija Administrar paquetes NuGet, busque IronXL, y haga clic en Instalar. NuGet resuelve todas las dependencias transitivas automáticamente.

Después de instalar el paquete, agregue las siguientes directivas using a su archivo de código subyacente:

using System;
using System.Data;
using System.Web.UI;
using IronXL;
using System;
using System.Data;
using System.Web.UI;
using IronXL;
Imports System
Imports System.Data
Imports System.Web.UI
Imports IronXL
$vbLabelText   $csharpLabel

IronXL es compatible con .NET Framework 4.6.2 y versiones posteriores, así como con .NET Core 3.1 y desde .NET 5 hasta .NET 10. No se requiere la instalación de Office ni el registro COM en el servidor. La documentación completa de la API está disponible en la referencia de objetos de IronXL.

¿Qué ID de paquete NuGet debes utilizar?

El ID del paquete correcto es IronXL (no IronXL.Excel, que es un alias heredado). Después de la instalación, el ensamblado IronXL.dll se referencia automáticamente. Puede verificar la versión instalada revisando el nodo Paquetes en el Explorador de Soluciones o ejecutando dotnet list package desde el directorio del proyecto.

¿Funciona IronXL en aplicaciones web ASP.NET Core?

Sí. La misma API funciona tanto en proyectos ASP.NET Web Forms como en proyectos ASP.NET Core (MVC o Razor Pages). En proyectos Core, reemplace Server.MapPath con IWebHostEnvironment.WebRootPath o Path.Combine(Directory.GetCurrentDirectory(), "Exports") al construir rutas de archivo del lado del servidor.

¿Cómo se exporta un GridView a un archivo de Excel?

El patrón de exportación más simple itera sobre cada fila renderizada en el GridView y copia el texto de cada celda a la celda correspondiente de la hoja de trabajo de Excel. En el marcado ASPX, agregue un control <asp:GridView ID="gvEmployees" runat="server" AutoGenerateColumns="true" /> y un botón <asp:Button ID="btnExport" runat="server" Text="Export to Excel" OnClick="btnExport_Click" />. El atributo runat="server" hace que ambos controles sean accesibles en el código subyacente.

El código subyacente vincula los datos de ejemplo en la primera carga y los exporta al hacer clic en el botón:

using System;
using System.Data;
using System.Web.UI;
using IronXL;

public partial class GridViewExport : Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        if (!IsPostBack)
        {
            BindGridView();
        }
    }

    private void BindGridView()
    {
        DataTable dt = new DataTable();
        dt.Columns.Add("EmployeeID", typeof(int));
        dt.Columns.Add("Name", typeof(string));
        dt.Columns.Add("Department", typeof(string));
        dt.Columns.Add("Salary", typeof(decimal));

        dt.Rows.Add(1, "John Smith", "Engineering", 75000);
        dt.Rows.Add(2, "Sarah Johnson", "Marketing", 65000);
        dt.Rows.Add(3, "Michael Chen", "Finance", 70000);

        ViewState["EmployeeData"] = dt;
        gvEmployees.DataSource = dt;
        gvEmployees.DataBind();
    }

    protected void btnExport_Click(object sender, EventArgs e)
    {
        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet worksheet = workbook.CreateWorkSheet("Employees");

        // Write header row
        for (int j = 0; j < gvEmployees.HeaderRow.Cells.Count; j++)
        {
            worksheet.SetCellValue(0, j, gvEmployees.HeaderRow.Cells[j].Text);
        }

        // Write data rows
        for (int i = 0; i < gvEmployees.Rows.Count; i++)
        {
            for (int j = 0; j < gvEmployees.Rows[i].Cells.Count; j++)
            {
                worksheet.SetCellValue(i + 1, j, gvEmployees.Rows[i].Cells[j].Text);
            }
        }

        string filePath = Server.MapPath("~/Exports/EmployeeData.xlsx");
        workbook.SaveAs(filePath);
    }
}
using System;
using System.Data;
using System.Web.UI;
using IronXL;

public partial class GridViewExport : Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        if (!IsPostBack)
        {
            BindGridView();
        }
    }

    private void BindGridView()
    {
        DataTable dt = new DataTable();
        dt.Columns.Add("EmployeeID", typeof(int));
        dt.Columns.Add("Name", typeof(string));
        dt.Columns.Add("Department", typeof(string));
        dt.Columns.Add("Salary", typeof(decimal));

        dt.Rows.Add(1, "John Smith", "Engineering", 75000);
        dt.Rows.Add(2, "Sarah Johnson", "Marketing", 65000);
        dt.Rows.Add(3, "Michael Chen", "Finance", 70000);

        ViewState["EmployeeData"] = dt;
        gvEmployees.DataSource = dt;
        gvEmployees.DataBind();
    }

    protected void btnExport_Click(object sender, EventArgs e)
    {
        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet worksheet = workbook.CreateWorkSheet("Employees");

        // Write header row
        for (int j = 0; j < gvEmployees.HeaderRow.Cells.Count; j++)
        {
            worksheet.SetCellValue(0, j, gvEmployees.HeaderRow.Cells[j].Text);
        }

        // Write data rows
        for (int i = 0; i < gvEmployees.Rows.Count; i++)
        {
            for (int j = 0; j < gvEmployees.Rows[i].Cells.Count; j++)
            {
                worksheet.SetCellValue(i + 1, j, gvEmployees.Rows[i].Cells[j].Text);
            }
        }

        string filePath = Server.MapPath("~/Exports/EmployeeData.xlsx");
        workbook.SaveAs(filePath);
    }
}
Imports System
Imports System.Data
Imports System.Web.UI
Imports IronXL

Public Partial Class GridViewExport
    Inherits Page

    Protected Sub Page_Load(sender As Object, e As EventArgs)
        If Not IsPostBack Then
            BindGridView()
        End If
    End Sub

    Private Sub BindGridView()
        Dim dt As New DataTable()
        dt.Columns.Add("EmployeeID", GetType(Integer))
        dt.Columns.Add("Name", GetType(String))
        dt.Columns.Add("Department", GetType(String))
        dt.Columns.Add("Salary", GetType(Decimal))

        dt.Rows.Add(1, "John Smith", "Engineering", 75000)
        dt.Rows.Add(2, "Sarah Johnson", "Marketing", 65000)
        dt.Rows.Add(3, "Michael Chen", "Finance", 70000)

        ViewState("EmployeeData") = dt
        gvEmployees.DataSource = dt
        gvEmployees.DataBind()
    End Sub

    Protected Sub btnExport_Click(sender As Object, e As EventArgs)
        Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
        Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Employees")

        ' Write header row
        For j As Integer = 0 To gvEmployees.HeaderRow.Cells.Count - 1
            worksheet.SetCellValue(0, j, gvEmployees.HeaderRow.Cells(j).Text)
        Next

        ' Write data rows
        For i As Integer = 0 To gvEmployees.Rows.Count - 1
            For j As Integer = 0 To gvEmployees.Rows(i).Cells.Count - 1
                worksheet.SetCellValue(i + 1, j, gvEmployees.Rows(i).Cells(j).Text)
            Next
        Next

        Dim filePath As String = Server.MapPath("~/Exports/EmployeeData.xlsx")
        workbook.SaveAs(filePath)
    End Sub
End Class
$vbLabelText   $csharpLabel

La llamada WorkBook.Create(ExcelFileFormat.XLSX) inicializa un libro de trabajo en memoria dirigido al formato moderno Open XML. CreateWorkSheet("Employees") agrega la primera hoja. El bucle externo (i) avanza a través de las filas de datos; el bucle interno (j) avanza a través de las columnas. El índice de fila i + 1 se usa para las celdas de datos de modo que el encabezado en la fila 0 no se sobrescriba.

¿Por qué utilizar IronXL en lugar de Excel Interop?

Excel Interop requiere una copia con licencia de Microsoft Excel instalada en el servidor y crea objetos COM que deben liberarse explícitamente para evitar fugas de memoria. IronXL lee y escribe archivos .xlsx directamente como paquetes Open XML -- sin COM, sin Office, sin Marshal.ReleaseComObject de plantilla. Esto la hace fiable en IIS, Azure App Service, Docker y otros entornos de servidor en los que Office no está disponible.

¿Cuál es el tipo MIME correcto para las descargas en formato XLSX?

Cuando desee que el navegador muestre un cuadro de diálogo de guardar archivo en lugar de servir los bytes en línea, establezca el tipo de contenido de la respuesta a application/vnd.openxmlformats-officedocument.spreadsheetml.sheet y agregue un encabezado Content-Disposition: attachment antes de escribir los bytes del libro de trabajo en el flujo de respuesta.

¿Cómo se añaden encabezados de columna y se ajusta automáticamente el tamaño de las columnas?

El ejemplo básico escribe encabezados extraídos de HeaderRow.Cells, pero una exportación de producción también debería ajustar automáticamente el tamaño de cada columna para que los datos sean legibles sin ajustes manuales en Excel:

protected void btnExport_Click(object sender, EventArgs e)
{
    WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
    WorkSheet worksheet = workbook.CreateWorkSheet("Employees");

    // Write column headers
    int colCount = gvEmployees.HeaderRow.Cells.Count;
    for (int i = 0; i < colCount; i++)
    {
        string header = gvEmployees.HeaderRow.Cells[i].Text;
        worksheet.SetCellValue(0, i, header);
    }

    // Write data rows
    for (int i = 0; i < gvEmployees.Rows.Count; i++)
    {
        for (int j = 0; j < gvEmployees.Rows[i].Cells.Count; j++)
        {
            worksheet.SetCellValue(i + 1, j, gvEmployees.Rows[i].Cells[j].Text);
        }
    }

    // Auto-size each column for readability
    for (int col = 0; col < colCount; col++)
    {
        worksheet.AutoSizeColumn(col);
    }

    string filePath = Server.MapPath("~/Exports/EmployeeReport.xlsx");
    workbook.SaveAs(filePath);
}
protected void btnExport_Click(object sender, EventArgs e)
{
    WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
    WorkSheet worksheet = workbook.CreateWorkSheet("Employees");

    // Write column headers
    int colCount = gvEmployees.HeaderRow.Cells.Count;
    for (int i = 0; i < colCount; i++)
    {
        string header = gvEmployees.HeaderRow.Cells[i].Text;
        worksheet.SetCellValue(0, i, header);
    }

    // Write data rows
    for (int i = 0; i < gvEmployees.Rows.Count; i++)
    {
        for (int j = 0; j < gvEmployees.Rows[i].Cells.Count; j++)
        {
            worksheet.SetCellValue(i + 1, j, gvEmployees.Rows[i].Cells[j].Text);
        }
    }

    // Auto-size each column for readability
    for (int col = 0; col < colCount; col++)
    {
        worksheet.AutoSizeColumn(col);
    }

    string filePath = Server.MapPath("~/Exports/EmployeeReport.xlsx");
    workbook.SaveAs(filePath);
}
Protected Sub btnExport_Click(sender As Object, e As EventArgs)
    Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
    Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Employees")

    ' Write column headers
    Dim colCount As Integer = gvEmployees.HeaderRow.Cells.Count
    For i As Integer = 0 To colCount - 1
        Dim header As String = gvEmployees.HeaderRow.Cells(i).Text
        worksheet.SetCellValue(0, i, header)
    Next

    ' Write data rows
    For i As Integer = 0 To gvEmployees.Rows.Count - 1
        For j As Integer = 0 To gvEmployees.Rows(i).Cells.Count - 1
            worksheet.SetCellValue(i + 1, j, gvEmployees.Rows(i).Cells(j).Text)
        Next
    Next

    ' Auto-size each column for readability
    For col As Integer = 0 To colCount - 1
        worksheet.AutoSizeColumn(col)
    Next

    Dim filePath As String = Server.MapPath("~/Exports/EmployeeReport.xlsx")
    workbook.SaveAs(filePath)
End Sub
$vbLabelText   $csharpLabel

AutoSizeColumn(col) instruye a IronXL a calcular el ancho óptimo de la columna basado en la longitud del contenido de la celda, imitando la acción Formato > Autoajustar ancho de columna en la aplicación de escritorio de Excel. Llamarla en un bucle después de escribir todos los datos es más eficiente que llamarla después de cada fila, ya que en ese momento se conoce el contenido final.

Para opciones de estilo adicionales -- encabezados en negrita, colores de fondo, formatos de número -- explora el tutorial de estilo de celdas de IronXL. También puedes fusionar celdas para crear títulos de informes que abarquen múltiples columnas.

¿Cómo se aplica el formato en negrita a las celdas de encabezado?

Use el objeto IStyle devuelto por worksheet["A1"].Style (o un rango). Establezca Font.Bold = true antes o después de escribir valores -- el estilo está desacoplado del contenido de las celdas:

// Bold the entire header row (columns A through D)
var headerRange = worksheet["A1:D1"];
headerRange.Style.Font.Bold = true;
headerRange.Style.BackgroundColor = "#4472C4";
headerRange.Style.Font.FontColor = "#FFFFFF";
// Bold the entire header row (columns A through D)
var headerRange = worksheet["A1:D1"];
headerRange.Style.Font.Bold = true;
headerRange.Style.BackgroundColor = "#4472C4";
headerRange.Style.Font.FontColor = "#FFFFFF";
' Bold the entire header row (columns A through D)
Dim headerRange = worksheet("A1:D1")
headerRange.Style.Font.Bold = True
headerRange.Style.BackgroundColor = "#4472C4"
headerRange.Style.Font.FontColor = "#FFFFFF"
$vbLabelText   $csharpLabel

Este patrón se aplica de manera uniforme a rangos de cualquier tamaño. Para obtener una lista completa de las propiedades de estilo, consulte la referencia de la API de estilo de IronXL.

¿Cómo se exportan datos directamente desde una DataTable?

Iterar sobre las filas GridView renderizadas vincula su exportación al estado visual actual del control, que puede verse afectado por el paginado, el ordenamiento y las configuraciones de visibilidad de columnas. Exportar desde el DataTable subyacente almacenado en ViewState produce un resultado determinista independientemente de cómo se configure la cuadrícula:

protected void btnExport_Click(object sender, EventArgs e)
{
    DataTable sourceData = ViewState["EmployeeData"] as DataTable;
    if (sourceData == null)
    {
        Response.Write("No data available to export.");
        return;
    }

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

    // Column headers from DataTable schema
    for (int i = 0; i < sourceData.Columns.Count; i++)
    {
        worksheet.SetCellValue(0, i, sourceData.Columns[i].ColumnName);
    }

    // Data rows from DataRow objects
    for (int i = 0; i < sourceData.Rows.Count; i++)
    {
        for (int j = 0; j < sourceData.Columns.Count; j++)
        {
            worksheet.SetCellValue(i + 1, j, sourceData.Rows[i][j].ToString());
        }
    }

    string filePath = Server.MapPath("~/Exports/DataExport.xlsx");
    workbook.SaveAs(filePath);
}
protected void btnExport_Click(object sender, EventArgs e)
{
    DataTable sourceData = ViewState["EmployeeData"] as DataTable;
    if (sourceData == null)
    {
        Response.Write("No data available to export.");
        return;
    }

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

    // Column headers from DataTable schema
    for (int i = 0; i < sourceData.Columns.Count; i++)
    {
        worksheet.SetCellValue(0, i, sourceData.Columns[i].ColumnName);
    }

    // Data rows from DataRow objects
    for (int i = 0; i < sourceData.Rows.Count; i++)
    {
        for (int j = 0; j < sourceData.Columns.Count; j++)
        {
            worksheet.SetCellValue(i + 1, j, sourceData.Rows[i][j].ToString());
        }
    }

    string filePath = Server.MapPath("~/Exports/DataExport.xlsx");
    workbook.SaveAs(filePath);
}
Protected Sub btnExport_Click(sender As Object, e As EventArgs)
    Dim sourceData As DataTable = TryCast(ViewState("EmployeeData"), DataTable)
    If sourceData Is Nothing Then
        Response.Write("No data available to export.")
        Return
    End If

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

    ' Column headers from DataTable schema
    For i As Integer = 0 To sourceData.Columns.Count - 1
        worksheet.SetCellValue(0, i, sourceData.Columns(i).ColumnName)
    Next

    ' Data rows from DataRow objects
    For i As Integer = 0 To sourceData.Rows.Count - 1
        For j As Integer = 0 To sourceData.Columns.Count - 1
            worksheet.SetCellValue(i + 1, j, sourceData.Rows(i)(j).ToString())
        Next
    Next

    Dim filePath As String = Server.MapPath("~/Exports/DataExport.xlsx")
    workbook.SaveAs(filePath)
End Sub
$vbLabelText   $csharpLabel

Los nombres de las columnas provienen de DataTable.Columns[i].ColumnName, que refleja el esquema de datos original en lugar de cualquier sobrescritura de nombres de visualización aplicada en la plantilla GridView. Los valores de las celdas se recuperan de objetos DataRow usando el índice de la columna, convirtiendo cada valor a string para satisfacer SetCellValue.

Este patrón es particularmente valioso cuando el GridView usa paginación -- iterar gvEmployees.Rows sólo devuelve las filas en la página visible actual, mientras que leer desde el completo DataTable exporta cada registro.

¿Qué ocurre con las exportaciones de DataTable de gran tamaño?

IronXL transmite datos de libros de trabajo de forma eficiente para grandes conjuntos de datos de Excel. Para exportaciones que superan las 100,000 filas, considere agrupar llamadas SetCellValue dentro de una operación de hoja de trabajo única en lugar de establecer celdas individuales en un bucle anidado. También puede escribir el libro de trabajo en un MemoryStream y vaciarlo al flujo Response de manera incremental para evitar mantener el archivo completo en la RAM del servidor.

¿Cómo se gestionan los errores durante la exportación?

Los manejadores de exportación de producción deben envolver las operaciones de IronXL en un bloque catch y devolver un mensaje descriptivo al usuario cuando algo salga mal. Los modos de fallo comunes incluyen un directorio ~/Exports/ inexistente, errores de permiso de archivo, y ViewState siendo nulo después de un tiempo de espera de la sesión:

protected void btnExport_Click(object sender, EventArgs e)
{
    try
    {
        DataTable sourceData = ViewState["EmployeeData"] as DataTable;
        if (sourceData == null)
            throw new InvalidOperationException("Session data has expired. Please reload the page.");

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

        for (int i = 0; i < sourceData.Columns.Count; i++)
            worksheet.SetCellValue(0, i, sourceData.Columns[i].ColumnName);

        for (int i = 0; i < sourceData.Rows.Count; i++)
            for (int j = 0; j < sourceData.Columns.Count; j++)
                worksheet.SetCellValue(i + 1, j, sourceData.Rows[i][j].ToString());

        string filePath = Server.MapPath("~/Exports/SafeExport.xlsx");
        workbook.SaveAs(filePath);

        lblStatus.Text = "Export successful. File saved to server.";
    }
    catch (Exception ex)
    {
        lblStatus.Text = $"Export failed: {ex.Message}";
    }
}
protected void btnExport_Click(object sender, EventArgs e)
{
    try
    {
        DataTable sourceData = ViewState["EmployeeData"] as DataTable;
        if (sourceData == null)
            throw new InvalidOperationException("Session data has expired. Please reload the page.");

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

        for (int i = 0; i < sourceData.Columns.Count; i++)
            worksheet.SetCellValue(0, i, sourceData.Columns[i].ColumnName);

        for (int i = 0; i < sourceData.Rows.Count; i++)
            for (int j = 0; j < sourceData.Columns.Count; j++)
                worksheet.SetCellValue(i + 1, j, sourceData.Rows[i][j].ToString());

        string filePath = Server.MapPath("~/Exports/SafeExport.xlsx");
        workbook.SaveAs(filePath);

        lblStatus.Text = "Export successful. File saved to server.";
    }
    catch (Exception ex)
    {
        lblStatus.Text = $"Export failed: {ex.Message}";
    }
}
Protected Sub btnExport_Click(sender As Object, e As EventArgs)
    Try
        Dim sourceData As DataTable = TryCast(ViewState("EmployeeData"), DataTable)
        If sourceData Is Nothing Then
            Throw New InvalidOperationException("Session data has expired. Please reload the page.")
        End If

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

        For i As Integer = 0 To sourceData.Columns.Count - 1
            worksheet.SetCellValue(0, i, sourceData.Columns(i).ColumnName)
        Next

        For i As Integer = 0 To sourceData.Rows.Count - 1
            For j As Integer = 0 To sourceData.Columns.Count - 1
                worksheet.SetCellValue(i + 1, j, sourceData.Rows(i)(j).ToString())
            Next
        Next

        Dim filePath As String = Server.MapPath("~/Exports/SafeExport.xlsx")
        workbook.SaveAs(filePath)

        lblStatus.Text = "Export successful. File saved to server."
    Catch ex As Exception
        lblStatus.Text = $"Export failed: {ex.Message}"
    End Try
End Sub
$vbLabelText   $csharpLabel

Para aplicaciones web que entregan el archivo como una descarga directa del navegador en lugar de guardarlo en el disco, use Response.BinaryWrite o escriba en Response.OutputStream después de establecer los encabezados de tipo de contenido y disposición. Asegúrese de que exista el directorio ~/Exports/ y la identidad del grupo de aplicaciones de IIS tenga permisos de escritura en él.

¿Cómo se envía el archivo XLSX como descarga desde el navegador?

Reemplace workbook.SaveAs(filePath) con una respuesta basada en flujo:

using System.IO;

// ... inside btnExport_Click after populating the worksheet ...

byte[] fileBytes;
using (MemoryStream ms = new MemoryStream())
{
    workbook.SaveAs(ms);
    fileBytes = ms.ToArray();
}

Response.Clear();
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
Response.AddHeader("Content-Disposition", "attachment; filename=EmployeeData.xlsx");
Response.BinaryWrite(fileBytes);
Response.End();
using System.IO;

// ... inside btnExport_Click after populating the worksheet ...

byte[] fileBytes;
using (MemoryStream ms = new MemoryStream())
{
    workbook.SaveAs(ms);
    fileBytes = ms.ToArray();
}

Response.Clear();
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
Response.AddHeader("Content-Disposition", "attachment; filename=EmployeeData.xlsx");
Response.BinaryWrite(fileBytes);
Response.End();
Imports System.IO

' ... inside btnExport_Click after populating the worksheet ...

Dim fileBytes As Byte()
Using ms As New MemoryStream()
    workbook.SaveAs(ms)
    fileBytes = ms.ToArray()
End Using

Response.Clear()
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
Response.AddHeader("Content-Disposition", "attachment; filename=EmployeeData.xlsx")
Response.BinaryWrite(fileBytes)
Response.End()
$vbLabelText   $csharpLabel

Este patrón evita escribir un archivo temporal en el disco. El MemoryStream se asigna en el servidor, se serializa para byte[], y se envía directamente al cliente. La llamada Response.End() vacía la respuesta e impide que se agregue marcado adicional de la página después de los datos binarios.

¿Cómo se exportan varias hojas o libros de trabajo avanzados?

Un solo WorkBook puede contener múltiples hojas, lo cual es útil cuando necesita exportar varios GridViews -- o el mismo conjunto de datos a diferentes granularidades -- en un solo archivo. Llame a workbook.CreateWorkSheet(name) una vez por cada pestaña:

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);

WorkSheet summary = workbook.CreateWorkSheet("Summary");
WorkSheet detail  = workbook.CreateWorkSheet("Detail");

// Populate summary sheet ...
// Populate detail sheet ...

workbook.SaveAs(Server.MapPath("~/Exports/FullReport.xlsx"));
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);

WorkSheet summary = workbook.CreateWorkSheet("Summary");
WorkSheet detail  = workbook.CreateWorkSheet("Detail");

// Populate summary sheet ...
// Populate detail sheet ...

workbook.SaveAs(Server.MapPath("~/Exports/FullReport.xlsx"));
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)

Dim summary As WorkSheet = workbook.CreateWorkSheet("Summary")
Dim detail As WorkSheet = workbook.CreateWorkSheet("Detail")

' Populate summary sheet ...
' Populate detail sheet ...

workbook.SaveAs(Server.MapPath("~/Exports/FullReport.xlsx"))
$vbLabelText   $csharpLabel

IronXL también admite la lectura de archivos Excel existentes, por lo que puede cargar una plantilla predefinida con la marca y el formato, introducir datos en celdas específicas y guardar el resultado, conservando los gráficos, las imágenes y los estilos que ya están en la plantilla.

Para una salida aún más rica, IronXL proporciona soporte de fórmulas de Excel, formato condicional, creación de gráficos, e incrustación de imágenes. Estas capacidades se documentan en la sección de tutoriales de IronXL.

¿En qué se diferencia IronXL de EPPlusy ClosedXML?

Característica IronXL EPPlus ClosedXML
Se requiere la instalación de Office No No No
Lectura y escritura de XLSX Sí Sí Sí
Compatibilidad con XLS (heredado) Sí No No
Exportación a CSV / TSV Sí No Parcial
API de creación de gráficos Sí Sí Limitado
Modelo de licencia Perpetuo + SaaS Polyform sin fines comerciales MIT
Compatibilidad con .NET 10 Sí Sí Sí

EPPlus pasó a una licencia comercial en la versión 5, lo que convierte a IronXL en una alternativa natural para los equipos que ya invierten en un ecosistema de bibliotecas .NET comerciales. ClosedXML sigue teniendo licencia MIT, pero ofrece compatibilidad limitada con gráficos. La elección correcta depende de las restricciones de licencia de su proyecto, las características de Excel que necesita, y si el soporte para formatos heredados .xls es un requisito.

¿Qué formatos de Excel admite IronXL?

IronXL lee y escribe .xlsx (Office Open XML), .xls (legacy BIFF8), .csv, y formatos .tsv. Puede convertir entre formatos de archivo Excel con una sola llamada de API cambiando el valor del enumerador ExcelFileFormat pasado a WorkBook.Create o cargando un archivo existente y guardándolo en un formato diferente.

¿Cuales son tus próximos pasos?

Ahora dispone de tres patrones listos para producción para exportar datos de ASP.NET GridView a archivos Excel XLSX utilizando IronXL:

  • Exportación por iteración de filas -- el camino más rápido hacia una exportación funcional desde un GridView enlazado
  • Exportación de encabezados y formato: añade ajuste automático del tamaño de las columnas y encabezados en negrita para obtener informes presentables
  • Exportación basada en DataTable: omite por completo el control renderizado para cuadrículas paginadas o filtradas

Los siguientes pasos lógicos son:

  1. Agregar una respuesta de descarga de navegador usando MemoryStream y Response.BinaryWrite para que los usuarios reciban el archivo inmediatamente sin una ruta de guardado en el servidor.
  2. Aplicar estilo de celda -- encabezados en negrita, rellenos de color de fondo y formatos de número -- usando la API de formato de IronXL.
  3. Explore los libros de trabajo de varias hojas para combinar datos resumidos y detallados en un único archivo que se entregará a las partes interesadas.
  4. Leer archivos Excel de nuevo en objetos DataTable usando la API de lectura de IronXL para flujos de trabajo de importación/exportación ida y vuelta.
  5. Inicie una prueba gratuita en ironsoftware.com/csharp/excel/ para probar todas las funciones en su proyecto con una Licencia Trial gratuita.

Para los equipos que crean procesos de generación de documentos, IronPDF se integra con IronXL para exportar hojas de cálculo directamente a PDF. Iron Suite incluye IronXL junto con IronPDF, IronOCR, IronBarcode e IronZIP a un precio combinado reducido.

Preguntas Frecuentes

¿Cuál es el propósito principal de utilizar IronXL para exportar GridView a Excel?

IronXL se utiliza principalmente para facilitar la exportación de datos desde un GridView ASP.NET a formatos Excel como XLSX, lo que garantiza un alto rendimiento y facilidad de integración en aplicaciones C#.

¿Puede IronXL manejar grandes conjuntos de datos al exportar desde GridView?

Sí, IronXL está optimizado para manejar de manera eficiente grandes conjuntos de datos durante el proceso de exportación de GridView a Excel, manteniendo la velocidad y el rendimiento.

¿Es posible personalizar la salida de Excel al utilizar IronXL?

Con IronXL, puede personalizar varios aspectos de la salida de Excel, como el formato, el estilo y la inclusión de datos o fórmulas adicionales en el archivo exportado.

¿Cómo se compara IronXL con otras bibliotecas para exportar GridView a Excel?

IronXL ofrece un enfoque más sencillo y flexible en comparación con otras bibliotecas, proporcionando soporte para formatos modernos de Excel e integración directa con aplicaciones C#.

¿IronXL admite la exportación a formatos distintos de XLSX?

Sí, IronXL admite la exportación a varios formatos de Excel, incluidos XLS, CSV y TSV, lo que proporciona versatilidad para diferentes requisitos de proyecto.

¿Cuáles son los requisitos previos para utilizar IronXL en un proyecto?

Para utilizar IronXL, necesita un entorno .NET y puede instalar IronXL a través de NuGet en su proyecto C#.

¿Puede IronXL exportar datos de GridView de forma asincrónica?

IronXL admite operaciones asincrónicas, lo que permite a los desarrolladores exportar datos de GridView a archivos Excel sin bloquear el hilo principal de la aplicación.

¿Cómo puedo comenzar a utilizar IronXL para exportar GridView a Excel?

Para comenzar, consulte la documentación y los ejemplos de IronXL, que brindan orientación paso a paso sobre cómo configurar y ejecutar exportaciones de datos de GridView a Excel.

Curtis Chau
Curtis Chau
  Chatea con el equipo de ingeniería ahora
Escritor Técnico

Curtis Chau tiene una licenciatura en Ciencias de la Computación (Carleton University) y se especializa en el desarrollo front-end con experiencia en Node.js, TypeScript, JavaScript y React. Apasionado por crear interfaces de usuario intuitivas y estéticamente agradables, disfruta trabajando con frameworks modernos y creando manuales bien ...

Leer más

Artículos Relacionados

Prueba de 30 días → Producto completo. Sin límites. Sin tarjeta. Prueba gratis

Equipo de soporte de Iron

Estamos disponibles online las 24 horas, 5 días a la semana.
Chat
Email
Llámame