¿Cómo puedo exportar datos de GridView a Excel en C#?

Puede exportar datos de GridView a Excel en C# con la biblioteca IronXL. Esta biblioteca le permite crear archivos de Excel mediante programación y exportar datos fácilmente, incluyendo formato y estilos.

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

IronXL simplifica el proceso de exportación de datos de GridView con su API intuitiva, lo que le permite mantener el formato y aplicar estilos sin esfuerzo, lo que puede ser un desafío con los métodos tradicionales.

¿IronXL admite el formato al exportar GridView a Excel?

Sí, IronXL admite varias opciones de formato, incluidas fuentes, colores y estilos de celda, lo que garantiza que los archivos de Excel exportados tengan un aspecto profesional y mantengan el diseño previsto.

¿Puedo personalizar la apariencia de los archivos Excel generados a partir de datos de GridView?

IronXL ofrece una variedad de opciones de personalización para archivos de Excel, lo que le permite ajustar estilos de celda, fuentes, colores y más para que coincidan con sus requisitos específicos al exportar desde GridView.

¿Es posible exportar grandes conjuntos de datos de GridView a Excel usando IronXL?

IronXL es capaz de manejar grandes conjuntos de datos de manera eficiente, lo que garantiza que pueda exportar datos extensos de GridView a Excel sin problemas de rendimiento.

¿Cuáles son los beneficios de exportar datos de GridView a Excel usando IronXL sobre otros métodos?

IronXL ofrece un enfoque más optimizado y flexible para exportar datos de GridView, proporcionando un soporte sólido para el formato, la personalización y el manejo de grandes conjuntos de datos, lo que lo hace superior a muchos otros métodos.

¿Cómo mantengo la integridad de los datos al exportar GridView a Excel?

IronXL garantiza la integridad de los datos al convertir y preservar con precisión los tipos y formatos de datos durante el proceso de exportación de GridView a Excel.

¿Puede IronXL exportar datos de controles GridView con estructuras complejas?

Sí, IronXL puede manejar y exportar eficazmente datos desde controles GridView con estructuras complejas, manteniendo la jerarquía y el formato en el archivo Excel resultante.

¿A qué formatos de archivos puede IronXL exportar datos de GridView?

IronXL exporta datos principalmente a formatos de Excel como XLSX, pero también admite otros formatos como CSV, lo que permite flexibilidad según sus necesidades.

¿Existe soporte para exportar GridView con formato condicional usando IronXL?

IronXL admite el formato condicional, lo que le permite establecer reglas y estilos que se ajustan dinámicamente en función de los valores de las celdas al exportar datos de GridView a Excel.

La biblioteca de Excel en C#

Explore Biblioteca de hojas de cálculo de Excel de IronXL para C# .NET Prueba gratis

Leer archivos de Excel sin Interop

Ver Todos los Ejemplos de Código %s

using IronXL;
using System;
using System.Linq;

// Supported for XLSX, XLS, XLSM, XLTX, CSV and TSV
WorkBook workBook = WorkBook.Load("sample.xlsx");

// Select worksheet at index 0
WorkSheet workSheet = workBook.WorkSheets[0];

// Get any existing worksheet
WorkSheet firstSheet = workBook.DefaultWorkSheet;

// Select a cell and return the converted value
int cellValue = workSheet["A2"].IntValue;

// Read from ranges of cells elegantly.
foreach (var cell in workSheet["A2:A10"])
{
    Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text);
}

// Calculate aggregate values such as Min, Max and Sum
decimal sum = workSheet["A2:A10"].Sum();

// Linq compatible
decimal max = workSheet["A2:A10"].Max(c => c.DecimalValue);

using IronXL;
using System;
using System.Linq;

// Supported for XLSX, XLS, XLSM, XLTX, CSV and TSV
WorkBook workBook = WorkBook.Load("sample.xlsx");

// Select worksheet at index 0
WorkSheet workSheet = workBook.WorkSheets[0];

// Get any existing worksheet
WorkSheet firstSheet = workBook.DefaultWorkSheet;

// Select a cell and return the converted value
int cellValue = workSheet["A2"].IntValue;

// Read from ranges of cells elegantly.
foreach (var cell in workSheet["A2:A10"])
{
    Console.WriteLine("Cell {0} has value '{1}'", cell.AddressString, cell.Text);
}

