Cómo exportar GridView a Excel con formato en C#

¿Cómo instalar la biblioteca en un proyecto .NET ?

Instale IronXL desde NuGet antes de escribir cualquier código de exportación. Abra la Consola del Administrador de Paquetes y ejecute:

Install-Package IronXL
dotnet add package IronXL

Install-Package IronXL
dotnet add package IronXL

IronXL es compatible con .NET 8, .NET 9 y .NET 10, así como con .NET Framework 4.6.2 y versiones posteriores. Después de la instalación, agregue las siguientes directivas using a cualquier archivo que realice operaciones de Excel:

using IronXL;
using IronXl.Styles;

using IronXL;
using IronXl.Styles;

No se requiere tiempo de ejecución adicional ni interoperabilidad de Office. La biblioteca escribe archivos binarios XLSX nativos que se abren limpiamente en Microsoft Excel, LibreOffice Calc y Google Sheets.

¿Cómo exportar un DataGridView de Windows Forms a Excel con formato de celda?

Las aplicaciones de Windows Forms utilizan el control DataGridView en lugar del control GridView basado en web. El patrón de exportación es el mismo en ambos casos: extraer valores de filas y celdas, crear un libro de trabajo IronXL, aplicar estilos y luego guardar o transmitir el resultado.

El enfoque más confiable convierte la propiedad DataSource del control en DataTable para evitar iterar las filas visuales, que pueden filtrarse o paginarse:

using IronXL;
using IronXl.Styles;
using System;
using System.Data;
using System.IO;
using System.Windows.Forms;

DataTable dt = (DataTable)dataGridView1.DataSource;

WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workBook.DefaultWorkSheet;

// Header row -- bold, blue background, white text
for (int col = 0; col < dt.Columns.Count; col++)
{
    sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
    var cell = sheet.GetCellAt(0, col);
    cell.Style.Font.Bold = true;
    cell.Style.SetBackgroundColor("#4472C4");
    cell.Style.Font.Color = "#FFFFFF";
    cell.Style.BottomBorder.Type = BorderType.Thin;
}

// Data rows -- alternating row color
for (int row = 0; row < dt.Rows.Count; row++)
{
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        string value = dt.Rows[row][col]?.ToString() ?? string.Empty;
        sheet.SetCellValue(row + 1, col, value);

        var cell = sheet.GetCellAt(row + 1, col);
        cell.Style.SetBackgroundColor(row % 2 == 0 ? "#D6DCE5" : "#FFFFFF");
        cell.Style.BottomBorder.Type = BorderType.Thin;
    }
}

// Save via dialog
using var saveDialog = new SaveFileDialog
{
    Filter = "Excel Files|*.xlsx",
    FileName = "GridViewExport.xlsx"
};

if (saveDialog.ShowDialog() == DialogResult.OK)
{
    workBook.SaveAs(saveDialog.FileName);
    MessageBox.Show("Export successful.", "Export",
        MessageBoxButtons.OK, MessageBoxIcon.Information);
}

using IronXL;
using IronXl.Styles;
using System;
using System.Data;
using System.IO;
using System.Windows.Forms;

DataTable dt = (DataTable)dataGridView1.DataSource;

WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workBook.DefaultWorkSheet;

// Header row -- bold, blue background, white text
for (int col = 0; col < dt.Columns.Count; col++)
{
    sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
    var cell = sheet.GetCellAt(0, col);
    cell.Style.Font.Bold = true;
    cell.Style.SetBackgroundColor("#4472C4");
    cell.Style.Font.Color = "#FFFFFF";
    cell.Style.BottomBorder.Type = BorderType.Thin;
}

// Data rows -- alternating row color
for (int row = 0; row < dt.Rows.Count; row++)
{
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        string value = dt.Rows[row][col]?.ToString() ?? string.Empty;
        sheet.SetCellValue(row + 1, col, value);

        var cell = sheet.GetCellAt(row + 1, col);
        cell.Style.SetBackgroundColor(row % 2 == 0 ? "#D6DCE5" : "#FFFFFF");
        cell.Style.BottomBorder.Type = BorderType.Thin;
    }
}

// Save via dialog
using var saveDialog = new SaveFileDialog
{
    Filter = "Excel Files|*.xlsx",
    FileName = "GridViewExport.xlsx"
};

if (saveDialog.ShowDialog() == DialogResult.OK)
{
    workBook.SaveAs(saveDialog.FileName);
    MessageBox.Show("Export successful.", "Export",
        MessageBoxButtons.OK, MessageBoxIcon.Information);
}

