Ícono de mensaje
Saltar al pie de página
  1. IronXL
  2. Blog de IronXL
  3. Usando IronXL
  4. Exportar DataGridView a Excel con encabezados de columna en C#
USANDO IRONXL

Exportar DataGridView a Excel con encabezados de columna en C#

Jordi Bardia
Jordi Bardia
Actualizado:

¿Cómo exportas un DataGridView a Excel con encabezados de columna en C#?

Exportar datos desde un control DataGridView de Windows Forms a formato Excel es un requisito común, pero los desarrolladores a menudo se encuentran con un muro frustrante: al archivo exportado le faltan los encabezados de columna. Cuando necesitas exportar DataGridView a Excel con encabezados de columna, la solución debe preservar de manera confiable todos tus datos y formato. Los enfoques tradicionales utilizando Interop de Microsoft Office pueden ser lentos, frágiles y requieren que MS Excel esté instalado en cada máquina que ejecute el código.

IronXL resuelve este problema de manera eficiente. Es una biblioteca .NET Excel que lee, crea y escribe archivos de Excel sin ninguna dependencia de Office. Este tutorial te guía por una solución completa de exportación, una que maneja encabezados de columna, tipos de datos, celdas nulas y guardado de archivos fácil de usar en solo unas pocas líneas de código.

Al final, tendrás un manejador de botones de Windows Forms que exporta un DataGridView a un archivo XLSX con todos los encabezados de columna intactos.

Lo que necesitas antes de comenzar

Antes de escribir cualquier código, asegúrate de tener lo siguiente:

  • Visual Studio 2022 o posterior (cualquier edición)
  • SDK de .NET 10 instalado
  • Un proyecto de aplicación Windows Forms dirigido a .NET 10
  • Acceso a NuGet para instalar IronXL

Los ejemplos a continuación utilizan declaraciones de nivel superior y la estructura moderna del proyecto .NET 10 en todo momento.

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

Abre la Consola del Administrador de Paquetes NuGet en Visual Studio y ejecuta cualquiera de los siguientes comandos. El paquete está listado en NuGet Gallery y está dirigido a .NET Standard 2.0 y superiores, por lo que funciona con cualquier proyecto moderno de .NET.

Install-Package IronXL
Install-Package IronXL
SHELL 
dotnet add package IronXL
dotnet add package IronXL
SHELL

Después de la instalación, agrega los espacios de nombres requeridos en la parte superior de tu archivo de formulario:

using IronXL;
using System;
using System.Data;
using System.Windows.Forms;
using IronXL;
using System;
using System.Data;
using System.Windows.Forms;
$vbLabelText   $csharpLabel

Estas importaciones dan acceso a la funcionalidad Excel de IronXL, a las operaciones DataTable y a los controles de Windows Forms necesarios para el proceso de exportación.

¿Cómo configuras un DataGridView con datos de muestra?

Comienza creando una aplicación Windows Forms en Visual Studio. Agrega un DataGridView llamado dataGridView1 y un Botón llamado btnExport al formulario principal a través del diseñador. Luego llena la cuadrícula al cargar el formulario:

using System;
using System.Data;
using System.Windows.Forms;

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }

    private void Form1_Load(object sender, EventArgs e)
    {
        DataTable dt = new DataTable();

        // Define columns -- these names become Excel headers
        dt.Columns.Add("Product ID", typeof(int));
        dt.Columns.Add("Product Name", typeof(string));
        dt.Columns.Add("Price", typeof(decimal));
        dt.Columns.Add("Stock Quantity", typeof(int));

        // Add sample rows
        dt.Rows.Add(1001, "Laptop", 999.99m, 15);
        dt.Rows.Add(1002, "Mouse", 29.99m, 50);
        dt.Rows.Add(1003, "Keyboard", 79.99m, 30);
        dt.Rows.Add(1004, "Monitor", 299.99m, 12);
        dt.Rows.Add(1005, "Headphones", 89.99m, 25);

        // Bind data to the grid
        dataGridView1.DataSource = dt;
    }
}
using System;
using System.Data;
using System.Windows.Forms;

public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }

    private void Form1_Load(object sender, EventArgs e)
    {
        DataTable dt = new DataTable();

        // Define columns -- these names become Excel headers
        dt.Columns.Add("Product ID", typeof(int));
        dt.Columns.Add("Product Name", typeof(string));
        dt.Columns.Add("Price", typeof(decimal));
        dt.Columns.Add("Stock Quantity", typeof(int));

        // Add sample rows
        dt.Rows.Add(1001, "Laptop", 999.99m, 15);
        dt.Rows.Add(1002, "Mouse", 29.99m, 50);
        dt.Rows.Add(1003, "Keyboard", 79.99m, 30);
        dt.Rows.Add(1004, "Monitor", 299.99m, 12);
        dt.Rows.Add(1005, "Headphones", 89.99m, 25);

        // Bind data to the grid
        dataGridView1.DataSource = dt;
    }
}
$vbLabelText   $csharpLabel