// Calculate aggregate values such as Min, Max and Sum
decimal sum = workSheet["A2:A10"].Sum();

// Linq compatible
decimal max = workSheet["A2:A10"].Max(c => c.DecimalValue);

PM >Install-Package IronXL.Excel

Install-Package IronXL.Excel

USANDO IRONXL

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

Curtis Chau

Updated: 28 de junio de 2026

La exportación de datos de GridView a Excel conservando los colores, las fuentes, los fondos alternos de las filas y los bordes es un requisito que aparece en casi todas las aplicaciones ASP.NET o Windows Forms basadas en datos. El enfoque tradicional: usar HtmlTextWriter y StringWriter para renderizar el control como HTML, produce archivos que presentan advertencias de formato en Excel y fallan silenciosamente para los usuarios. IronXL resuelve esto generando archivos XLSX nativos íntegramente en C# sin depender de Microsoft Office, lo que le ofrece un control preciso sobre el estilo de cada celda.

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

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

PM > Install-Package IronXL.Excel

Install-Package IronXL.Excel

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 en Excel:

using IronXL;
using IronXL.Styles;

using IronXL;
using IronXL.Styles;

Imports IronXL
Imports IronXL.Styles

Imports IronXL
Imports IronXL.Styles

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

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

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

El enfoque más confiable convierte la propiedad DataSource del control a un DataTable para evitar iterar las filas visuales, que pueden estar filtradas o paginadas:

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

Imports IronXL
Imports IronXL.Styles
Imports System
Imports System.Data
Imports System.IO
Imports System.Windows.Forms

Dim dt As DataTable = DirectCast(dataGridView1.DataSource, DataTable)

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

' Header row -- bold, blue background, white text
For col As Integer = 0 To dt.Columns.Count - 1
    sheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
    Dim 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
Next

' Data rows -- alternating row color
For row As Integer = 0 To dt.Rows.Count - 1
    For col As Integer = 0 To dt.Columns.Count - 1
        Dim value As String = If(dt.Rows(row)(col)?.ToString(), String.Empty)
        sheet.SetCellValue(row + 1, col, value)

        Dim cell = sheet.GetCellAt(row + 1, col)
        cell.Style.SetBackgroundColor(If(row Mod 2 = 0, "#D6DCE5", "#FFFFFF"))
        cell.Style.BottomBorder.Type = BorderType.Thin
    Next
Next

' Save via dialog
Using saveDialog As New SaveFileDialog With {
    .Filter = "Excel Files|*.xlsx",
    .FileName = "GridViewExport.xlsx"
}
    If saveDialog.ShowDialog() = DialogResult.OK Then
        workBook.SaveAs(saveDialog.FileName)
        MessageBox.Show("Export successful.", "Export", MessageBoxButtons.OK, MessageBoxIcon.Information)
    End If
End Using

Imports IronXL
Imports IronXL.Styles
Imports System
Imports System.Data
Imports System.IO
Imports System.Windows.Forms

Dim dt As DataTable = DirectCast(dataGridView1.DataSource, DataTable)

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

' Header row -- bold, blue background, white text
For col As Integer = 0 To dt.Columns.Count - 1
    sheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
    Dim 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
Next

' Data rows -- alternating row color
For row As Integer = 0 To dt.Rows.Count - 1
    For col As Integer = 0 To dt.Columns.Count - 1
        Dim value As String = If(dt.Rows(row)(col)?.ToString(), String.Empty)
        sheet.SetCellValue(row + 1, col, value)

        Dim cell = sheet.GetCellAt(row + 1, col)
        cell.Style.SetBackgroundColor(If(row Mod 2 = 0, "#D6DCE5", "#FFFFFF"))
        cell.Style.BottomBorder.Type = BorderType.Thin
    Next
Next

' Save via dialog
Using saveDialog As New SaveFileDialog With {
    .Filter = "Excel Files|*.xlsx",
    .FileName = "GridViewExport.xlsx"
}
    If saveDialog.ShowDialog() = DialogResult.OK Then
        workBook.SaveAs(saveDialog.FileName)
        MessageBox.Show("Export successful.", "Export", MessageBoxButtons.OK, MessageBoxIcon.Information)
    End If
End Using

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

