Ícono de mensaje
Saltar al pie de página
  1. Iron Software
  2. Blog de IronXL
  3. Usando IronXL
  4. Exportar a Excel desde Gridview
USANDO IRONXL

Cómo exportar a Excel desde GridView en C# usando IronXL

Jordi Bardia
Jordi Bardia
Actualizado:

La exportación de datos de GridView a un archivo Excel auténtico es uno de los requisitos más comunes en las aplicaciones web ASP.NET. Los enfoques tradicionales que utilizan HtmlTextWriter y StringWriter crean archivos Excel falsos que activan advertencias del navegador y errores de formato cuando los usuarios intentan abrirlos. Esta guía le muestra cómo exportar datos de GridView a archivos .xlsx con el formato adecuado utilizando IronXL, lo que elimina los quebraderos de cabeza a los que se enfrentan los desarrolladores con los métodos tradicionales.

¿Por qué el método tradicional de exportación de GridView causa problemas?

El método clásico para exportar a Excel desde GridView en ASP.NET C# implica renderizar HTML y establecer encabezados Response con valores de nombre de archivo adjunto Content-Disposition. Este enfoque requiere anular public override void VerifyRenderingInServerForm para evitar errores en tiempo de ejecución. El archivo resultante no es un archivo Excel auténtico, sino HTML camuflado con la extensión .xls, lo que hace que Excel muestre mensajes de advertencia cuando los usuarios lo abren.

En concreto, la técnica tradicional presenta los siguientes inconvenientes:

  • Excel muestra una advertencia que dice "El formato y la extensión del archivo no coinciden" cada vez que se abre
  • Se pierden el formato y los tipos de datos porque estos se almacenan como HTML sin procesar
  • Debes implementar VerifyRenderingInServerForm como solución alternativa, lo que añade deuda técnica a tu proyecto
  • El archivo resultante carece de metadatos de celda adecuados, lo que lo hace inutilizable para herramientas de automatización o generación de informes posteriores

IronXL resuelve estos problemas creando archivos Excel auténticos .xlsx sin necesidad de instalar Microsoft Office en el servidor. Obtendrá un archivo que cualquier aplicación de hoja de cálculo puede abrir correctamente, conservando los tipos de datos, el estilo y la estructura OOXML adecuados.

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

Antes de escribir cualquier lógica de exportación, añade IronXL a tu proyecto utilizando el Gestor de paquetes NuGet. Abra la consola del gestor de paquetes en Visual Studio y ejecute:

Install-Package IronXl.Excel
Install-Package IronXl.Excel
SHELL

También puede buscar IronXl.Excel en la interfaz de usuario del Gestor de paquetes de NuGet e instalarlo desde allí. Una vez instalado, puede hacer referencia al espacio de nombres IronXL en cualquier archivo de código subyacente.

IronXL está destinado a .NET Standard 2.0 y versiones posteriores, por lo que funciona tanto con proyectos modernos de ASP.NET Core como con aplicaciones clásicas de ASP.NET Framework. No se requiere interoperabilidad COM, instalación de Office ni dependencias nativas adicionales en su servidor web.

Para obtener más detalles, consulte la guía de instalación de IronXL y la página del paquete NuGet de IronXL.

¿Cómo se configura el GridView de ASP.NET para la exportación?

Crea tu página Default.aspx con un control GridView y un botón de exportación. El marcado es el estándar de Web Forms:

<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Default.aspx.cs" Inherits="GridViewExportTest.Default" %>
<!DOCTYPE html>
<html>
<head runat="server">
    <title>Export GridView to Excel</title>
</head>
<body>
    <form id="form1" runat="server">
        <div>
            <h2>IronXL GridView Export Demo</h2>
            <asp:GridView ID="GridView1" runat="server" AutoGenerateColumns="true"
                HeaderStyle-BackColor="#3AC0F2" HeaderStyle-ForeColor="White" CellPadding="5">
            </asp:GridView>
            <br />
            <asp:Button ID="btnExport" runat="server" Text="Export to Excel (.xlsx)"
                OnClick="btnExport_Click" />
        </div>
    </form>