Los nombres de las columnas definidos en las llamadas dt.Columns.Add(...) se convertirán en la fila de encabezado en el archivo de Excel exportado. Puedes sustituir cualquier fuente de datos aquí: un resultado de consulta de base de datos, una importación CSV, o una respuesta de API almacenada como un DataTable funcionan idénticamente con el código de exportación mostrado más adelante. El enfoque DataTable es particularmente conveniente porque DataGridView expone una propiedad DataSource que acepta cualquier IList o IBindingList, lo que significa que el mismo código de exportación se generaliza en todos los escenarios de enlace sin modificación.

Si tu DataGridView se llena desde una base de datos utilizando un SqlDataAdapter, el DataTable ya contiene columnas tipadas. Pasar esos valores tipados a SetCellValue en lugar de llamar a ToString() sobre ellos mantiene las columnas numéricas numéricas en la salida de Excel, lo que es importante para cualquier uso posterior en informes o tablas dinámicas.

Esto crea un DataGridView lleno con todos los datos:

Exportar DataGridView a Excel con encabezados de columna usando IronXL: Imagen 1 - Datos de muestra en un DataGridView

Para escenarios de enlace de datos más avanzados, la documentación de Microsoft sobre enlace de datos en DataGridView proporciona ejemplos adicionales.

¿Cómo exportas el DataGridView a Excel mientras conservas los encabezados de columna?

El método de exportación lee los encabezados de columna de la propiedad HeaderText de cada columna de DataGridView y los escribe en la fila 0 de la hoja de trabajo. Las filas de datos siguen a partir de la fila 1 en adelante. Conecta este método al evento de clic btnExport:

private void btnExport_Click(object sender, EventArgs e)
{
    try
    {
        // Create a new Excel workbook in XLSX format
        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet worksheet = workbook.CreateWorkSheet("Exported Data");

        // Write column headers to row 0
        for (int col = 0; col < dataGridView1.Columns.Count; col++)
        {
            worksheet.SetCellValue(0, col, dataGridView1.Columns[col].HeaderText);
        }

        // Write data rows starting at row 1
        for (int row = 0; row < dataGridView1.Rows.Count; row++)
        {
            // Skip the placeholder new-row at the bottom of the grid
            if (dataGridView1.AllowUserToAddRows && row == dataGridView1.Rows.Count - 1)
                continue;

            for (int col = 0; col < dataGridView1.Columns.Count; col++)
            {
                var cellValue = dataGridView1.Rows[row].Cells[col].Value;
                if (cellValue != null)
                {
                    worksheet.SetCellValue(row + 1, col, cellValue.ToString());
                }
            }
        }

        // Prompt the user to choose a save location
        using SaveFileDialog saveFileDialog = new SaveFileDialog
        {
            Filter = "Excel Files|*.xlsx",
            FileName = "DataGridView_Export.xlsx"
        };

        if (saveFileDialog.ShowDialog() == DialogResult.OK)
        {
            workbook.SaveAs(saveFileDialog.FileName);
            MessageBox.Show("Export completed successfully!", "Success",
                            MessageBoxButtons.OK, MessageBoxIcon.Information);
        }
    }
    catch (Exception ex)
    {
        MessageBox.Show($"Export failed: {ex.Message}", "Error",
                       MessageBoxButtons.OK, MessageBoxIcon.Error);
    }
}
private void btnExport_Click(object sender, EventArgs e)
{
    try
    {
        // Create a new Excel workbook in XLSX format
        WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
        WorkSheet worksheet = workbook.CreateWorkSheet("Exported Data");

        // Write column headers to row 0
        for (int col = 0; col < dataGridView1.Columns.Count; col++)
        {
            worksheet.SetCellValue(0, col, dataGridView1.Columns[col].HeaderText);
        }

        // Write data rows starting at row 1
        for (int row = 0; row < dataGridView1.Rows.Count; row++)
        {
            // Skip the placeholder new-row at the bottom of the grid
            if (dataGridView1.AllowUserToAddRows && row == dataGridView1.Rows.Count - 1)
                continue;

            for (int col = 0; col < dataGridView1.Columns.Count; col++)
            {
                var cellValue = dataGridView1.Rows[row].Cells[col].Value;
                if (cellValue != null)
                {
                    worksheet.SetCellValue(row + 1, col, cellValue.ToString());
                }
            }
        }

        // Prompt the user to choose a save location
        using SaveFileDialog saveFileDialog = new SaveFileDialog
        {
            Filter = "Excel Files|*.xlsx",
            FileName = "DataGridView_Export.xlsx"
        };

        if (saveFileDialog.ShowDialog() == DialogResult.OK)
        {
            workbook.SaveAs(saveFileDialog.FileName);
            MessageBox.Show("Export completed successfully!", "Success",
                            MessageBoxButtons.OK, MessageBoxIcon.Information);
        }
    }
    catch (Exception ex)
    {
        MessageBox.Show($"Export failed: {ex.Message}", "Error",
                       MessageBoxButtons.OK, MessageBoxIcon.Error);
    }
}
$vbLabelText   $csharpLabel

