Cómo exportar DataGridView a Excel en C# con IronXL

¿Cómo se configura un proyecto de Windows Forms para la exportación a Excel?

Windows Forms es una biblioteca de interfaz gráfica de usuario (GUI) fundamental en el ecosistema .NET, ampliamente utilizada para crear aplicaciones de escritorio. El control DataGridView es uno de sus componentes más utilizados: muestra, edita y gestiona datos tabulares de cualquier fuente enlazable, como un DataTable, un resultado de consulta de base de datos o una lista en memoria.

La exportación de esos datos de cuadrícula a Excel satisface varias necesidades cotidianas: enviar informes a las partes interesadas, archivar instantáneas para auditorías o introducir datos en herramientas analíticas posteriores. Los dos enfoques tradicionales son Microsoft Interoperabilidad de Office y las bibliotecas de terceros. Interop requiere una copia de Excel instalada en cada máquina que ejecute la aplicación, crea problemas relacionados con el ciclo de vida de los objetos COM y ofrece un rendimiento deficiente en implementaciones en servidor o en la nube. Bibliotecas como IronXL, ClosedXML y Syncfusion evitan esos problemas escribiendo directamente en el formato de archivo Open XML sin ninguna dependencia de Office.

Esta guía muestra el enfoque de IronXL en C# for .NET 10, aunque IronXL es compatible con .NET Framework 4.6.2 y todas las versiones modernas de .NET.

Install-Package IronXL.Excel

using IronXL;
using System.Data;

using IronXL;
using System.Data;

Imports IronXL
Imports System.Data

¿Cómo se rellena un DataGridView con datos de ejemplo?

Para este recorrido, el formulario contiene un DataGridView llamado DataGridView1 y un botón llamado btnExport. La cuadrícula se llena en el evento Load del formulario con registros de empleados almacenados en un DataTable:

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

    // Define columns with the appropriate .NET type
    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 sample rows
    dt.Rows.Add(101, "Sarah Johnson", "Engineering", 85000m);
    dt.Rows.Add(102, "Michael Chen", "Marketing", 72000m);
    dt.Rows.Add(103, "Emily Davis", "Finance", 91000m);
    dt.Rows.Add(104, "James Wilson", "Engineering", 78000m);

    DataGridView1.DataSource = dt;
}

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

    // Define columns with the appropriate .NET type
    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 sample rows
    dt.Rows.Add(101, "Sarah Johnson", "Engineering", 85000m);
    dt.Rows.Add(102, "Michael Chen", "Marketing", 72000m);
    dt.Rows.Add(103, "Emily Davis", "Finance", 91000m);
    dt.Rows.Add(104, "James Wilson", "Engineering", 78000m);

    DataGridView1.DataSource = dt;
}

Option Strict On



Private Sub Form1_Load(sender As Object, e As EventArgs) Handles MyBase.Load
    Dim dt As New DataTable()

    ' Define columns with the appropriate .NET type
    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 sample rows
    dt.Rows.Add(101, "Sarah Johnson", "Engineering", 85000D)
    dt.Rows.Add(102, "Michael Chen", "Marketing", 72000D)
    dt.Rows.Add(103, "Emily Davis", "Finance", 91000D)
    dt.Rows.Add(104, "James Wilson", "Engineering", 78000D)

    DataGridView1.DataSource = dt
End Sub

Cada columna se define con un tipo .NET específico para que las comparaciones numéricas y el formato funcionen correctamente posteriormente. La propiedad DataSource enlaza el DataTable directamente al DataGridView, y la cuadrícula renderiza automáticamente todas las filas cuando se abre el formulario. En producción, estos datos suelen proceder de una consulta a una base de datos, un conjunto de resultados ORM o una respuesta de una API REST, en lugar de valores codificados de forma rígida.

¿Cómo se exportan los datos de DataGridView a un archivo de Excel con encabezados de columna?

La lógica de exportación se encuentra dentro del controlador de clic del botón. El código crea un nuevo WorkBook, recupera la hoja de trabajo por defecto, escribe encabezados de columna en la primera fila, luego escribe cada fila de datos debajo de ellos:

void btnExport_Click(object sender, EventArgs e)
{
    var workbook = WorkBook.Create();
    var sheet = workbook.DefaultWorkSheet;

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

    // Write data rows starting at row index 1
    for (int row = 0; row < DataGridView1.Rows.Count; row++)
    {
        for (int col = 0; col < DataGridView1.Columns.Count; col++)
        {
            object? cellValue = DataGridView1.Rows[row].Cells[col].Value;
            if (cellValue is not null)
            {
                sheet.SetCellValue(row + 1, col, cellValue.ToString()!);
            }
        }
    }

    string outputPath = "EmployeeData.xlsx";
    workbook.SaveAs(outputPath);
    MessageBox.Show("Export complete. File saved to: " + outputPath, "Success");
}

void btnExport_Click(object sender, EventArgs e)
{
    var workbook = WorkBook.Create();
    var sheet = workbook.DefaultWorkSheet;

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

    // Write data rows starting at row index 1
    for (int row = 0; row < DataGridView1.Rows.Count; row++)
    {
        for (int col = 0; col < DataGridView1.Columns.Count; col++)
        {
            object? cellValue = DataGridView1.Rows[row].Cells[col].Value;
            if (cellValue is not null)
            {
                sheet.SetCellValue(row + 1, col, cellValue.ToString()!);
            }
        }
    }

    string outputPath = "EmployeeData.xlsx";
    workbook.SaveAs(outputPath);
    MessageBox.Show("Export complete. File saved to: " + outputPath, "Success");
}

Private Sub btnExport_Click(sender As Object, e As EventArgs)
    Dim workbook = WorkBook.Create()
    Dim sheet = workbook.DefaultWorkSheet

    ' Write column headers to row index 0
    For col As Integer = 0 To DataGridView1.Columns.Count - 1
        sheet.SetCellValue(0, col, DataGridView1.Columns(col).HeaderText)
    Next

    ' Write data rows starting at row index 1
    For row As Integer = 0 To DataGridView1.Rows.Count - 1
        For col As Integer = 0 To DataGridView1.Columns.Count - 1
            Dim cellValue As Object = DataGridView1.Rows(row).Cells(col).Value
            If cellValue IsNot Nothing Then
                sheet.SetCellValue(row + 1, col, cellValue.ToString())
            End If
        Next
    Next

    Dim outputPath As String = "EmployeeData.xlsx"
    workbook.SaveAs(outputPath)
    MessageBox.Show("Export complete. File saved to: " & outputPath, "Success")
End Sub

El objeto WorkBook representa todo el archivo de Excel en memoria. DefaultWorkSheet devuelve la primera hoja sin requerir que crees una explícitamente. El bucle externo escribe el texto del encabezado desde HeaderText en la fila cero. A continuación, el bucle anidado recorre cada fila de datos, comprobando si hay valores nulos antes de convertir el valor de la celda en una cadena. El desplazamiento row + 1 mueve los datos por debajo de la fila de encabezado. SaveAs escribe el libro de trabajo terminado como un archivo XLSX de Open XML en la ruta especificada.

El archivo resultante se abre en Excel, Google Sheets o cualquier aplicación que lea el formato XLSX. Los encabezados de columna aparecen en la primera fila, y todas las filas de datos siguen en el mismo orden en que aparecieron en el DataGridView.

¿Cómo se aplica el formato de celda al archivo Excel exportado?

Un simple volcado de datos es funcional, pero no está listo para su presentación. La API de estilo de IronXL te permite aplicar fuentes en negrita, colores de fondo, colores de texto y formatos numéricos a cualquier rango de celdas antes de ahorrar:

void ExportWithFormatting()
{
    var workbook = WorkBook.Create();
    var sheet = workbook.DefaultWorkSheet;

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

    // Style the header row: bold white text on blue background
    var headerRange = sheet.GetRange("A1:D1");
    headerRange.Style.Font.Bold = true;
    headerRange.Style.SetBackgroundColor("#4472C4");
    headerRange.Style.Font.SetColor("#FFFFFF");

    // Locate the Salary column index
    int salaryColIndex = -1;
    for (int i = 0; i < DataGridView1.Columns.Count; i++)
    {
        if (string.Equals(DataGridView1.Columns[i].HeaderText, "Salary",
            StringComparison.OrdinalIgnoreCase))
        {
            salaryColIndex = i;
            break;
        }
    }

    // Write data rows, preserving numeric types
    for (int row = 0; row < DataGridView1.Rows.Count; row++)
    {
        if (DataGridView1.Rows[row].IsNewRow) continue;

        for (int col = 0; col < DataGridView1.Columns.Count; col++)
        {
            object? cellValue = DataGridView1.Rows[row].Cells[col].Value;
            if (cellValue is null) continue;

            int targetRow = row + 1;

            if (col == salaryColIndex)
            {
                // Write salary as a true numeric decimal
                if (decimal.TryParse(cellValue.ToString(),
                    System.Globalization.NumberStyles.Number,
                    System.Globalization.CultureInfo.InvariantCulture,
                    out decimal decValue))
                {
                    sheet.SetCellValue(targetRow, col, decValue);
                }
                else
                {
                    sheet.SetCellValue(targetRow, col, cellValue.ToString()!);
                }
            }
            else
            {
                sheet.SetCellValue(targetRow, col, cellValue.ToString()!);
            }
        }
    }

    // Apply currency format to the salary column data range
    var salaryRange = sheet.GetRange("D2:D5");
    salaryRange.FormatString = "$#,##0";

    workbook.SaveAs("FormattedEmployeeData.xlsx");
}