</body>
</html>
<%@ Page Language="C#" AutoEventWireup="true" CodeBehind="Default.aspx.cs" Inherits="GridViewExportTest.Default" %>
<!DOCTYPE html>
<html>
<head runat="server">
    <title>Export GridView to Excel</title>
</head>
<body>
    <form id="form1" runat="server">
        <div>
            <h2>IronXL GridView Export Demo</h2>
            <asp:GridView ID="GridView1" runat="server" AutoGenerateColumns="true"
                HeaderStyle-BackColor="#3AC0F2" HeaderStyle-ForeColor="White" CellPadding="5">
            </asp:GridView>
            <br />
            <asp:Button ID="btnExport" runat="server" Text="Export to Excel (.xlsx)"
                OnClick="btnExport_Click" />
        </div>
    </form>
</body>
</html>
$vbLabelText   $csharpLabel

Este marcado crea una página sencilla con un enlace GridView y un botón que activa la exportación. El atributo AutoGenerateColumns="true" significa que la cuadrícula lee los nombres de las columnas directamente desde el DataTable vinculado.

Vinculación de datos de muestra a GridView

En el código subyacente, vincule un DataTable a la cuadrícula y guárdelo en Session para su uso posterior durante el postback de exportación:

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

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

        private void BindGridView()
        {
            DataTable dt = new DataTable("Employees");
            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, "Mike Wilson", "Sales", 70000);
            dt.Rows.Add(4, "Emily Davis", "Engineering", 80000);

            GridView1.DataSource = dt;
            GridView1.DataBind();

            // Store DataTable in Session for export postback
            Session["GridData"] = dt;
        }
    }
}
using System;
using System.Data;
using System.Web.UI;
using IronXL;

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

        private void BindGridView()
        {
            DataTable dt = new DataTable("Employees");
            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, "Mike Wilson", "Sales", 70000);
            dt.Rows.Add(4, "Emily Davis", "Engineering", 80000);

            GridView1.DataSource = dt;
            GridView1.DataBind();

            // Store DataTable in Session for export postback
            Session["GridData"] = dt;
        }
    }
}
Imports System
Imports System.Data
Imports System.Web.UI
Imports IronXL

Namespace GridViewExport
    Partial Public Class [Default]
        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("Employees")
            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, "Mike Wilson", "Sales", 70000)
            dt.Rows.Add(4, "Emily Davis", "Engineering", 80000)

            GridView1.DataSource = dt
            GridView1.DataBind()

            ' Store DataTable in Session for export postback
            Session("GridData") = dt
        End Sub
    End Class
End Namespace
$vbLabelText   $csharpLabel

Al almacenar el DataTable en Session se evita volver a consultar la base de datos o reconstruir los datos durante el postback activado por el botón de exportación. Para aplicaciones reales, sustituya las filas codificadas de forma rígida por una consulta a la base de datos utilizando Entity Framework o ADO.NET.

Exportar a Excel desde GridView en ASP .NET C#: una solución limpia en C#: Imagen 1 - Interfaz de usuario que muestra los datos de ejemplo de GridView

¿Cómo se exportan los datos de GridView a Excel utilizando IronXL?

El enfoque limpio de la exportación de GridView convierte su DataTable en un IronXL WorkBook y transmite el resultado directamente al navegador. Este es el método de exportación completo:

protected void btnExport_Click(object sender, EventArgs e)
{
    ExportGridViewToExcel();
}

private void ExportGridViewToExcel()
{
    DataTable dt = (DataTable)Session["GridData"];

    // Create a workbook and load data from the DataTable
    WorkBook workbook = WorkBook.Create();
    WorkBook.LoadWorkSheetsFromDataSet(new DataSet { Tables = { dt } }, workbook);
    WorkSheet worksheet = workbook.DefaultWorkSheet;

    // Apply header row formatting
    var headerRange = worksheet["A1:D1"];
    headerRange.Style.Font.Bold = true;
    headerRange.Style.Font.Size = 12;
    headerRange.Style.SetBackgroundColor("#3AC0F2");

    // Stream the file to the browser
    string filename = "GridViewExport_" + DateTime.Now.ToString("yyyyMMdd") + ".xlsx";
    Response.Clear();
    Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
    Response.AddHeader("content-disposition", "attachment;filename=" + filename);
    workbook.SaveAsStream(Response.OutputStream, IronXl.Enum.FileFormat.Xlsx);
    Response.Flush();
    Response.End();
}
protected void btnExport_Click(object sender, EventArgs e)
{
    ExportGridViewToExcel();
}