El patrón de color alternado de filas -- row % 2 == 0 selecciona #D6DCE5, de lo contrario #FFFFFF -- refleja el estilo de tabla de filas bandadas integrado en Excel. Puedes sustituir cualquier código de color hexadecimal de seis caracteres que se ajuste al sistema de diseño de tu aplicación.

Imágenes de salida

Exportar GridView a Excel con Formato C# usando IronXL: Imagen 1 - Salida de GridView

Exportar GridView a Excel con Formato C# usando IronXL: Imagen 2 - Salida de Excel

Exportar GridView a Excel con Formato C# usando IronXL: Imagen 3 - Salida de Mensaje

¿Cómo se exporta un GridView de ASP.NET a Excel y se transmite el archivo al navegador?

Las aplicaciones web requieren un mecanismo de entrega diferente. En lugar de escribir en el sistema de archivos, usted serializa el libro a 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 importante paso previo para GridViews paginados: deshabilitar el paginado (AllowPaging = false) y volver a enlazar 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();

Imports IronXL
Imports IronXL.Styles
Imports System
Imports System.Data
Imports System.IO
Imports System.Web.UI

' Disable paging so all rows are captured
GridView1.AllowPaging = False
GridView1.DataBind()

Dim dt As DataTable = CType(GridView1.DataSource, DataTable)

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

' Header row
For col As Integer = 0 To dt.Columns.Count - 1
    sheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
    Dim 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
Next

' Data rows
For row As Integer = 0 To dt.Rows.Count - 1
    For col As Integer = 0 To dt.Columns.Count - 1
        sheet.SetCellValue(row + 1, col, If(dt.Rows(row)(col)?.ToString(), String.Empty))
        Dim cell = sheet.GetCellAt(row + 1, col)
        cell.Style.SetBackgroundColor(If(row Mod 2 = 0, "#DEEAF1", "#FFFFFF"))
        cell.Style.BottomBorder.Type = BorderType.Thin
        cell.Style.LeftBorder.Type = BorderType.Thin
        cell.Style.RightBorder.Type = BorderType.Thin
    Next
Next

' Stream to browser
Dim fileBytes As Byte() = 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()

Imports IronXL
Imports IronXL.Styles
Imports System
Imports System.Data
Imports System.IO
Imports System.Web.UI

' Disable paging so all rows are captured
GridView1.AllowPaging = False
GridView1.DataBind()

Dim dt As DataTable = CType(GridView1.DataSource, DataTable)

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

' Header row
For col As Integer = 0 To dt.Columns.Count - 1
    sheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
    Dim 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
Next

' Data rows
For row As Integer = 0 To dt.Rows.Count - 1
    For col As Integer = 0 To dt.Columns.Count - 1
        sheet.SetCellValue(row + 1, col, If(dt.Rows(row)(col)?.ToString(), String.Empty))
        Dim cell = sheet.GetCellAt(row + 1, col)
        cell.Style.SetBackgroundColor(If(row Mod 2 = 0, "#DEEAF1", "#FFFFFF"))
        cell.Style.BottomBorder.Type = BorderType.Thin
        cell.Style.LeftBorder.Type = BorderType.Thin
        cell.Style.RightBorder.Type = BorderType.Thin
    Next
Next

' Stream to browser
Dim fileBytes As Byte() = 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 aplicaciones ASP.NET Core, reemplace Response.BinaryWrite con File(fileBytes, contentType, fileName) en una acción de controlador; la lógica de creación del libro es idéntica.

¿Cómo se aplica el formato condicional en función de los valores de las celdas?

El formato condicional resalta las celdas que cumplen criterios específicos; por ejemplo, marcando en rojo las fechas vencidas o señalando en naranja los valores por debajo de un umbral. IronXL aplica formato condicional a nivel de celda durante la creación del libro de trabajo:

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

Imports System

' Assume "DueDate" is column index 3 and "Amount" is column index 4
Dim today As DateTime = DateTime.Today