void ExportWithFormatting()
{
    var workbook = WorkBook.Create();
    var sheet = workbook.DefaultWorkSheet;

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

    // Style the header row: bold white text on blue background
    var headerRange = sheet.GetRange("A1:D1");
    headerRange.Style.Font.Bold = true;
    headerRange.Style.SetBackgroundColor("#4472C4");
    headerRange.Style.Font.SetColor("#FFFFFF");

    // Locate the Salary column index
    int salaryColIndex = -1;
    for (int i = 0; i < DataGridView1.Columns.Count; i++)
    {
        if (string.Equals(DataGridView1.Columns[i].HeaderText, "Salary",
            StringComparison.OrdinalIgnoreCase))
        {
            salaryColIndex = i;
            break;
        }
    }

    // Write data rows, preserving numeric types
    for (int row = 0; row < DataGridView1.Rows.Count; row++)
    {
        if (DataGridView1.Rows[row].IsNewRow) continue;

        for (int col = 0; col < DataGridView1.Columns.Count; col++)
        {
            object? cellValue = DataGridView1.Rows[row].Cells[col].Value;
            if (cellValue is null) continue;

            int targetRow = row + 1;

            if (col == salaryColIndex)
            {
                // Write salary as a true numeric decimal
                if (decimal.TryParse(cellValue.ToString(),
                    System.Globalization.NumberStyles.Number,
                    System.Globalization.CultureInfo.InvariantCulture,
                    out decimal decValue))
                {
                    sheet.SetCellValue(targetRow, col, decValue);
                }
                else
                {
                    sheet.SetCellValue(targetRow, col, cellValue.ToString()!);
                }
            }
            else
            {
                sheet.SetCellValue(targetRow, col, cellValue.ToString()!);
            }
        }
    }

    // Apply currency format to the salary column data range
    var salaryRange = sheet.GetRange("D2:D5");
    salaryRange.FormatString = "$#,##0";

    workbook.SaveAs("FormattedEmployeeData.xlsx");
}

Option Strict On



Sub ExportWithFormatting()
    Dim workbook = WorkBook.Create()
    Dim sheet = workbook.DefaultWorkSheet

    ' Write column headers
    For col As Integer = 0 To DataGridView1.Columns.Count - 1
        sheet.SetCellValue(0, col, DataGridView1.Columns(col).HeaderText)
    Next

    ' Style the header row: bold white text on blue background
    Dim headerRange = sheet.GetRange("A1:D1")
    headerRange.Style.Font.Bold = True
    headerRange.Style.SetBackgroundColor("#4472C4")
    headerRange.Style.Font.SetColor("#FFFFFF")

    ' Locate the Salary column index
    Dim salaryColIndex As Integer = -1
    For i As Integer = 0 To DataGridView1.Columns.Count - 1
        If String.Equals(DataGridView1.Columns(i).HeaderText, "Salary", StringComparison.OrdinalIgnoreCase) Then
            salaryColIndex = i
            Exit For
        End If
    Next

    ' Write data rows, preserving numeric types
    For row As Integer = 0 To DataGridView1.Rows.Count - 1
        If DataGridView1.Rows(row).IsNewRow Then Continue For

        For col As Integer = 0 To DataGridView1.Columns.Count - 1
            Dim cellValue As Object = DataGridView1.Rows(row).Cells(col).Value
            If cellValue Is Nothing Then Continue For

            Dim targetRow As Integer = row + 1

            If col = salaryColIndex Then
                ' Write salary as a true numeric decimal
                Dim decValue As Decimal
                If Decimal.TryParse(cellValue.ToString(), Globalization.NumberStyles.Number, Globalization.CultureInfo.InvariantCulture, decValue) Then
                    sheet.SetCellValue(targetRow, col, decValue)
                Else
                    sheet.SetCellValue(targetRow, col, cellValue.ToString())
                End If
            Else
                sheet.SetCellValue(targetRow, col, cellValue.ToString())
            End If
        Next
    Next

    ' Apply currency format to the salary column data range
    Dim salaryRange = sheet.GetRange("D2:D5")
    salaryRange.FormatString = "$#,##0"

    workbook.SaveAs("FormattedEmployeeData.xlsx")