private void ExportGridViewToExcel()
{
    DataTable dt = (DataTable)Session["GridData"];

    // Create a workbook and load data from the DataTable
    WorkBook workbook = WorkBook.Create();
    WorkBook.LoadWorkSheetsFromDataSet(new DataSet { Tables = { dt } }, workbook);
    WorkSheet worksheet = workbook.DefaultWorkSheet;

    // Apply header row formatting
    var headerRange = worksheet["A1:D1"];
    headerRange.Style.Font.Bold = true;
    headerRange.Style.Font.Size = 12;
    headerRange.Style.SetBackgroundColor("#3AC0F2");

    // Stream the file to the browser
    string filename = "GridViewExport_" + DateTime.Now.ToString("yyyyMMdd") + ".xlsx";
    Response.Clear();
    Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
    Response.AddHeader("content-disposition", "attachment;filename=" + filename);
    workbook.SaveAsStream(Response.OutputStream, IronXl.Enum.FileFormat.Xlsx);
    Response.Flush();
    Response.End();
}
Imports System
Imports System.Data
Imports IronXL

Protected Sub btnExport_Click(sender As Object, e As EventArgs)
    ExportGridViewToExcel()
End Sub

Private Sub ExportGridViewToExcel()
    Dim dt As DataTable = DirectCast(Session("GridData"), DataTable)

    ' Create a workbook and load data from the DataTable
    Dim workbook As WorkBook = WorkBook.Create()
    WorkBook.LoadWorkSheetsFromDataSet(New DataSet With {.Tables = {dt}}, workbook)
    Dim worksheet As WorkSheet = workbook.DefaultWorkSheet

    ' Apply header row formatting
    Dim headerRange = worksheet("A1:D1")
    headerRange.Style.Font.Bold = True
    headerRange.Style.Font.Size = 12
    headerRange.Style.SetBackgroundColor("#3AC0F2")

    ' Stream the file to the browser
    Dim filename As String = "GridViewExport_" & DateTime.Now.ToString("yyyyMMdd") & ".xlsx"
    Response.Clear()
    Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
    Response.AddHeader("content-disposition", "attachment;filename=" & filename)
    workbook.SaveAsStream(Response.OutputStream, IronXl.Enum.FileFormat.Xlsx)
    Response.Flush()
    Response.End()
End Sub
$vbLabelText   $csharpLabel

Cómo funciona la exportación paso a paso

El proceso se divide en tres pasos lógicos:

  1. Recuperar la DataTable -- Session["GridData"] devuelve el mismo DataTable que estaba vinculado a la cuadrícula. Esto evita llamadas duplicadas a la base de datos.
  2. Crear el libro de trabajo -- WorkBook.LoadWorkSheetsFromDataSet crea automáticamente una hoja de cálculo por cada DataTable en el DataSet, copiando los encabezados de columna y los valores de fila en las celdas correspondientes.
  3. Transmisión al navegador: al establecer Content-Type como tipo MIME OOXML y escribir en Response.OutputStream, se inicia una descarga en el navegador con la extensión correcta .xlsx. No se escribe ningún archivo temporal en el disco.

Esto difiere fundamentalmente del enfoque heredado HtmlTextWriter. El archivo exportado utiliza el formato Open XML —el mismo formato que utiliza Microsoft Excel de forma nativa—, por lo que se abre sin avisos.

Para obtener más información sobre cómo cargar datos mediante programación, consulte la documentación de IronXL WorkBook y cómo exportar DataTable a Excel en C#.

Exportar a Excel desde GridView en ASP .NET C#: una solución limpia en C#: Imagen 2 - Archivo Excel exportado

¿Cómo se ahorra el archivo de Excel en el disco en lugar de transmitirlo?

Si su aplicación necesita archivar las exportaciones en el servidor antes de proporcionar un enlace de descarga al usuario, guarde el libro de trabajo en una ruta de archivo en lugar de transmitirlo a Response.OutputStream:

