Í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

Exportar a Excel desde GridView en ASP .NET C#: Una solución limpia en C#

Jordi Bardia
Jordi Bardia
Publicado:

Exportar datos de GridView a un archivo Excel original es un requisito común 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. En este artículo, demostraremos cómo exportar datos de GridView a archivos Excel con el formato adecuado utilizando IronXL, eliminando los dolores de cabeza que enfrentan los desarrolladores con los métodos heredados.

¿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 configurar los encabezados de respuesta con valores de nombre de archivo adjunto Content-Disposition. Este enfoque requiere anular la operación public override void VerifyRenderingInServerForm para evitar errores de tiempo de ejecución. El archivo resultante no es un verdadero archivo de Excel: es HTML disfrazado con una extensión .xls, lo que hace que Excel muestre mensajes de advertencia cuando los usuarios lo abren.

IronXL resuelve estos problemas creando archivos Excel .xlsx genuinos sin necesidad de instalar Microsoft Office en el servidor.

¿Cómo configuro mi proyecto ASP.NET para la exportación de vista de cuadrícula?

Primero, instale la biblioteca IronXL a través del Administrador de paquetes NuGet en su proyecto de Visual Studio:

Install-Package IronXL.Excel

Cree su página Default.aspx con un control GridView y un botón para exportar datos:

<%@ 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

¿Cómo exporto datos de GridView a Excel usando IronXL?

La respuesta para una exportación limpia de GridView radica en convertir sus datos a una DataTable y luego utilizar la funcionalidad de hojas de trabajo de IronXL. Aquí está el código subyacente completo que maneja la carga de la página, el enlace de datos y la función 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()
        {
            // Create sample DataTable with database-style data
            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));
            // Add rows to simulate database records
            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
            Session["GridData"] = dt;
        }
        protected void btnExport_Click(object sender, EventArgs e)
        {
            ExportGridViewToExcel();
        }
        private void ExportGridViewToExcel()
        {
            DataTable dt = (DataTable)Session["GridData"];
            // Create workbook and load data from 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 file to browser for download
            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();
        }
    }
}
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()
        {
            // Create sample DataTable with database-style data
            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));
            // Add rows to simulate database records
            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
            Session["GridData"] = dt;
        }
        protected void btnExport_Click(object sender, EventArgs e)
        {
            ExportGridViewToExcel();
        }
        private void ExportGridViewToExcel()
        {
            DataTable dt = (DataTable)Session["GridData"];
            // Create workbook and load data from 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 file to browser for download
            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 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()
            ' Create sample DataTable with database-style data
            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))
            ' Add rows to simulate database records
            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
            Session("GridData") = dt
        End Sub

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

        Private Sub ExportGridViewToExcel()
            Dim dt As DataTable = CType(Session("GridData"), DataTable)
            ' Create workbook and load data from 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 file to browser for download
            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
    End Class
End Namespace
$vbLabelText   $csharpLabel

Ejemplo de resultado

Exportar a Excel desde GridView en ASP .NET C#: Una solución C# limpia: Imagen 1 - Interfaz de usuario con nuestros datos de muestra

El código anterior demuestra cómo exportar datos de GridView sin el nuevo enfoque HtmlTextWriter y StringWriter. IronXL maneja la creación de archivos Excel internamente, por lo que no es necesario escribir HTML ni preocuparse por la anulación de VerifyRenderingInServerForm que causa tantos errores en las implementaciones tradicionales.

¿Cómo puedo guardar el archivo de Excel en el disco?

Si su aplicación necesita guardar el archivo Excel en el servidor antes de permitir que el usuario lo descargue, modifique el método de exportación:

private void SaveExcelToDisk(object sender, EventArgs e)
{
    DataTable dt = (DataTable)Session["GridData"];
    WorkBook workbook = WorkBook.Create();
    DataSet dataSet = new DataSet();
    dataSet.Tables.Add(dt.Copy());
    WorkBook.LoadWorkSheetsFromDataSet(dataSet, workbook);
    // Save to disk
    string filename = Server.MapPath("~/Exports/") + "Report.xlsx";
    workbook.SaveAs(filename);
    // Provide download link to user
    Response.Write("<script>alert('File saved successfully!');</script>");
}
private void SaveExcelToDisk(object sender, EventArgs e)
{
    DataTable dt = (DataTable)Session["GridData"];
    WorkBook workbook = WorkBook.Create();
    DataSet dataSet = new DataSet();
    dataSet.Tables.Add(dt.Copy());
    WorkBook.LoadWorkSheetsFromDataSet(dataSet, workbook);
    // Save to disk
    string filename = Server.MapPath("~/Exports/") + "Report.xlsx";
    workbook.SaveAs(filename);
    // Provide download link to user
    Response.Write("<script>alert('File saved successfully!');</script>");
}
Private Sub SaveExcelToDisk(sender As Object, e As EventArgs)
    Dim dt As DataTable = DirectCast(Session("GridData"), DataTable)
    Dim workbook As WorkBook = WorkBook.Create()
    Dim dataSet As New DataSet()
    dataSet.Tables.Add(dt.Copy())
    WorkBook.LoadWorkSheetsFromDataSet(dataSet, workbook)
    ' Save to disk
    Dim filename As String = Server.MapPath("~/Exports/") & "Report.xlsx"
    workbook.SaveAs(filename)
    ' Provide download link to user
    Response.Write("<script>alert('File saved successfully!');</script>")