For row As Integer = 0 To dt.Rows.Count - 1
    ' Highlight past-due dates
    If dt.Columns.Contains("DueDate") AndAlso dt.Rows(row)("DueDate") IsNot DBNull.Value Then
        Dim dueDate As DateTime = Convert.ToDateTime(dt.Rows(row)("DueDate"))
        Dim dueDateCell = sheet.GetCellAt(row + 1, 3)
        If dueDate < today Then
            dueDateCell.Style.SetBackgroundColor("#FF0000")
            dueDateCell.Style.Font.Color = "#FFFFFF"
            dueDateCell.Style.Font.Bold = True
        End If
    End If

    ' Highlight amounts below threshold
    If dt.Columns.Contains("Amount") AndAlso dt.Rows(row)("Amount") IsNot DBNull.Value Then
        Dim amount As Decimal = Convert.ToDecimal(dt.Rows(row)("Amount"))
        Dim amountCell = sheet.GetCellAt(row + 1, 4)
        If amount < 100D Then
            amountCell.Style.SetBackgroundColor("#FFC000")
        End If
    End If
Next row

Imports System

' Assume "DueDate" is column index 3 and "Amount" is column index 4
Dim today As DateTime = DateTime.Today

For row As Integer = 0 To dt.Rows.Count - 1
    ' Highlight past-due dates
    If dt.Columns.Contains("DueDate") AndAlso dt.Rows(row)("DueDate") IsNot DBNull.Value Then
        Dim dueDate As DateTime = Convert.ToDateTime(dt.Rows(row)("DueDate"))
        Dim dueDateCell = sheet.GetCellAt(row + 1, 3)
        If dueDate < today Then
            dueDateCell.Style.SetBackgroundColor("#FF0000")
            dueDateCell.Style.Font.Color = "#FFFFFF"
            dueDateCell.Style.Font.Bold = True
        End If
    End If

    ' Highlight amounts below threshold
    If dt.Columns.Contains("Amount") AndAlso dt.Rows(row)("Amount") IsNot DBNull.Value Then
        Dim amount As Decimal = Convert.ToDecimal(dt.Rows(row)("Amount"))
        Dim amountCell = sheet.GetCellAt(row + 1, 4)
        If amount < 100D Then
            amountCell.Style.SetBackgroundColor("#FFC000")
        End If
    End If
Next row

Este patrón es modulable: añada tantas comprobaciones condicionales como requieran sus necesidades de generación de informes. Dado que IronXL opera celda por celda, puede combinar el formato condicional con la lógica de alternancia de colores de filas aplicando el estilo condicional después del estilo de fila base.

¿Cómo se ajusta el ancho de las columnas y se fija la fila de encabezado?

Una exportación a Excel con formato Professional incluye anchos de columna adecuados y una fila de encabezado fija, de modo que los nombres de las columnas permanezcan visibles cuando los usuarios se desplacen por conjuntos de datos de gran tamaño.

IronXL expone el ancho de columna a través del accesor de columna WorkSheet y el congelamiento de 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);

' Auto-size columns 0 through the last column index
For col As Integer = 0 To dt.Columns.Count - 1
    ' Set column width in character units (1 unit ≈ one default character width)
    sheet.SetColumnWidth(col, 20)
Next

' 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 col As Integer = 0 To dt.Columns.Count - 1
    ' Set column width in character units (1 unit ≈ one default character width)
    sheet.SetColumnWidth(col, 20)
Next

' 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 basándose en el número máximo de caracteres de cada columna en lugar de utilizar un valor fijo. Iterar los valores de columna DataTable, medir la longitud de la cadena y multiplicar por un factor de ancho de carácter apropiado para el tamaño de fuente elegido.

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

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

Muchas aplicaciones .NET llenan datos mediante llamadas de servicio o consultas de base de datos y los mantienen en un DataTable sin vincularlos nunca a un control de interfaz de usuario. Puede exportar un DataTable directamente a Excel sin instanciar un GridView en absoluto.

Esta es la ruta más eficiente para tareas en segundo plano, informes programados y puntos finales de API que necesitan generar 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();
}

Imports IronXL
Imports IronXL.Styles
Imports System.Data