private void SaveExcelToDisk(WorkBook workbook, string exportFolder)
{
    // Ensure the exports directory exists
    if (!System.IO.Directory.Exists(exportFolder))
    {
        System.IO.Directory.CreateDirectory(exportFolder);
    }

    string timestamp = DateTime.Now.ToString("yyyyMMdd_HHmmss");
    string filename = System.IO.Path.Combine(exportFolder, $"Report_{timestamp}.xlsx");

    workbook.SaveAs(filename);

    // Return the relative path for generating a download link
    string relativePath = "~/Exports/Report_" + timestamp + ".xlsx";
    Response.Write($"<script>alert('File saved to {relativePath}');</script>");
}
private void SaveExcelToDisk(WorkBook workbook, string exportFolder)
{
    // Ensure the exports directory exists
    if (!System.IO.Directory.Exists(exportFolder))
    {
        System.IO.Directory.CreateDirectory(exportFolder);
    }

    string timestamp = DateTime.Now.ToString("yyyyMMdd_HHmmss");
    string filename = System.IO.Path.Combine(exportFolder, $"Report_{timestamp}.xlsx");

    workbook.SaveAs(filename);

    // Return the relative path for generating a download link
    string relativePath = "~/Exports/Report_" + timestamp + ".xlsx";
    Response.Write($"<script>alert('File saved to {relativePath}');</script>");
}
Private Sub SaveExcelToDisk(workbook As WorkBook, exportFolder As String)
    ' Ensure the exports directory exists
    If Not System.IO.Directory.Exists(exportFolder) Then
        System.IO.Directory.CreateDirectory(exportFolder)
    End If

    Dim timestamp As String = DateTime.Now.ToString("yyyyMMdd_HHmmss")
    Dim filename As String = System.IO.Path.Combine(exportFolder, $"Report_{timestamp}.xlsx")

    workbook.SaveAs(filename)

    ' Return the relative path for generating a download link
    Dim relativePath As String = "~/Exports/Report_" & timestamp & ".xlsx"
    Response.Write($"<script>alert('File saved to {relativePath}');</script>")
End Sub
$vbLabelText   $csharpLabel

Elegir entre streaming y guardado en disco

Comparación entre estrategias de exportación por streaming y con guardado en disco
Estrategia Ventajas Contras Mejor para
Transmisión al navegador Sin uso de disco, entrega inmediata No se puede archivar ni reenviar Exportaciones de usuarios bajo demanda
Guardar en disco El archivo se conserva para auditorías, nuevas descargas o envío por correo electrónico Requiere tareas de limpieza y gestión del espacio en disco Informes programados, registros de auditoría

Para la mayoría de las aplicaciones web interactivas, la transmisión directa al navegador es la opción adecuada. Ahorre el archivo en el disco cuando necesite enviarlo por correo electrónico, almacenarlo por motivos de cumplimiento normativo o permitir su descarga posterior desde una página de gestión de archivos.

¿Cómo se aplica el formato avanzado a la hoja de Excel exportada?

IronXL le ofrece un control minucioso sobre los estilos de celda, el ancho de las columnas, los formatos numéricos y mucho más. El siguiente ejemplo muestra cómo crear una exportación con un estilo profesional:

private void ExportWithFormatting()
{
    DataTable dt = new DataTable("Products");
    dt.Columns.Add("Product", typeof(string));
    dt.Columns.Add("Category", typeof(string));
    dt.Columns.Add("Price", typeof(decimal));
    dt.Columns.Add("InStock", typeof(bool));

    dt.Rows.Add("Widget A", "Hardware", 29.99m, true);
    dt.Rows.Add("Widget B", "Hardware", 49.99m, false);
    dt.Rows.Add("Service Plan", "Support", 199.00m, true);

    WorkBook workbook = WorkBook.Create();
    WorkBook.LoadWorkSheetsFromDataSet(new DataSet { Tables = { dt } }, workbook);
    WorkSheet sheet = workbook.WorkSheets[0];

    // Style the header row
    sheet["A1:D1"].Style.Font.Bold = true;
    sheet["A1:D1"].Style.Font.Size = 13;
    sheet["A1:D1"].Style.SetBackgroundColor("#2196F3");
    sheet["A1:D1"].Style.Font.Color = "#FFFFFF";

    // Apply currency format to the Price column (column C, rows 2 onwards)
    sheet["C2:C4"].Style.NumberFormat.Format = "$#,##0.00";

    // Auto-size all columns for readability
    for (int col = 0; col < 4; col++)
    {
        sheet.AutoSizeColumn(col);
    }

    // Freeze the header row so it stays visible when scrolling
    sheet.FreezePanes(0, 0, 1, 0);

    workbook.SaveAs("FormattedExport.xlsx");
}
private void ExportWithFormatting()
{
    DataTable dt = new DataTable("Products");
    dt.Columns.Add("Product", typeof(string));
    dt.Columns.Add("Category", typeof(string));
    dt.Columns.Add("Price", typeof(decimal));
    dt.Columns.Add("InStock", typeof(bool));

    dt.Rows.Add("Widget A", "Hardware", 29.99m, true);
    dt.Rows.Add("Widget B", "Hardware", 49.99m, false);
    dt.Rows.Add("Service Plan", "Support", 199.00m, true);

    WorkBook workbook = WorkBook.Create();
    WorkBook.LoadWorkSheetsFromDataSet(new DataSet { Tables = { dt } }, workbook);
    WorkSheet sheet = workbook.WorkSheets[0];

    // Style the header row
    sheet["A1:D1"].Style.Font.Bold = true;
    sheet["A1:D1"].Style.Font.Size = 13;
    sheet["A1:D1"].Style.SetBackgroundColor("#2196F3");
    sheet["A1:D1"].Style.Font.Color = "#FFFFFF";

    // Apply currency format to the Price column (column C, rows 2 onwards)
    sheet["C2:C4"].Style.NumberFormat.Format = "$#,##0.00";

    // Auto-size all columns for readability
    for (int col = 0; col < 4; col++)
    {
        sheet.AutoSizeColumn(col);
    }

    // Freeze the header row so it stays visible when scrolling
    sheet.FreezePanes(0, 0, 1, 0);

    workbook.SaveAs("FormattedExport.xlsx");
}
Private Sub ExportWithFormatting()
    Dim dt As New DataTable("Products")
    dt.Columns.Add("Product", GetType(String))
    dt.Columns.Add("Category", GetType(String))
    dt.Columns.Add("Price", GetType(Decimal))
    dt.Columns.Add("InStock", GetType(Boolean))

    dt.Rows.Add("Widget A", "Hardware", 29.99D, True)
    dt.Rows.Add("Widget B", "Hardware", 49.99D, False)
    dt.Rows.Add("Service Plan", "Support", 199.0D, True)

    Dim workbook As WorkBook = WorkBook.Create()
    WorkBook.LoadWorkSheetsFromDataSet(New DataSet With {.Tables = {dt}}, workbook)
    Dim sheet As WorkSheet = workbook.WorkSheets(0)

    ' Style the header row
    sheet("A1:D1").Style.Font.Bold = True
    sheet("A1:D1").Style.Font.Size = 13
    sheet("A1:D1").Style.SetBackgroundColor("#2196F3")
    sheet("A1:D1").Style.Font.Color = "#FFFFFF"

    ' Apply currency format to the Price column (column C, rows 2 onwards)
    sheet("C2:C4").Style.NumberFormat.Format = "$#,##0.00"

    ' Auto-size all columns for readability
    For col As Integer = 0 To 3
        sheet.AutoSizeColumn(col)
    Next

    ' Freeze the header row so it stays visible when scrolling
    sheet.FreezePanes(0, 0, 1, 0)

    workbook.SaveAs("FormattedExport.xlsx")
End Sub
$vbLabelText   $csharpLabel

Opciones de formato disponibles en IronXL

IronXL expone un amplio conjunto de propiedades de formato a través del espacio de nombres IronXl.Styles:

  • Estilo de fuente: negrita, cursiva, subrayado, tipo de letra y tamaño
  • Colores de fondo de celda: se aceptan cadenas de color hexadecimales directamente
  • Formatos de números y fechas: cualquier cadena de formato de Excel, incluidos los patrones de moneda, porcentaje y fecha
  • Ancho de columna: ancho en píxeles manual o AutoSizeColumn para ajuste automático
  • Congelar paneles: bloquear filas o columnas de encabezado durante el desplazamiento
  • Bordes de celda: los cuatro bordes con estilo y color configurables
  • Combinar celdas: unir celdas de diferentes filas o columnas para los encabezados de los informes

