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

¿Cómo se configura un proyecto de Windows Forms para exportar a Excel?

Windows Forms es una biblioteca 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 administra datos tabulares de cualquier fuente enlazable, como un DataTable, un resultado de consulta de base de datos o una lista en memoria.

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

Esta guía demuestra el enfoque IronXL en C# dirigido a .NET 10, aunque IronXL admite .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;

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

Para este tutorial, el formulario contiene un DataGridView llamado DataGridView1 y un botón llamado btnExport. La cuadrícula se completa 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;
}

Cada columna se define con un tipo .NET específico para que las comparaciones numéricas y el formato funcionen correctamente más adelante. La propiedad DataSource vincula DataTable directamente a DataGridView, y la cuadrícula representa automáticamente todas las filas cuando se abre el formulario. En producción, estos datos normalmente provendrían de una consulta de base de datos, un conjunto de resultados ORM o una respuesta de API REST en lugar de valores codificados.

¿Cómo exportar datos de DataGridView a un archivo 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 encabezados de columna en la primera fila y 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");
}

El objeto WorkBook representa todo el archivo Excel en la memoria. DefaultWorkSheet devuelve la primera hoja sin necesidad de crear una explícitamente. El bucle externo escribe el texto del encabezado de HeaderText en la fila cero. Luego, el bucle anidado itera cada fila de datos, verificando si hay valores nulos antes de convertir el valor de la celda en una cadena. El desplazamiento row + 1 desplaza los datos debajo de la fila del encabezado. SaveAs escribe el libro de trabajo 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 en el mismo orden en que aparecieron en DataGridView.

¿Cómo aplicar formato de celda al archivo Excel exportado?

Un volcado de datos simple es funcional pero no está listo para ser presentado. La API de estilo de IronXL le permite aplicar fuentes en negrita, colores de fondo, colores de texto y formatos de números a cualquier rango de celdas antes de guardar:

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

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

Puede ampliar este patrón para aplicar sombreado de filas alternadas, ajuste automático del ancho de columna o congelar paneles consultando la documentación de estilo de IronXL .

¿Cómo exportar datos de DataGridView a CSV en lugar de XLSX?

Algunos flujos de trabajo requieren una salida CSV para ser compatibles con sistemas heredados o canales de datos livianos. IronXL gestiona la exportación CSV sin 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");
}

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 consistencia significa que la lógica de escritura de datos permanece idéntica independientemente del formato de salida: una ventaja significativa sobre las bibliotecas que requieren rutas de código separadas para cada formato.

La exportación CSV es especialmente útil cuando el consumidor final es un script de pandas de Python , 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 gestionar conjuntos de datos grandes de DataGridView de forma eficiente?

Para cuadrículas que contienen decenas de miles de filas, el rendimiento se convierte en un factor a considerar. El siguiente patrón reduce la presión de la memoria al construir el conjunto de datos completo en una sola pasada:

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

Para las 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 necesita exportar de forma asincrónica para mantener la interfaz de usuario receptiva durante exportaciones grandes, envuelva 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 de operaciones de archivos asincrónicos para conocer patrones sobre cómo enviar los resultados al hilo de la interfaz de usuario.

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

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

• Cada máquina que ejecute la aplicación necesita una copia con licencia de Microsoft Excel instalada
• Los entornos de servidor y los contenedores en la nube normalmente no pueden instalar Office
• La interoperabilidad COM requiere la liberación explícita de cada objeto para evitar fugas de memoria y procesos zombi de Excel
• El manejo de errores a través del límite COM es detallado 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 autónomas. La API de la biblioteca es .NET completamente administrada, por lo que la recolección de elementos no utilizados maneja la memoria automáticamente sin llamadas Marshal.ReleaseComObject. La velocidad es sustancialmente mayor porque no se produce comunicación entre procesos.

Para los equipos que evalúan alternativas, ClosedXML es una opción popular de código abierto. IronXL ofrece un conjunto de funciones más amplio que incluye conversión de PDF , generación de gráficos y soporte comercial, que pueden ser factores en las decisiones de adquisición empresarial. Revise las opciones de licencia de IronXL para encontrar el nivel adecuado según el tamaño de su equipo y su escenario de implementación.

La sección de tutoriales de IronXL cubre 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 capacidades que se extienden naturalmente del patrón de exportación DataGridView que se muestra aquí.

¿Cuales son tus próximos pasos?

Ahora tiene código C# funcional para exportar un DataGridView a un archivo Excel formateado usando IronXL. Desde aquí, considere las siguientes direcciones:

• Agregar manejo de errores : envuelva el código de exportación en un bloque try/catch y muestre un mensaje fácil de usar si el archivo está bloqueado o la ruta no es válida
• Admite selección de ruta de archivo : use SaveFileDialog para permitir que los usuarios elijan la ubicación de salida y el nombre del archivo en tiempo de ejecución
• Cargar datos reales : Reemplace el ejemplo DataTable 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 varias hojas : crea objetos WorkSheet adicionales en el mismo WorkBook para organizar conjuntos de datos relacionados
• Aplicar formato condicional : resalte las celdas que excedan los umbrales utilizando la API de formato condicional de IronXL
• Revise las opciones de licencia : Hay una prueba gratuita disponible; Los niveles de licencia cubren desde desarrolladores individuales hasta implementaciones empresariales.
• Explore la referencia completa de la API : La referencia de objetos IronXL documenta todas las clases y métodos disponibles