End Sub

El método GetRange acepta la notación estándar de Excel (A1:D1) para seleccionar un bloque contiguo de celdas. Configurar Style.Font.Bold, Style.SetBackgroundColor y Style.Font.SetColor aplica esos formatos a cada celda en el rango seleccionado. Para columnas numéricas, escribir el valor como un decimal en lugar de una cadena mantiene intacto el tipo de datos, lo que significa que Excel puede aplicar correctamente el formato de número como $#,##0. Las celdas almacenadas como cadenas no responden a los códigos de formato numérico.

Puede extender este patrón para aplicar sombreado alternado de filas, ajuste automático de ancho de columna, o congelar paneles consultando la documentación de estilos de IronXL.

¿Cómo se exportan los datos de DataGridView a CSV en lugar de a XLSX?

Algunos flujos de trabajo requieren una salida en formato CSV para garantizar la compatibilidad con sistemas heredados o canalizaciones de datos ligeras. IronXL gestiona la exportación a CSV sin necesidad de realizar ningún cambio de configuración adicional en el código principal:

void ExportToCsv()
{
    var workbook = WorkBook.Create();
    var sheet = workbook.DefaultWorkSheet;

    for (int col = 0; col < DataGridView1.Columns.Count; col++)
    {
        sheet.SetCellValue(0, col, DataGridView1.Columns[col].HeaderText);
    }

    for (int row = 0; row < DataGridView1.Rows.Count; row++)
    {
        if (DataGridView1.Rows[row].IsNewRow) continue;

        for (int col = 0; col < DataGridView1.Columns.Count; col++)
        {
            object? cell = DataGridView1.Rows[row].Cells[col].Value;
            if (cell is not null)
                sheet.SetCellValue(row + 1, col, cell.ToString()!);
        }
    }

    // Saving with a .csv extension produces a comma-separated file
    workbook.SaveAs("EmployeeData.csv");
}

void ExportToCsv()
{
    var workbook = WorkBook.Create();
    var sheet = workbook.DefaultWorkSheet;

    for (int col = 0; col < DataGridView1.Columns.Count; col++)
    {
        sheet.SetCellValue(0, col, DataGridView1.Columns[col].HeaderText);
    }

    for (int row = 0; row < DataGridView1.Rows.Count; row++)
    {
        if (DataGridView1.Rows[row].IsNewRow) continue;

        for (int col = 0; col < DataGridView1.Columns.Count; col++)
        {
            object? cell = DataGridView1.Rows[row].Cells[col].Value;
            if (cell is not null)
                sheet.SetCellValue(row + 1, col, cell.ToString()!);
        }
    }

    // Saving with a .csv extension produces a comma-separated file
    workbook.SaveAs("EmployeeData.csv");
}

Sub ExportToCsv()
    Dim workbook = WorkBook.Create()
    Dim sheet = workbook.DefaultWorkSheet

    For col As Integer = 0 To DataGridView1.Columns.Count - 1
        sheet.SetCellValue(0, col, DataGridView1.Columns(col).HeaderText)
    Next

    For row As Integer = 0 To DataGridView1.Rows.Count - 1
        If DataGridView1.Rows(row).IsNewRow Then Continue For

        For col As Integer = 0 To DataGridView1.Columns.Count - 1
            Dim cell As Object = DataGridView1.Rows(row).Cells(col).Value
            If cell IsNot Nothing Then
                sheet.SetCellValue(row + 1, col, cell.ToString())
            End If
        Next
    Next

    ' Saving with a .csv extension produces a comma-separated file
    workbook.SaveAs("EmployeeData.csv")
End Sub

El único cambio respecto a la exportación XLSX es la extensión del archivo pasada a SaveAs. IronXL detecta la extensión y serializa el libro de trabajo en el formato correcto automáticamente. Esta coherencia significa que la lógica de escritura de datos permanece idéntica independientemente del formato de salida, lo que supone una ventaja significativa frente a las bibliotecas que requieren rutas de código separadas para cada formato.