Desglosando los pasos de la exportación

Cada paso del método sirve para un propósito específico:

  • WorkBook.Create: Inicializa un nuevo archivo de Excel en memoria usando el formato XLSX. No se escribe ningún archivo en disco hasta que SaveAs es llamado.
  • CreateWorkSheet: Agrega una hoja nombrada para contener los datos exportados. El nombre "Exported Data" aparece como la etiqueta de la pestaña en Excel.
  • Bucle de encabezado de columna: Lee dataGridView1.Columns[col].HeaderText para cada columna y lo escribe en el índice de fila 0. Este es el paso clave que preserva los encabezados.
  • Bucles de fila de datos: Bucles anidados iteran cada fila y columna, usando row + 1 como el índice de fila en Excel para que los datos siempre comiencen debajo de la fila de encabezado.
  • Verificación de nulos: Evita excepciones cuando una celda no contiene valor, lo cual es común en datos reales.
  • SaveFileDialog: Permite a los usuarios elegir el nombre y destino del archivo en tiempo de ejecución en lugar de codificar una ruta.

El archivo exportado se ve así:

Exportar DataGridView a Excel con encabezados de columna usando IronXL: Imagen 2 - Archivo Excel de salida con los datos de muestra exportados

¿Cómo manejas los casos excepcionales comunes durante la exportación?

Los datos del mundo real rara vez se ven tan limpios como un conjunto de datos de muestra. Aquí están los escenarios más probables que encontrarás y cómo abordarlos.

Celdas vacías

La verificación de nulos (if (cellValue != null)) en el bucle de datos maneja las celdas vacías sin lanzar una excepción. Las celdas vacías permanecen en blanco en la salida de Excel, preservando la estructura de la cuadrícula.

Tipos de datos mixtos

IronXL maneja diferentes formatos de datos automáticamente. Cuando pasas un número como cadena a través de ToString(), Excel aún puede reconocerlo como numérico dependiendo del valor. Para un control preciso del tipo, convierte el valor de la celda al tipo correcto antes de escribir:

if (cellValue is int intVal)
    worksheet.SetCellValue(row + 1, col, intVal);
else if (cellValue is decimal decVal)
    worksheet.SetCellValue(row + 1, col, (double)decVal);
else
    worksheet.SetCellValue(row + 1, col, cellValue?.ToString() ?? string.Empty);
if (cellValue is int intVal)
    worksheet.SetCellValue(row + 1, col, intVal);
else if (cellValue is decimal decVal)
    worksheet.SetCellValue(row + 1, col, (double)decVal);
else
    worksheet.SetCellValue(row + 1, col, cellValue?.ToString() ?? string.Empty);
$vbLabelText   $csharpLabel

Este enfoque mantiene las columnas numéricas numéricas en Excel para que las fórmulas y el ordenado funcionen correctamente posteriormente.

Caracteres especiales en los encabezados

Los encabezados de columna con caracteres especiales como &, <, > y letras acentuadas se exportan correctamente. IronXL maneja la codificación automáticamente y no requiere ningún escape de tu parte.

Conjuntos de datos grandes

Para cuadrículas que contienen decenas de miles de filas, considera mover la lógica de exportación a un hilo en segundo plano para mantener la interfaz de usuario receptiva. Envuelve la llamada WorkBook.Create y la lógica del bucle en una llamada Task.Run y actualiza la UI desde la devolución de llamada completada. La documentación de Microsoft sobre programación asincrónica con Task explica el patrón en detalle.