Public Shared Function DataTableToExcelBytes(dt As DataTable, Optional sheetName As String = "Report") As Byte()
    Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
    Dim sheet As WorkSheet = workBook.CreateWorkSheet(sheetName)

    ' Header
    For col As Integer = 0 To dt.Columns.Count - 1
        sheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
        Dim cell = sheet.GetCellAt(0, col)
        cell.Style.Font.Bold = True
        cell.Style.SetBackgroundColor("#4472C4")
        cell.Style.Font.Color = "#FFFFFF"
    Next

    ' Data
    For row As Integer = 0 To dt.Rows.Count - 1
        For col As Integer = 0 To dt.Columns.Count - 1
            sheet.SetCellValue(row + 1, col, If(dt.Rows(row)(col)?.ToString(), String.Empty))
        Next
    Next

    Return workBook.ToByteArray()
End Function

Imports IronXL
Imports IronXL.Styles
Imports System.Data

Public Shared Function DataTableToExcelBytes(dt As DataTable, Optional sheetName As String = "Report") As Byte()
    Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
    Dim sheet As WorkSheet = workBook.CreateWorkSheet(sheetName)

    ' Header
    For col As Integer = 0 To dt.Columns.Count - 1
        sheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
        Dim cell = sheet.GetCellAt(0, col)
        cell.Style.Font.Bold = True
        cell.Style.SetBackgroundColor("#4472C4")
        cell.Style.Font.Color = "#FFFFFF"
    Next

    ' Data
    For row As Integer = 0 To dt.Rows.Count - 1
        For col As Integer = 0 To dt.Columns.Count - 1
            sheet.SetCellValue(row + 1, col, If(dt.Rows(row)(col)?.ToString(), String.Empty))
        Next
    Next

    Return workBook.ToByteArray()
End Function

Este método devuelve un byte[] que puede escribir en disco, transmitir desde un punto final de API, adjuntar a un correo electrónico o almacenar en memoria caché. Para 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 gestionas los grandes conjuntos de datos y el rendimiento?

La exportación de decenas de miles de filas a Excel exige prestar atención a la asignación de memoria. Crear 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 siempre que sea posible, aplicando estilos a rangos de celdas en lugar de a celdas individuales:

Enfoques de exportación de IronXL según el tamaño del conjunto de datos
Tamaño del conjunto de datos	Enfoque recomendado	Consideración clave
Hasta 5000 filas	Bucle de estilo celda por celda	Código sencillo, sobrecarga insignificante
5 000 - 50 000 filas	Aplicación de estilo a nivel de rango	Reduce significativamente las asignaciones de objetos
Más de 50 000 filas	Exportación directa de DataTable, estilo minimalista	Minimizar las operaciones por celda; utilizar streaming si está disponible

Para GridViews paginados, siempre configure AllowPaging = false y vuelva a enlazar antes de exportar. La paginación limita el número 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, lo que suele ser una fuente frecuente de errores de exportación incompleta.

También puede revisar la guía sobre exportación de una lista de objetos a Excel en C# para patrones que funcionen con colecciones fuertemente tipadas en lugar de filas DataTable no tipadas.

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

Las aplicaciones ASP.NET Core y Blazor no tienen un control GridView de Web Forms, pero el desafío subyacente de exportar datos es el mismo: obtener una colección de objetos o un DataTable, construir un libro con estilo, y entregar un archivo. El código de creación del libro es idéntico; solo cambia el mecanismo de entrega.

En una aplicación Blazor, activa la descarga de un archivo mediante 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");
}

Imports IronXL
Imports System.Data
Imports Microsoft.JSInterop

