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 vinculable, como un DataTable, el resultado de una consulta a una 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
dotnet add package IronXL

Install-Package IronXL
dotnet add package IronXL

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 tutorial, el formulario contiene un DataGridView llamado DataGridView1 y un botón llamado btnExport. La cuadrícula se rellena en el evento Load del formulario con los registros de los 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 vincula DataTable directamente a DataGridView, y la cuadrícula muestra 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 cálculo predeterminada, escribe los encabezados de columna en la primera fila y, a continuación, 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 necesidad de crearla explícitamente. El bucle exterior escribe el texto del encabezado de 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 desplaza los datos por debajo de la fila del encabezado. SaveAs guarda el libro terminado como un archivo Open XML XLSX 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 el mismo orden en que aparecían 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. Al establecer Style.Font.Bold, Style.SetBackgroundColor y Style.Font.SetColor, se aplican esos formatos a todas las celdas del rango seleccionado. En las columnas numéricas, escribir el valor como decimal en lugar de como una cadena mantiene intacto el tipo de datos, lo que significa que Excel puede aplicar correctamente el formato numérico, como $#,##0. Las celdas almacenadas como cadenas no responden a los códigos de formato numérico.

Puede ampliar este patrón para aplicar sombreado alterno de filas, ajuste automático del 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 con respecto a la exportación XLSX es la extensión de 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 DataGridView está vinculado a DataTable, puede cargar la tabla directamente en IronXL utilizando 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 las tablas 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 exportaciones de gran volumen, envuelve la lógica de exportación en una llamada Task.Run y ejecuta el resultado en un subproceso 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 .NET tradicionales utilizaban Microsoft.Office.Interop.Excel para controlar 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 .NET totalmente gestionada, por lo que la recolección de basura gestiona 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 de funciones más amplio que incluye conversión a PDF, generación de gráficos y soporte técnico comercial, lo que puede influir en las decisiones de adquisición de Enterprise. 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 dispone de código C# operativo para exportar un DataGridView a un archivo Excel formateado utilizando IronXL. A partir de aquí, ten en cuenta las siguientes indicaciones:

• Añadir gestión de errores: Encerrar el código de exportación en un bloque try/catch y mostrar un mensaje claro para el usuario si el archivo está bloqueado o la ruta no es válida
• Compatibilidad con la selección de la ruta del archivo: utilice SaveFileDialog para permitir a los usuarios elegir la ubicación de salida y el nombre del archivo en tiempo de ejecución
• Cargar datos reales: Sustituya el ejemplo DataTable por una consulta a la base de datos utilizando ADO.NET Framework o Entity Framework
• Leer archivos existentes: Utilice WorkBook.Load para abrir una hoja de cálculo existente y actualizarla, en lugar de crear siempre una nueva
• Exportar a varias 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