Para escenarios adicionales como formato de celdas, preservación de fórmulas, y protección con contraseña, la documentación de IronXL cubre cada uno en detalle.

¿Cómo se comparan los enfoques principales de exportación?

Antes de comprometerse con una biblioteca, es útil entender las compensaciones entre los métodos más comunes.

Comparación de métodos de exportación de DataGridView a Excel en C#
Método Se requiere oficina Encabezados de columna Actuación Seguro para servidor
Interop de Microsoft Office Sí Manual Lento No
OpenXml SDK No Manual Rápido Sí
ClosedXML No Manual Bien Sí
IronXL No Automático Rápido Sí

Las soluciones basadas en Interop requieren que Excel esté instalado en el servidor, lo cual es tanto una preocupación de licencia como una complejidad de implementación. OpenXml SDK es poderoso pero de bajo nivel, escribir una fila de encabezado requiere construir estructuras XML manualmente. IronXL y ClosedXML proporcionan API de nivel superior, pero el modelo WorkBook y WorkSheet de IronXL se ajusta estrechamente a la forma en que los desarrolladores ya piensan en las hojas de cálculo.

¿Cómo exportas a CSV en lugar de XLSX?

El mismo patrón de exportación se aplica cuando necesitas un archivo CSV en lugar de un libro de trabajo de Excel. Cambia el formato de archivo y la extensión:

WorkBook csvWorkbook = WorkBook.Create(ExcelFileFormat.CSV);
WorkSheet csvSheet = csvWorkbook.CreateWorkSheet("Data");

// Headers and data loops remain identical

using SaveFileDialog dialog = new SaveFileDialog
{
    Filter = "CSV Files|*.csv",
    FileName = "DataGridView_Export.csv"
};

if (dialog.ShowDialog() == DialogResult.OK)
    csvWorkbook.SaveAs(dialog.FileName);
WorkBook csvWorkbook = WorkBook.Create(ExcelFileFormat.CSV);
WorkSheet csvSheet = csvWorkbook.CreateWorkSheet("Data");

// Headers and data loops remain identical

using SaveFileDialog dialog = new SaveFileDialog
{
    Filter = "CSV Files|*.csv",
    FileName = "DataGridView_Export.csv"
};

if (dialog.ShowDialog() == DialogResult.OK)
    csvWorkbook.SaveAs(dialog.FileName);
$vbLabelText   $csharpLabel

La exportación CSV es útil cuando el sistema consumidor no admite XLSX o cuando el tamaño del archivo es una preocupación para conjuntos de datos muy grandes.

¿Cómo estilos la fila de encabezado en el archivo exportado?

Los datos exportados son más legibles cuando la fila de encabezado es visualmente distinta. IronXL proporciona opciones de estilo de celda que te permiten aplicar texto en negrita, color de fondo y tamaño de fuente después de escribir los valores del encabezado:

// Write headers and apply bold styling
for (int col = 0; col < dataGridView1.Columns.Count; col++)
{
    string cellAddress = worksheet.GetCellAddress(0, col);
    worksheet[cellAddress].Value = dataGridView1.Columns[col].HeaderText;
    worksheet[cellAddress].Style.Font.Bold = true;
    worksheet[cellAddress].Style.SetBackgroundColor("#4472C4");
    worksheet[cellAddress].Style.Font.FontColor = "#FFFFFF";
}
// Write headers and apply bold styling
for (int col = 0; col < dataGridView1.Columns.Count; col++)
{
    string cellAddress = worksheet.GetCellAddress(0, col);
    worksheet[cellAddress].Value = dataGridView1.Columns[col].HeaderText;
    worksheet[cellAddress].Style.Font.Bold = true;
    worksheet[cellAddress].Style.SetBackgroundColor("#4472C4");
    worksheet[cellAddress].Style.Font.FontColor = "#FFFFFF";
}
$vbLabelText   $csharpLabel

Una fila de encabezado con estilo hace que el archivo exportado sea utilizable inmediatamente para informes sin requerir que el destinatario aplique formato manualmente. Para un listado completo de propiedades de estilo, ve la referencia de estilo de celda de IronXL.

¿Cómo empezar con una prueba gratuita?

IronXL ofrece una prueba gratuita que te permite probar todas las funciones, incluidos los flujos de trabajo de exportación mostrados en este artículo. Instala el paquete con cualquiera de los comandos NuGet mostrados arriba, genera una clave de prueba en la página de licencias de IronXL y configúralo en tu aplicación antes de la primera llamada a la biblioteca:

IronXl.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";
IronXl.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";
$vbLabelText   $csharpLabel