Public Async Function ExportToExcelAsync(dt As DataTable, js As IJSRuntime) As Task
    Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
    Dim sheet As WorkSheet = workBook.DefaultWorkSheet

    For col As Integer = 0 To dt.Columns.Count - 1
        sheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
        Dim cell = sheet.GetCellAt(0, col)
        cell.Style.Font.Bold = True
        cell.Style.SetBackgroundColor("#4472C4")
        cell.Style.Font.Color = "#FFFFFF"
    Next

    For row As Integer = 0 To dt.Rows.Count - 1
        For col As Integer = 0 To dt.Columns.Count - 1
            sheet.SetCellValue(row + 1, col, If(dt.Rows(row)(col)?.ToString(), String.Empty))
        Next
    Next

    Dim fileBytes As Byte() = workBook.ToByteArray()
    Dim base64 As String = Convert.ToBase64String(fileBytes)
    Await js.InvokeVoidAsync("downloadFileFromBase64", base64, "GridViewExport.xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
End Function

Imports IronXL
Imports System.Data
Imports Microsoft.JSInterop

Public Async Function ExportToExcelAsync(dt As DataTable, js As IJSRuntime) As Task
    Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
    Dim sheet As WorkSheet = workBook.DefaultWorkSheet

    For col As Integer = 0 To dt.Columns.Count - 1
        sheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
        Dim cell = sheet.GetCellAt(0, col)
        cell.Style.Font.Bold = True
        cell.Style.SetBackgroundColor("#4472C4")
        cell.Style.Font.Color = "#FFFFFF"
    Next

    For row As Integer = 0 To dt.Rows.Count - 1
        For col As Integer = 0 To dt.Columns.Count - 1
            sheet.SetCellValue(row + 1, col, If(dt.Rows(row)(col)?.ToString(), String.Empty))
        Next
    Next

    Dim fileBytes As Byte() = workBook.ToByteArray()
    Dim base64 As String = Convert.ToBase64String(fileBytes)
    Await js.InvokeVoidAsync("downloadFileFromBase64", base64, "GridViewExport.xlsx", "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
End Function

La guía completa del patrón de descarga de Blazor se encuentra en el tutorial de exportación de Blazor a Excel. Para un enfoque basado en controladores de ASP.NET Core, consulte el tutorial de exportación a Excel de .NET Core.

Estilo de fuente y opciones de borde

IronXL expone controles granulares de fuente y borde a través del objeto Style en cada celda. La gama completa de estilos de fuente de Excel en C# incluye negrita, cursiva, subrayado, tamaño y color. Los tipos de borde disponibles a través de BorderType cubren variantes de línea delgada, media, gruesa, discontinua, punteada, doble y varias de línea de cabello.

Para las filas de encabezado o los pies de página de resumen combinados, IronXL también admite la fusión de celdas en Excel mediante C#, lo cual resulta útil cuando se desea que una única celda de título abarque varias columnas por encima de la tabla de datos.

Para ajustar automáticamente el ancho de las columnas tras rellenarlas con datos, consulte la guía "Ajustar automáticamente el ancho de las celdas en Excel con C#" para conocer el método recomendado.

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

La técnica tradicional de exportación ASP.NET: sobrescribir VerifyRenderingInServerForm, crear un StringWriter y HtmlTextWriter, y escribir el control renderizado en la respuesta, produce un documento HTML con una extensión .xls. Microsoft Excel abre estos archivos con una advertencia de compatibilidad porque el archivo no está realmente en formato binario de Excel ni en formato OOXML. Los estilos se limitan al CSS en línea que Excel interpreta parcialmente. No es posible aplicar formato condicional. Los usuarios de plataformas que no sean Windows o que utilicen LibreOffice observan un resultado de menor calidad.

IronXL escribe directamente en el formato Open XML Spreadsheet (OOXML). El resultado es un archivo .xlsx adecuado, idéntico a lo que crea Excel en sí mismo, que se abre sin advertencias en Excel, LibreOffice, Google Sheets y Numbers en macOS. El formato se codifica como estilos de hoja de cálculo, no como atributos HTML, por lo que se conserva en las idas y venidas y en la visualización multiplataforma.

Comparación de métodos de exportación para ASP.NET GridView
Método	Formato de archivo	Advertencias de formato	Compatibilidad total con el estilo	Se requiere oficina
HtmlTextWriter + StringWriter	HTML camuflado como XLS	Sí	No	No
Interop de Office (COM)	Nativo XLS/XLSX	No	Sí	Sí
IronXL	Nativo XLSX/XLS	No	Sí	No

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

¿Cuales son tus próximos pasos?

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

Para ir más allá:

Inicie una prueba gratuita de IronXL para comprobar todas las funciones de formato y exportación con sus propios datos.
Consulte la documentación de IronXL para obtener la referencia completa de la API, incluyendo tablas dinámicas, gráficos y validación de datos.
Explora 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 Excel en C# para conocer el flujo de trabajo de importación complementario cuando su aplicación también necesite utilizar hojas de cálculo cargadas.
Para exportaciones en formato CSV además de XLSX, consulte el tutorial de exportación de C# a CSV.
Si exporta datos desde un DataGridView con los encabezados de columna en la primera fila, consulte la guía específica "DataGridView a Excel con encabezados de columna".

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 estructurados y visualmente atractivos.

...