Para consultar la referencia completa de la API, véase la documentación sobre el estilo de celdas de IronXL y el formato de números de IronXL.

Exportar a Excel desde GridView en ASP .NET C#: una solución limpia en C#: Imagen 3 - Documento Excel formateado exportado

¿Cómo se gestionan los conjuntos de datos de gran tamaño en las exportaciones de GridView?

Cuando GridView está vinculado a miles de filas, existen algunas técnicas que permiten que la exportación sea rápida y eficiente en cuanto a memoria:

Paginación y DataTable del lado del servidor

No exportes solo la página visible del GridView. Recupere el conjunto de datos completo de su fuente de datos en un DataTable antes de llamar a WorkBook.LoadWorkSheetsFromDataSet. IronXL escribe filas en una sola pasada sin cargar todo el libro en la memoria varias veces, lo que lo hace adecuado para decenas de miles de filas.

Añadir varias hojas de cálculo

Puede incluir varios objetos DataTable en el DataSet para generar un libro con pestañas separadas:

DataSet exportSet = new DataSet();
exportSet.Tables.Add(GetEmployeeData());    // Sheet 1
exportSet.Tables.Add(GetDepartmentData());  // Sheet 2
exportSet.Tables.Add(GetSalaryReport());    // Sheet 3

WorkBook workbook = WorkBook.Create();
WorkBook.LoadWorkSheetsFromDataSet(exportSet, workbook);

Response.Clear();
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
Response.AddHeader("content-disposition", "attachment;filename=MultiSheetReport.xlsx");
workbook.SaveAsStream(Response.OutputStream, IronXl.Enum.FileFormat.Xlsx);
Response.Flush();
Response.End();
DataSet exportSet = new DataSet();
exportSet.Tables.Add(GetEmployeeData());    // Sheet 1
exportSet.Tables.Add(GetDepartmentData());  // Sheet 2
exportSet.Tables.Add(GetSalaryReport());    // Sheet 3

WorkBook workbook = WorkBook.Create();
WorkBook.LoadWorkSheetsFromDataSet(exportSet, workbook);

Response.Clear();
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
Response.AddHeader("content-disposition", "attachment;filename=MultiSheetReport.xlsx");
workbook.SaveAsStream(Response.OutputStream, IronXl.Enum.FileFormat.Xlsx);
Response.Flush();
Response.End();
Imports System.Data
Imports IronXL

Dim exportSet As New DataSet()
exportSet.Tables.Add(GetEmployeeData()) ' Sheet 1
exportSet.Tables.Add(GetDepartmentData()) ' Sheet 2
exportSet.Tables.Add(GetSalaryReport()) ' Sheet 3

Dim workbook As WorkBook = WorkBook.Create()
WorkBook.LoadWorkSheetsFromDataSet(exportSet, workbook)

Response.Clear()
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
Response.AddHeader("content-disposition", "attachment;filename=MultiSheetReport.xlsx")
workbook.SaveAsStream(Response.OutputStream, IronXL.FileFormat.Xlsx)
Response.Flush()
Response.End()
$vbLabelText   $csharpLabel

Cada DataTable.TableName se convierte en el nombre de la pestaña de la hoja de cálculo en Excel. Este patrón funciona bien para informes de gestión que combinan datos relacionados en múltiples vistas.

Guías relacionadas:

¿Cuáles son las principales ventajas de utilizar IronXL para la exportación de GridView?

El uso de IronXL para exportar datos de GridView ofrece claras ventajas sobre el enfoque tradicional de envoltura HTML:

  • Archivos Excel auténticos: crea un formato válido .xlsx que se abre sin advertencias del navegador ni mensajes de error
  • No requiere instalación de Office: funciona en cualquier servidor web sin necesidad de Microsoft Excel ni interoperabilidad con Office
  • No se anula VerifyRenderingInServerForm -- elimina la solución provisional repetitiva que satura el código tradicional
  • Control total del formato: dar estilo a las celdas, aplicar formatos numéricos, congelar paneles y crear hojas de cálculo profesionales mediante programación
  • Compatibilidad con varias hojas: exporta conjuntos de datos relacionados como pestañas independientes en un único libro de trabajo
  • Compatibilidad multiplataforma: funciona correctamente en servidores Windows y Linux, incluidos contenedores Docker y Azure App Service