La prueba produce archivos Excel totalmente funcionales y no restringe las características disponibles. Para el despliegue en producción, las opciones de licencia cubren desarrolladores individuales, equipos y redistribución sin regalías.

Para escenarios de exportación relacionados, explora cómo IronXL maneja exportar DataTables directamente a Excel, leer archivos Excel en DataGridViews, y crear gráficos a partir de datos exportados.

Eligiendo la estrategia de exportación correcta para tu caso de uso

El método de exportación sencillo celda por celda mostrado a lo largo de este tutorial se adapta a la mayoría de aplicaciones de Windows Forms. Si tu DataGridView está ligado a un DataTable, también puedes pasar el DataTable directamente al convertidor de DataTable a hoja de trabajo de IronXL, que maneja la fila de encabezado automáticamente. Elige el enfoque directo de DataTable cuando tu diseño de columna esté fijo y desees el camino de código más corto posible. Elige el enfoque manual celda por celda cuando necesites lógica condicional por celda, por ejemplo, resaltando celdas cuyo valor esté fuera de un rango aceptable, o mapeando tipos NULL explícitamente antes de escribir.

Para escenarios del lado del servidor como controladores ASP.NET Core que generan informes Excel descargables, se aplica la misma API de IronXL. La única diferencia es el destino de guardado: en lugar de SaveAs(filePath), llama a workbook.ToByteArray() y escribe los bytes en la respuesta HTTP con un tipo de contenido de application/vnd.openxmlformats-officedocument.spreadsheetml.sheet. Los encabezados de columna se transfieren de manera idéntica, independientemente de si la salida va a un archivo o a un flujo.

Preguntas Frecuentes

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

Use la biblioteca IronXL para crear un libro de Excel, itere las columnas de DataGridView para escribir los encabezados en la fila 0, luego itere las filas de datos y escriba los valores de las celdas a partir de la fila 1. Guarde el libro con Guardar como.

¿Cuál es la ventaja de utilizar IronXL para exportar datos?

IronXL proporciona una API de alto nivel para operaciones de Excel que no requiere la instalación de Microsoft Office. Gestiona encabezados, tipos de datos y formatos de archivo sin necesidad de manipulación manual de XML.

¿Es posible conservar los encabezados de columna al exportar de DataGridView a Excel?

Sí. Lea la propiedad HeaderText de cada columna DataGridView y escríbala en la fila 0 de la hoja de cálculo IronXL antes de escribir cualquier fila de datos.

¿Necesito una versión de prueba para empezar a usar IronXL para exportar a Excel?

Hay una prueba gratuita disponible que da acceso a todas las funciones. Instale el paquete NuGet , genere una clave de prueba y configure IronXl.License.LicenseKey antes de realizar cualquier llamada a la biblioteca.

¿Puede IronXL manejar grandes conjuntos de datos DataGridView al exportar a Excel?

Sí. Para cuadrículas muy grandes, ejecute la exportación en un hilo en segundo plano usando Task.Run para mantener la interfaz de usuario respondiendo mientras IronXL escribe los datos.

¿Cuáles son los pasos para exportar DataGridView a Excel utilizando IronXL?

Instale IronXL, cree un WorkBook y una WorkSheet, recorra las columnas de DataGridView para escribir encabezados en la fila 0, recorra las filas para escribir datos de la fila 1 y luego llame a SaveAs para escribir el archivo.

¿Por qué elegir IronXL en lugar de otras bibliotecas para exportar a Excel?

IronXL no requiere instalación de Office, se ejecuta en servidores y proporciona una API WorkBook/WorkSheet limpia que se adapta naturalmente a cómo los desarrolladores piensan acerca de las hojas de cálculo, con documentación sólida y soporte activo.

¿Hay soporte disponible para solucionar problemas con IronXL?

Sí. IronXL proporciona documentación detallada de API, ejemplos de código y soporte de ingeniería directo para clientes con licencia.

¿Puedo personalizar el proceso de exportación de Excel con IronXL?

Sí. Después de escribir los datos, puede aplicar fuentes en negrita, colores de fondo, bordes y formatos de números a cualquier rango de celdas utilizando la API de estilo de IronXL.

¿Es IronXL compatible con la exportación de datos a otros formatos además de Excel?

Sí. IronXL admite los formatos XLSX, XLS, CSV y TSV. Para cambiar de formato, solo es necesario modificar el valor de la enumeración ExcelFileFormat que se pasa a WorkBook.Create.

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

Iron Support Team

We're online 24 hours, 5 days a week.
Chat
Email
Call Me