WorkBook.Create inicializa un nuevo libro de trabajo en memoria en formato XLSX. DefaultWorkSheet devuelve la primera hoja, que puedes renombrar a través de su propiedad Name antes de guardar. SetCellValue acepta cadenas, números enteros, dobles y valores DateTime -- IronXL selecciona automáticamente el tipo de celda correcto.

El patrón de colores de filas alternas -- row % 2 == 0 selecciona #D6DCE5, de lo contrario #FFFFFF -- refleja el estilo de tabla de filas con bandas integrado en Excel. Puede sustituir cualquier color hexadecimal de seis caracteres que coincida con el sistema de diseño de su aplicación.

¿Cómo exportar un GridView ASP.NET a Excel y transmitir el archivo al navegador?

Las aplicaciones web requieren un mecanismo de entrega diferente. En lugar de escribir en el sistema de archivos, serializa el libro de trabajo en un MemoryStream y lo escribe en la respuesta HTTP con los encabezados correctos para que el navegador lo trate como una descarga de archivo.

El paso previo al vuelo importante para GridViews paginados: deshabilitar la paginación (AllowPaging = false) y volver a vincular la fuente de datos antes de exportar para que se capture cada registro (no solo la página actual).

using IronXL;
using IronXl.Styles;
using System;
using System.Data;
using System.IO;
using System.Web.UI;

// Disable paging so all rows are captured
GridView1.AllowPaging = false;
GridView1.DataBind();

DataTable dt = (DataTable)GridView1.DataSource;

WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workBook.DefaultWorkSheet;

// Header row
for (int col = 0; col < dt.Columns.Count; col++)
{
    sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
    var cell = sheet.GetCellAt(0, col);
    cell.Style.Font.Bold = true;
    cell.Style.SetBackgroundColor("#2E75B6");
    cell.Style.Font.Color = "#FFFFFF";
    cell.Style.HorizontalAlignment = HorizontalAlignment.Center;
    cell.Style.BottomBorder.Type = BorderType.Medium;
}

// Data rows
for (int row = 0; row < dt.Rows.Count; row++)
{
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        sheet.SetCellValue(row + 1, col, dt.Rows[row][col]?.ToString() ?? string.Empty);
        var cell = sheet.GetCellAt(row + 1, col);
        cell.Style.SetBackgroundColor(row % 2 == 0 ? "#DEEAF1" : "#FFFFFF");
        cell.Style.BottomBorder.Type = BorderType.Thin;
        cell.Style.LeftBorder.Type = BorderType.Thin;
        cell.Style.RightBorder.Type = BorderType.Thin;
    }
}

// Stream to browser
byte[] fileBytes = workBook.ToByteArray();
Response.Clear();
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
Response.AddHeader("content-disposition", "attachment; filename=GridViewExport.xlsx");
Response.BinaryWrite(fileBytes);
Response.End();

using IronXL;
using IronXl.Styles;
using System;
using System.Data;
using System.IO;
using System.Web.UI;

// Disable paging so all rows are captured
GridView1.AllowPaging = false;
GridView1.DataBind();

DataTable dt = (DataTable)GridView1.DataSource;

WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workBook.DefaultWorkSheet;

// Header row
for (int col = 0; col < dt.Columns.Count; col++)
{
    sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
    var cell = sheet.GetCellAt(0, col);
    cell.Style.Font.Bold = true;
    cell.Style.SetBackgroundColor("#2E75B6");
    cell.Style.Font.Color = "#FFFFFF";
    cell.Style.HorizontalAlignment = HorizontalAlignment.Center;
    cell.Style.BottomBorder.Type = BorderType.Medium;
}

// Data rows
for (int row = 0; row < dt.Rows.Count; row++)
{
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        sheet.SetCellValue(row + 1, col, dt.Rows[row][col]?.ToString() ?? string.Empty);
        var cell = sheet.GetCellAt(row + 1, col);
        cell.Style.SetBackgroundColor(row % 2 == 0 ? "#DEEAF1" : "#FFFFFF");
        cell.Style.BottomBorder.Type = BorderType.Thin;
        cell.Style.LeftBorder.Type = BorderType.Thin;
        cell.Style.RightBorder.Type = BorderType.Thin;
    }
}

// Stream to browser
byte[] fileBytes = workBook.ToByteArray();
Response.Clear();
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
Response.AddHeader("content-disposition", "attachment; filename=GridViewExport.xlsx");
Response.BinaryWrite(fileBytes);
Response.End();