La biblioteca está disponible en NuGet y es compatible con todos los entornos .NET modernos, incluido .NET 10. También admite la lectura y escritura de otros formatos, como CSV y ODS, lo que la convierte en una única dependencia para todas las necesidades de hojas de cálculo de su aplicación.

Para una comparación detallada con otras bibliotecas IronXL, consulte IronXL vs ClosedXML y la descripción general de las características de IronXL.

¿Cuales son tus próximos pasos?

Ahora tienes todo lo necesario para sustituir la exportación GridView heredada HtmlTextWriter por una implementación IronXL limpia y sin advertencias. A continuación se indica cómo proceder:

  • Prueba la versión de prueba gratuita: inicia una prueba de 30 días de IronXL sin necesidad de tarjeta de crédito y prueba el código de exportación en tu propio proyecto
  • Descubre más tutoriales de IronXL: el blog de IronXL trata sobre la importación de datos, fórmulas de celdas, generación de gráficos y flujos de trabajo con plantillas de Excel
  • Lea la referencia de la API: la documentación de la API de IronXL cubre todos los métodos de WorkBook, WorkSheet y la API de estilo.
  • Compare las opciones de licencia: consulte los precios de IronXL para encontrar la licencia adecuada para el tamaño de su equipo y su escenario de implementación
  • Haz una pregunta: el equipo de soporte de Iron Software y los foros de la comunidad están a tu disposición si te encuentras con algún imprevisto.

Preguntas Frecuentes

¿Por qué debería utilizar IronXL para exportar datos de GridView a Excel?

IronXL le permite crear archivos XLSX genuinos desde GridView en ASP.NET C# sin los problemas comunes asociados con HtmlTextWriter y StringWriter, como advertencias del navegador y errores de formato.

¿Cuáles son las limitaciones del uso de HtmlTextWriter para exportar a Excel?

HtmlTextWriter suele crear archivos Excel falsos que pueden provocar advertencias del navegador y problemas de formato. IronXL soluciona estos problemas generando archivos Excel auténticos.

¿Cómo mejora IronXL el proceso de exportación de datos desde GridView?

IronXL simplifica la exportación de datos desde GridView al permitir a los desarrolladores generar archivos Excel con el formato adecuado directamente desde sus aplicaciones ASP.NET, evitando la necesidad de soluciones alternativas basadas en HTML.

¿Qué formato de archivo utiliza IronXL para los archivos Excel exportados?

IronXL exporta datos a archivos XLSX originales, lo que garantiza la compatibilidad y el formato adecuado cuando se abren en Excel.

¿Puede IronXL ayudar con problemas de formato al exportar a Excel?

Sí, IronXL elimina los problemas de formato al crear verdaderos archivos Excel, lo que garantiza que los datos aparezcan correctamente sin activar advertencias del navegador.

¿Existe un ejemplo de código para exportar datos de GridView con IronXL?

Sí, el tutorial incluye ejemplos de código que demuestran cómo utilizar IronXL para exportar datos de GridView a Excel de manera eficiente y efectiva.

¿IronXL admite la exportación de grandes conjuntos de datos desde GridView?

IronXL está diseñado para manejar grandes conjuntos de datos de manera eficiente, lo que lo hace adecuado para exportar datos extensos desde GridView a Excel.

¿Cuáles son los beneficios de utilizar IronXL sobre los métodos tradicionales para exportar a Excel?

IronXL ofrece una solución más confiable y eficiente, eliminando las advertencias del navegador, garantizando un formato de archivo correcto y proporcionando una implementación de código sencilla para exportar datos de GridView.

Jordi Bardia
Jordi Bardia
  Chatea con el equipo de ingeniería ahora
Ingeniero de Software
Jordi es más competente en Python, C# y C++. Cuando no está aprovechando sus habilidades en Iron Software, está programando juegos. Compartiendo responsabilidades para pruebas de productos, desarrollo de productos e investigación, Jordi agrega un valor inmenso a la mejora continua del producto. La experiencia variada lo mantiene ...
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