La exportación a CSV resulta especialmente útil cuando el consumidor final es un script de Python pandas, una herramienta de importación masiva de bases de datos o una plataforma de análisis que no puede leer archivos XLSX binarios.

¿Cómo se gestionan de forma eficiente grandes conjuntos de datos en DataGridView?

En el caso de tablas que contienen decenas de miles de filas, el rendimiento se convierte en un factor a tener en cuenta. El siguiente patrón reduce la presión sobre la memoria al construir el conjunto de datos completo en una sola pasada:

Cuando el DataGridView está enlazado a un DataTable, puedes cargar la tabla directamente en IronXL usando el método WorkSheet.LoadDataTable, evitando por completo la iteración celda por celda. Este enfoque es más rápido y conserva automáticamente todos los tipos de columna.

Para cuadrículas que no están respaldadas por un DataTable, el patrón celda por celda mostrado anteriormente sigue siendo el enfoque estándar. Si necesitas exportar de forma asíncrona para mantener la interfaz de usuario receptiva durante grandes exportaciones, encierra la lógica de exportación en una llamada Task.Run y await el resultado en un hilo en segundo plano. Consulte la documentación sobre operaciones asíncronas con archivos para conocer los patrones de envío de resultados al subproceso de la interfaz de usuario.

¿Por qué IronXL es mejor que Interoperabilidad de Office para la exportación de DataGridView?

Las soluciones tradicionales de .NET usaban Microsoft.Office.Interop.Excel para gestionar un proceso de Excel en ejecución. Este enfoque genera varios problemas de implementación y fiabilidad:

• Cada equipo en el que se ejecute la aplicación necesita tener instalada una copia con licencia de Microsoft Excel
• Los entornos de servidor y los contenedores en la nube no suelen poder instalar Office
• COM Interop requiere la liberación explícita de cada objeto para evitar fugas de memoria y procesos de Excel "zombis".
• El manejo de errores a través del límite COM es prolijo y frágil
• El rendimiento se degrada rápidamente a medida que aumenta el número de filas

IronXL escribe directamente en el formato de archivo OOXML sin iniciar ningún proceso externo. Las aplicaciones se implementan como unidades independientes. La API de la biblioteca es completamente gestionada por .NET, por lo que la recolección de basura maneja la memoria automáticamente sin llamadas Marshal.ReleaseComObject. La velocidad es considerablemente mayor, ya que no se produce comunicación entre procesos.

Para los equipos que estén evaluando alternativas, ClosedXML es una opción de código abierto muy popular. IronXL ofrece un conjunto más amplio de características incluyendo conversión a PDF, generación de gráficos, y soporte comercial, lo que puede ser un factor en decisiones de adquisición empresarial. Consulte las opciones de licencia de IronXL para elegir el nivel adecuado al tamaño de su equipo y su escenario de implementación.

La sección de tutoriales de IronXL abarca la lectura de archivos Excel existentes, la modificación de plantillas, la generación de gráficos y la aplicación de formato condicional, todas ellas capacidades que se derivan de forma natural del patrón de exportación de DataGridView que se muestra aquí.

¿Cuales son tus próximos pasos?

Ahora tienes un código C# funcional para exportar un DataGridView a un archivo Excel formateado usando IronXL. A partir de aquí, ten en cuenta las siguientes indicaciones:

• Agregar manejo de errores: Envuelve el código de exportación en un bloque try/catch y muestra un mensaje amigable para el usuario si el archivo está bloqueado o la ruta es inválida
• Soporte de selección de ruta de archivo: Usa SaveFileDialog para permitir a los usuarios elegir la ubicación y el nombre del archivo de salida en tiempo de ejecución
• Cargar datos reales: Reemplaza el DataTable de muestra con una consulta de base de datos usando ADO.NET o Entity Framework
• Leer archivos existentes: Use WorkBook.Load para abrir una hoja de cálculo existente y actualizarla en lugar de crear siempre una nueva.
• Exportar a múltiples hojas: Crea objetos WorkSheet adicionales en el mismo WorkBook para organizar conjuntos de datos relacionados
• Aplicar formato condicional: resaltar las celdas que superen los umbrales utilizando la API de formato condicional de IronXL
• Revisa las opciones de licencia: hay disponible una versión de prueba gratuita; Los niveles de licencia abarcan desde desarrolladores individuales hasta implementaciones Enterprise
• Consulte la referencia completa de la API: La referencia de objetos de IronXL documenta todas las clases y métodos disponibles