End Sub
$vbLabelText   $csharpLabel

Archivo de Excel de salida

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

¿Cómo aplico formato avanzado a la hoja de Excel?

IronXL proporciona un amplio control sobre celdas, columnas y filas. A continuación se explica cómo crear un archivo Excel con estilo profesional con sus datos de GridView:

private void ExportWithFormatting()
{
    DataTable dt = new DataTable();
    dt.Columns.Add("Product");
    dt.Columns.Add("Price");
    dt.Rows.Add("Widget A", "$29.99");
    dt.Rows.Add("Widget B", "$49.99");
    WorkBook workbook = WorkBook.Create();
    WorkBook.LoadWorkSheetsFromDataSet(new DataSet { Tables = { dt } }, workbook);
    WorkSheet sheet = workbook.WorkSheets[0];
    // Format header row with bold font size
    sheet["A1:B1"].Style.Font.Bold = true;
    sheet["A1:B1"].Style.Font.Size = 14;
    // Auto-fit columns for better display
    sheet.AutoSizeColumn(0);
    sheet.AutoSizeColumn(1);
    workbook.SaveAs("FormattedExport.xlsx");
}
private void ExportWithFormatting()
{
    DataTable dt = new DataTable();
    dt.Columns.Add("Product");
    dt.Columns.Add("Price");
    dt.Rows.Add("Widget A", "$29.99");
    dt.Rows.Add("Widget B", "$49.99");
    WorkBook workbook = WorkBook.Create();
    WorkBook.LoadWorkSheetsFromDataSet(new DataSet { Tables = { dt } }, workbook);
    WorkSheet sheet = workbook.WorkSheets[0];
    // Format header row with bold font size
    sheet["A1:B1"].Style.Font.Bold = true;
    sheet["A1:B1"].Style.Font.Size = 14;
    // Auto-fit columns for better display
    sheet.AutoSizeColumn(0);
    sheet.AutoSizeColumn(1);
    workbook.SaveAs("FormattedExport.xlsx");
}
Private Sub ExportWithFormatting()
    Dim dt As New DataTable()
    dt.Columns.Add("Product")
    dt.Columns.Add("Price")
    dt.Rows.Add("Widget A", "$29.99")
    dt.Rows.Add("Widget B", "$49.99")
    Dim workbook As WorkBook = WorkBook.Create()
    WorkBook.LoadWorkSheetsFromDataSet(New DataSet With {.Tables = {dt}}, workbook)
    Dim sheet As WorkSheet = workbook.WorkSheets(0)
    ' Format header row with bold font size
    sheet("A1:B1").Style.Font.Bold = True
    sheet("A1:B1").Style.Font.Size = 14
    ' Auto-fit columns for better display
    sheet.AutoSizeColumn(0)
    sheet.AutoSizeColumn(1)
    workbook.SaveAs("FormattedExport.xlsx")
End Sub
$vbLabelText   $csharpLabel

Salida formateada

Exportar a Excel desde GridView en ASP .NET C#: Una solución C# limpia: Imagen 3 - Documento de Excel con formato exportado

¿Cuáles son los beneficios clave de este enfoque?

El uso de IronXL para exportar datos de GridView ofrece varias ventajas:

  • Archivos Excel originales : crea un formato .xlsx válido que se abre sin advertencias del navegador ni mensajes de error
  • No requiere instalación de Office : funciona en cualquier servidor web sin Microsoft Excel
  • Código limpio : elimina la necesidad de nuevos HtmlTextWriter, manipulación de respuestas y soluciones alternativas de control de formularios.
  • Control de formato completo : aplique estilo a celdas, configure el tamaño de fuente, agregue comentarios y cree hojas de cálculo profesionales.
  • Compatibilidad multiplataforma : funciona correctamente en servidores Windows y Linux

La biblioteca IronXL transforma lo que alguna vez fue una tarea de desarrollo ASP.NET frustrante en un código sencillo y fácil de mantener que produce resultados profesionales.* **

¿Está listo para optimizar su funcionalidad de exportación de GridView? Comience una prueba gratuita de IronXL _ y experimente la generación de archivos Excel sin complicaciones en sus proyectos ASP.NET. Para la implementación de producción, explore las opciones de licencia de IronXL para encontrar la opción adecuada para su equipo.

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