Response.AddHeader con content-disposition: attachment fuerza un diálogo de descarga de archivos en todos los navegadores modernos. El tipo MIME application/vnd.openxmlformats-officedocument.spreadsheetml.sheet es el tipo registrado para archivos XLSX y evita que el navegador intente mostrar el contenido binario en línea.

Para las aplicaciones ASP.NET Core , reemplace Response.BinaryWrite con File(fileBytes, contentType, fileName) en una acción del controlador: la lógica de creación del libro es idéntica.

// Assume "DueDate" is column index 3 and "Amount" is column index 4
DateTime today = DateTime.Today;

for (int row = 0; row < dt.Rows.Count; row++)
{
    // Highlight past-due dates
    if (dt.Columns.Contains("DueDate") && dt.Rows[row]["DueDate"] != DBNull.Value)
    {
        DateTime dueDate = Convert.ToDateTime(dt.Rows[row]["DueDate"]);
        var dueDateCell = sheet.GetCellAt(row + 1, 3);
        if (dueDate < today)
        {
            dueDateCell.Style.SetBackgroundColor("#FF0000");
            dueDateCell.Style.Font.Color = "#FFFFFF";
            dueDateCell.Style.Font.Bold = true;
        }
    }

    // Highlight amounts below threshold
    if (dt.Columns.Contains("Amount") && dt.Rows[row]["Amount"] != DBNull.Value)
    {
        decimal amount = Convert.ToDecimal(dt.Rows[row]["Amount"]);
        var amountCell = sheet.GetCellAt(row + 1, 4);
        if (amount < 100m)
        {
            amountCell.Style.SetBackgroundColor("#FFC000");
        }
    }
}

// Assume "DueDate" is column index 3 and "Amount" is column index 4
DateTime today = DateTime.Today;

for (int row = 0; row < dt.Rows.Count; row++)
{
    // Highlight past-due dates
    if (dt.Columns.Contains("DueDate") && dt.Rows[row]["DueDate"] != DBNull.Value)
    {
        DateTime dueDate = Convert.ToDateTime(dt.Rows[row]["DueDate"]);
        var dueDateCell = sheet.GetCellAt(row + 1, 3);
        if (dueDate < today)
        {
            dueDateCell.Style.SetBackgroundColor("#FF0000");
            dueDateCell.Style.Font.Color = "#FFFFFF";
            dueDateCell.Style.Font.Bold = true;
        }
    }

    // Highlight amounts below threshold
    if (dt.Columns.Contains("Amount") && dt.Rows[row]["Amount"] != DBNull.Value)
    {
        decimal amount = Convert.ToDecimal(dt.Rows[row]["Amount"]);
        var amountCell = sheet.GetCellAt(row + 1, 4);
        if (amount < 100m)
        {
            amountCell.Style.SetBackgroundColor("#FFC000");
        }
    }
}

¿Cómo establecer el ancho de las columnas y congelar la fila del encabezado?

Una exportación de Excel con formato profesional incluye anchos de columna adecuados y una fila de encabezado congelada para que los nombres de las columnas permanezcan visibles cuando los usuarios se desplazan por conjuntos de datos grandes.

IronXL expone el ancho de la columna a través del accesor de columna WorkSheet y congela el encabezado a través del método FreezeRows:

// Auto-size columns 0 through the last column index
for (int col = 0; col < dt.Columns.Count; col++)
{
    // Set column width in character units (1 unit ≈ one default character width)
    sheet.SetColumnWidth(col, 20);
}

// Freeze the first row (index 0) so the header stays visible while scrolling
sheet.FreezeRows(1);

// Optionally set row height for the header (in points)
sheet.SetRowHeight(0, 20);

// Auto-size columns 0 through the last column index
for (int col = 0; col < dt.Columns.Count; col++)
{
    // Set column width in character units (1 unit ≈ one default character width)
    sheet.SetColumnWidth(col, 20);
}

// Freeze the first row (index 0) so the header stays visible while scrolling
sheet.FreezeRows(1);

// Optionally set row height for the header (in points)
sheet.SetRowHeight(0, 20);

Para uso en producción, considere calcular el ancho en función del recuento máximo de caracteres en cada columna en lugar de utilizar un valor fijo. Itere los valores de la columna DataTable, mida la longitud de la cadena y multiplíquela por un factor de ancho de carácter apropiado para el tamaño de fuente elegido.

También puede aplicar color de fondo a las celdas de Excel usando C# independientemente de la lógica de bandas de filas para lograr un enfoque de estilo más detallado.

¿Cómo exportar una DataTable a Excel sin un control GridView?

Muchas aplicaciones .NET completan datos a través de llamadas de servicio o consultas de base de datos y los almacenan en un DataTable sin vincularlos nunca a un control de UI. Puede exportar un DataTable directamente a Excel sin necesidad de crear una instancia de GridView.

Esta es la ruta más eficiente para trabajos en segundo plano, informes programados y puntos finales de API que necesitan producir archivos Excel en el servidor:

using IronXL;
using IronXl.Styles;
using System.Data;

public static byte[] DataTableToExcelBytes(DataTable dt, string sheetName = "Report")
{
    WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
    WorkSheet sheet = workBook.CreateWorkSheet(sheetName);

    // Header
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
        var cell = sheet.GetCellAt(0, col);
        cell.Style.Font.Bold = true;
        cell.Style.SetBackgroundColor("#4472C4");
        cell.Style.Font.Color = "#FFFFFF";
    }

    // Data
    for (int row = 0; row < dt.Rows.Count; row++)
    {
        for (int col = 0; col < dt.Columns.Count; col++)
        {
            sheet.SetCellValue(row + 1, col, dt.Rows[row][col]?.ToString() ?? string.Empty);
        }
    }

    return workBook.ToByteArray();
}

using IronXL;
using IronXl.Styles;
using System.Data;

public static byte[] DataTableToExcelBytes(DataTable dt, string sheetName = "Report")
{
    WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
    WorkSheet sheet = workBook.CreateWorkSheet(sheetName);

    // Header
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
        var cell = sheet.GetCellAt(0, col);
        cell.Style.Font.Bold = true;
        cell.Style.SetBackgroundColor("#4472C4");
        cell.Style.Font.Color = "#FFFFFF";
    }

    // Data
    for (int row = 0; row < dt.Rows.Count; row++)
    {
        for (int col = 0; col < dt.Columns.Count; col++)
        {
            sheet.SetCellValue(row + 1, col, dt.Rows[row][col]?.ToString() ?? string.Empty);
        }
    }

    return workBook.ToByteArray();
}

Este método devuelve un byte[] que puedes escribir en el disco, transmitir desde un punto final de API, adjuntar a un correo electrónico o almacenar en caché en la memoria. Para conocer técnicas relacionadas, consulte la guía sobre cómo exportar una DataTable a Excel y el tutorial sobre la forma más rápida de exportar una DataTable a Excel .

¿Cómo gestionar grandes conjuntos de datos y el rendimiento?

Exportar decenas de miles de filas a Excel exige prestar atención a la asignación de memoria. La creación de un nuevo objeto de estilo de celda para cada celda de una cuadrícula grande es el cuello de botella de rendimiento más común. Reutilice las definiciones de estilo cuando sea posible estableciendo estilos en objetos de rango en lugar de celdas individuales:

Para GridViews paginados, configure siempre AllowPaging = false y vuelva a vincular antes de exportar. La paginación limita la cantidad de filas visibles en el control, por lo que una exportación paginada captura solo la página actual en lugar de todo el conjunto de datos, una fuente frecuente de errores de exportación incompleta.

También puede revisar la guía sobre cómo exportar una lista de objetos a Excel en C# para encontrar patrones que funcionen con colecciones fuertemente tipadas en lugar de filas DataTable sin tipo.

¿Cómo exportar un GridView en ASP.NET Core o Blazor?

Las aplicaciones ASP.NET Core y Blazor no tienen un control de formularios Web Forms GridView, pero el reto subyacente de la exportación de datos es el mismo: tomar una colección de objetos o un DataTable, crear un libro de trabajo con estilo y entregar un archivo. El código de creación del libro de trabajo es idéntico. Sólo cambia el mecanismo de entrega.

En una aplicación Blazor , active una descarga de archivo a través de la interoperabilidad de JavaScript :

// In a Blazor component or service
using IronXL;
using System.Data;
using Microsoft.JSInterop;

public async Task ExportToExcelAsync(DataTable dt, IJSRuntime js)
{
    WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
    WorkSheet sheet = workBook.DefaultWorkSheet;

    for (int col = 0; col < dt.Columns.Count; col++)
    {
        sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
        var cell = sheet.GetCellAt(0, col);
        cell.Style.Font.Bold = true;
        cell.Style.SetBackgroundColor("#4472C4");
        cell.Style.Font.Color = "#FFFFFF";
    }

    for (int row = 0; row < dt.Rows.Count; row++)
    {
        for (int col = 0; col < dt.Columns.Count; col++)
        {
            sheet.SetCellValue(row + 1, col, dt.Rows[row][col]?.ToString() ?? string.Empty);
        }
    }

    byte[] fileBytes = workBook.ToByteArray();
    string base64 = Convert.ToBase64String(fileBytes);
    await js.InvokeVoidAsync("downloadFileFromBase64", base64, "GridViewExport.xlsx",
        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
}

// In a Blazor component or service
using IronXL;
using System.Data;
using Microsoft.JSInterop;

public async Task ExportToExcelAsync(DataTable dt, IJSRuntime js)
{
    WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
    WorkSheet sheet = workBook.DefaultWorkSheet;

    for (int col = 0; col < dt.Columns.Count; col++)
    {
        sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
        var cell = sheet.GetCellAt(0, col);
        cell.Style.Font.Bold = true;
        cell.Style.SetBackgroundColor("#4472C4");
        cell.Style.Font.Color = "#FFFFFF";
    }

    for (int row = 0; row < dt.Rows.Count; row++)
    {
        for (int col = 0; col < dt.Columns.Count; col++)
        {
            sheet.SetCellValue(row + 1, col, dt.Rows[row][col]?.ToString() ?? string.Empty);
        }
    }

    byte[] fileBytes = workBook.ToByteArray();
    string base64 = Convert.ToBase64String(fileBytes);
    await js.InvokeVoidAsync("downloadFileFromBase64", base64, "GridViewExport.xlsx",
        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
}

El tutorial completo del patrón de descarga de Blazor se encuentra en el tutorial de exportación de Blazor a Excel . Para obtener un enfoque de controlador de ASP.NET Core , consulte el tutorial de exportación de ASP.NET Core a Excel .

¿Por qué una biblioteca nativa de Excel produce exportaciones más limpias que HtmlTextWriter?

La técnica tradicional de exportación ASP.NET (anular VerifyRenderingInServerForm, crear un StringWriter y un HtmlTextWriter y escribir el control representado en la respuesta) produce un documento HTML con una extensión .xls. Microsoft Excel abre dichos archivos con una advertencia de compatibilidad porque el archivo no está en realidad en formato binario de Excel ni en formato OOXML. Los estilos están limitados a CSS en línea que Excel interpreta parcialmente. El formato condicional es imposible. Los usuarios que utilizan plataformas que no sean Windows o que utilicen LibreOffice ven una salida degradada.

IronXL escribe directamente el formato de hoja de cálculo Open XML (OOXML). El resultado es un archivo .xlsx adecuado, idéntico al que Excel mismo crea, que se abre sin advertencias en Excel, LibreOffice, Google Sheets y Numbers en macOS. El formato está codificado como estilos de hoja de cálculo, no como atributos HTML, por lo que sobrevive a los viajes de ida y vuelta y a la visualización en múltiples plataformas.

La documentación oficial de Microsoft sobre el SDK de Open XML explica el formato subyacente que produce IronXL . La especificación OOXML mantenida por ECMA International define el estándar que garantiza la compatibilidad entre aplicaciones. La documentación del control ASP.NET GridView en Microsoft Docs describe el modelo de control desde el cual leen los patrones de exportación anteriores.

¿Cuales son tus próximos pasos?

Ahora tiene los patrones necesarios para exportar datos de GridView y DataGridView a archivos XLSX con el formato adecuado utilizando IronXL , que abarca los modelos de entrega de Windows Forms, ASP.NET Web Forms, ASP.NET Core y Blazor .

Para ir más allá:

• Comience una prueba gratuita de IronXL para probar las capacidades completas de formato y exportación con sus propios datos.
• Revise la documentación de IronXL para obtener la referencia completa de la API, incluidas tablas dinámicas, gráficos y validación de datos.
• Explore la creación de informes de Excel en C# para combinar los patrones de exportación anteriores con resúmenes y gráficos calculados.
• Consulte la lectura de archivos de Excel en C# para conocer el flujo de trabajo de importación complementario cuando su aplicación también necesita consumir hojas de cálculo cargadas.
• Para exportaciones basadas en CSV junto con XLSX, consulte el tutorial de exportación de C# a CSV .
• Si exporta datos desde un DataGridView con encabezados de columna como la primera fila, consulte la guía dedicada de DataGridView a Excel con encabezado de columna .