Cómo exportar una lista de objetos a Excel en C#

¿Por qué es complicado exportar listas a archivos de Excel?

Los enfoques tradicionales para exportar datos a Excel a menudo implican Microsoft Office Interop, que requiere la instalación de Excel en el servidor y genera dolores de cabeza de implementación. La población manual de celda por celda usando reflexiones es un proceso que consume tiempo y es propenso a errores. Las potentes funciones de importación de datos de IronXL resuelven estos problemas con un mapeo de propiedades inteligente entre fuentes de datos y encabezados de columnas de Excel, sin necesidad de MS Office ni código de reflexión complejo.

La biblioteca maneja la conversión de tipos automáticamente, admite objetos anidados y mantiene la integridad de los datos a través de diferentes formatos como archivos CSV y archivos XLSX. Para los desarrolladores que trabajan con operaciones de Excel en C# sin interoperabilidad , IronXL es ideal para proyectos .NET modernos que necesitan capacidades robustas de generación de Excel y de importación/exportación de datos. La biblioteca se integra perfectamente con las aplicaciones .NET MAUI y admite la implementación en plataformas en nube Azure y AWS .

Al trabajar con grandes conjuntos de datos, los métodos tradicionales suelen tener problemas con la gestión de la memoria y el rendimiento. IronXL aborda estas preocupaciones con estructuras de datos internas optimizadas que manejan eficientemente la conversión entre diferentes formatos de hojas de cálculo manteniendo excelentes características de rendimiento.

¿Cómo exportar datos de una lista simple a Excel?

Empezar con IronXL requiere una configuración mínima. Primero, instala la biblioteca a través de la Consola del Administrador de Paquetes NuGet:

Install-Package IronXL.Excel

Una vez instalado, puede comenzar inmediatamente a crear hojas de cálculo de Excel a partir de sus estructuras de datos de C#. Exploremos cómo exportar datos utilizando un modelo de Empleado:

using IronXL;
using System.Collections.Generic;
using System.Data;
public class Employee
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Department { get; set; }
    public decimal Salary { get; set; }
    public DateTime HireDate { get; set; }
}
class Program
{
    static void Main(string[] args)
    {
        // Create sample data for Excel export
        var employees = new List<Employee>
        {
            new Employee { Id = 1, Name = "Alice Johnson", Department = "Engineering",
                           Salary = 95000, HireDate = new DateTime(2020, 3, 15) },
            new Employee { Id = 2, Name = "Bob Smith", Department = "Marketing",
                           Salary = 75000, HireDate = new DateTime(2021, 7, 1) },
            new Employee { Id = 3, Name = "Carol Williams", Department = "Engineering",
                           Salary = 105000, HireDate = new DateTime(2019, 11, 20) }
        };
        // Convert the list of employees to a DataTable
        DataTable dataTable = new DataTable();
        dataTable.Columns.Add("Id", typeof(int));
        dataTable.Columns.Add("Name", typeof(string));
        dataTable.Columns.Add("Department", typeof(string));
        dataTable.Columns.Add("Salary", typeof(decimal));
        dataTable.Columns.Add("HireDate", typeof(DateTime));
        foreach (var employee in employees)
        {
            dataTable.Rows.Add(employee.Id, employee.Name, employee.Department, employee.Salary, employee.HireDate);
        }
        // Export DataTable to Excel spreadsheet
        var workbook = new WorkBook();
        var worksheet = workbook.CreateWorkSheet("Employees");
        // Populate the worksheet
        for (int i = 0; i < dataTable.Columns.Count; i++)
        {
            worksheet.SetCellValue(0, i, dataTable.Columns[i].ColumnName); // Add column headers
        }
        for (int i = 0; i < dataTable.Rows.Count; i++)
        {
            for (int j = 0; j < dataTable.Columns.Count; j++)
            {
                worksheet.SetCellValue(i + 1, j, dataTable.Rows[i][j]); // Add data rows
            }
        }
        // Save as XLSX file
        workbook.SaveAs("EmployeeReport.xlsx");
    }
}

using IronXL;
using System.Collections.Generic;
using System.Data;
public class Employee
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string Department { get; set; }
    public decimal Salary { get; set; }
    public DateTime HireDate { get; set; }
}
class Program
{
    static void Main(string[] args)
    {
        // Create sample data for Excel export
        var employees = new List<Employee>
        {
            new Employee { Id = 1, Name = "Alice Johnson", Department = "Engineering",
                           Salary = 95000, HireDate = new DateTime(2020, 3, 15) },
            new Employee { Id = 2, Name = "Bob Smith", Department = "Marketing",
                           Salary = 75000, HireDate = new DateTime(2021, 7, 1) },
            new Employee { Id = 3, Name = "Carol Williams", Department = "Engineering",
                           Salary = 105000, HireDate = new DateTime(2019, 11, 20) }
        };
        // Convert the list of employees to a DataTable
        DataTable dataTable = new DataTable();
        dataTable.Columns.Add("Id", typeof(int));
        dataTable.Columns.Add("Name", typeof(string));
        dataTable.Columns.Add("Department", typeof(string));
        dataTable.Columns.Add("Salary", typeof(decimal));
        dataTable.Columns.Add("HireDate", typeof(DateTime));
        foreach (var employee in employees)
        {
            dataTable.Rows.Add(employee.Id, employee.Name, employee.Department, employee.Salary, employee.HireDate);
        }
        // Export DataTable to Excel spreadsheet
        var workbook = new WorkBook();
        var worksheet = workbook.CreateWorkSheet("Employees");
        // Populate the worksheet
        for (int i = 0; i < dataTable.Columns.Count; i++)
        {
            worksheet.SetCellValue(0, i, dataTable.Columns[i].ColumnName); // Add column headers
        }
        for (int i = 0; i < dataTable.Rows.Count; i++)
        {
            for (int j = 0; j < dataTable.Columns.Count; j++)
            {
                worksheet.SetCellValue(i + 1, j, dataTable.Rows[i][j]); // Add data rows
            }
        }
        // Save as XLSX file
        workbook.SaveAs("EmployeeReport.xlsx");
    }
}

Este código de ejemplo demuestra cómo exportar datos a Excel desde una List<Employee> usando IronXL. Primero convierte la lista de empleados en una DataTable y luego escribe manualmente los encabezados de columna y las filas en una hoja de cálculo. IronXL maneja automáticamente tipos de datos como int, string y DateTime , lo que garantiza un formato limpio en la hoja de cálculo generada. Finalmente, la función de guardar de Excel produce un archivo XLSX guardado como EmployeeReport , lo que proporciona una forma simple y eficiente de convertir datos estructurados de C# en un informe profesional de Excel .

El enfoque mostrado arriba representa un patrón fundamental que puede extenderse a escenarios más complejos. Por ejemplo, es posible que necesite exportar conjuntos de datos y tablas de datos desde consultas de bases de datos existentes o importar datos de Excel desde fuentes externas. IronXL proporciona métodos integrales para ambos escenarios, lo que lo convierte en una herramienta versátil para operaciones de intercambio de datos.

Hoja de cálculo de Excel que muestra los datos exportados de los empleados con columnas para ID, Nombre, Departamento, Salario y Fecha de contratación, e incluye tres ejemplos de registros de empleados con el formato de datos correcto.

¿Cómo exportar objetos de negocio complejos?

Las aplicaciones de .NET del mundo real a menudo implican estructuras de datos más complejas. Cuando se trabaja con propiedades anidadas, campos calculados o datos jerárquicos, se necesita un enfoque más sofisticado. IronXL se destaca en el manejo de estos escenarios y brinda un soporte sólido para trabajar con datos en varios formatos. A continuación se explica cómo exportar un inventario de productos con propiedades anidadas:

using IronXL;
using System.Collections.Generic;
using System.Data;
public class Product
{
    public string SKU { get; set; }
    public string ProductName { get; set; }
    public string Category { get; set; }
    public decimal Price { get; set; }
    public int StockLevel { get; set; }
    public bool IsActive { get; set; }
    public DateTime LastRestocked { get; set; }
    public decimal CalculatedValue => Price * StockLevel;
}
class Program
{
    static void Main(string[] args)
    {
        // Generate product inventory list for Excel export
        var products = new List<Product>
        {
            new Product
            {
                SKU = "TECH-001",
                ProductName = "Wireless Mouse",
                Category = "Electronics",
                Price = 29.99m,
                StockLevel = 150,
                IsActive = true,
                LastRestocked = DateTime.Now.AddDays(-5)
            },
            new Product
            {
                SKU = "TECH-002",
                ProductName = "Mechanical Keyboard",
                Category = "Electronics",
                Price = 89.99m,
                StockLevel = 75,
                IsActive = true,
                LastRestocked = DateTime.Now.AddDays(-12)
            },
            new Product
            {
                SKU = "OFF-001",
                ProductName = "Desk Organizer",
                Category = "Office Supplies",
                Price = 15.99m,
                StockLevel = 0,
                IsActive = false,
                LastRestocked = DateTime.Now.AddMonths(-1)
            }
        };
        // Create Excel workbook and import collection data
        var workbook = WorkBook.Create();
        var worksheet = workbook.CreateWorkSheet("Inventory");
        // Export generic list to Excel with headers
        var dataTable = new DataTable();
        dataTable.Columns.Add("SKU", typeof(string));
        dataTable.Columns.Add("ProductName", typeof(string));
        dataTable.Columns.Add("Category", typeof(string));
        dataTable.Columns.Add("Price", typeof(decimal));
        dataTable.Columns.Add("StockLevel", typeof(int));
        dataTable.Columns.Add("IsActive", typeof(bool));
        dataTable.Columns.Add("LastRestocked", typeof(DateTime));
        dataTable.Columns.Add("CalculatedValue", typeof(decimal));
        foreach (var product in products)
        {
            dataTable.Rows.Add(
                product.SKU,
                product.ProductName,
                product.Category,
                product.Price,
                product.StockLevel,
                product.IsActive,
                product.LastRestocked,
                product.CalculatedValue
            );
        }
        // With the following code:
        worksheet["A1"].Value = "SKU";
        worksheet["B1"].Value = "ProductName";
        worksheet["C1"].Value = "Category";
        worksheet["D1"].Value = "Price";
        worksheet["E1"].Value = "StockLevel";
        worksheet["F1"].Value = "IsActive";
        worksheet["G1"].Value = "LastRestocked";
        worksheet["H1"].Value = "CalculatedValue";
        int row = 2;
        foreach (DataRow dataRow in dataTable.Rows)
        {
            worksheet[$"A{row}"].Value = dataRow["SKU"];
            worksheet[$"B{row}"].Value = dataRow["ProductName"];
            worksheet[$"C{row}"].Value = dataRow["Category"];
            worksheet[$"D{row}"].Value = dataRow["Price"];
            worksheet[$"E{row}"].Value = dataRow["StockLevel"];
            worksheet[$"F{row}"].Value = dataRow["IsActive"];
            worksheet[$"G{row}"].Value = dataRow["LastRestocked"];
            worksheet[$"H{row}"].Value = dataRow["CalculatedValue"];
            row++;
        }
        // Auto-fit columns for optimal display
        for (int col = 0; col < 8; col++)
        {
            worksheet.AutoSizeColumn(col);
        }
        // Save as Excel XLSX format
        workbook.SaveAs("ProductInventory.xlsx");
    }
}

using IronXL;
using System.Collections.Generic;
using System.Data;
public class Product
{
    public string SKU { get; set; }
    public string ProductName { get; set; }
    public string Category { get; set; }
    public decimal Price { get; set; }
    public int StockLevel { get; set; }
    public bool IsActive { get; set; }
    public DateTime LastRestocked { get; set; }
    public decimal CalculatedValue => Price * StockLevel;
}
class Program
{
    static void Main(string[] args)
    {
        // Generate product inventory list for Excel export
        var products = new List<Product>
        {
            new Product
            {
                SKU = "TECH-001",
                ProductName = "Wireless Mouse",
                Category = "Electronics",
                Price = 29.99m,
                StockLevel = 150,
                IsActive = true,
                LastRestocked = DateTime.Now.AddDays(-5)
            },
            new Product
            {
                SKU = "TECH-002",
                ProductName = "Mechanical Keyboard",
                Category = "Electronics",
                Price = 89.99m,
                StockLevel = 75,
                IsActive = true,
                LastRestocked = DateTime.Now.AddDays(-12)
            },
            new Product
            {
                SKU = "OFF-001",
                ProductName = "Desk Organizer",
                Category = "Office Supplies",
                Price = 15.99m,
                StockLevel = 0,
                IsActive = false,
                LastRestocked = DateTime.Now.AddMonths(-1)
            }
        };
        // Create Excel workbook and import collection data
        var workbook = WorkBook.Create();
        var worksheet = workbook.CreateWorkSheet("Inventory");
        // Export generic list to Excel with headers
        var dataTable = new DataTable();
        dataTable.Columns.Add("SKU", typeof(string));
        dataTable.Columns.Add("ProductName", typeof(string));
        dataTable.Columns.Add("Category", typeof(string));
        dataTable.Columns.Add("Price", typeof(decimal));
        dataTable.Columns.Add("StockLevel", typeof(int));
        dataTable.Columns.Add("IsActive", typeof(bool));
        dataTable.Columns.Add("LastRestocked", typeof(DateTime));
        dataTable.Columns.Add("CalculatedValue", typeof(decimal));
        foreach (var product in products)
        {
            dataTable.Rows.Add(
                product.SKU,
                product.ProductName,
                product.Category,
                product.Price,
                product.StockLevel,
                product.IsActive,
                product.LastRestocked,
                product.CalculatedValue
            );
        }
        // With the following code:
        worksheet["A1"].Value = "SKU";
        worksheet["B1"].Value = "ProductName";
        worksheet["C1"].Value = "Category";
        worksheet["D1"].Value = "Price";
        worksheet["E1"].Value = "StockLevel";
        worksheet["F1"].Value = "IsActive";
        worksheet["G1"].Value = "LastRestocked";
        worksheet["H1"].Value = "CalculatedValue";
        int row = 2;
        foreach (DataRow dataRow in dataTable.Rows)
        {
            worksheet[$"A{row}"].Value = dataRow["SKU"];
            worksheet[$"B{row}"].Value = dataRow["ProductName"];
            worksheet[$"C{row}"].Value = dataRow["Category"];
            worksheet[$"D{row}"].Value = dataRow["Price"];
            worksheet[$"E{row}"].Value = dataRow["StockLevel"];
            worksheet[$"F{row}"].Value = dataRow["IsActive"];
            worksheet[$"G{row}"].Value = dataRow["LastRestocked"];
            worksheet[$"H{row}"].Value = dataRow["CalculatedValue"];
            row++;
        }
        // Auto-fit columns for optimal display
        for (int col = 0; col < 8; col++)
        {
            worksheet.AutoSizeColumn(col);
        }
        // Save as Excel XLSX format
        workbook.SaveAs("ProductInventory.xlsx");
    }
}

Este código demuestra cómo generar un reporte dinámico de inventario de productos en Excel usando IronXL. Construye una lista de objetos Product que contiene detalles como SKU, precio, nivel de existencias y fecha de reposición, y luego calcula un CalculatedValue derivado para cada artículo. Los datos se convierten en una Tabla de datos, se escriben en una hoja de cálculo de Excel con encabezados y se formatean para facilitar su lectura mediante columnas de tamaño automático. IronXL maneja sin problemas tipos de datos como decimales, booleanos y fechas, asegurando una salida de hoja de cálculo profesional. El resultado, ProductInventory , proporciona una exportación de inventario limpia y basada en datos, ideal para informes o análisis comerciales.

Al trabajar con objetos complejos, es posible que también necesite administrar hojas de trabajo para diferentes categorías de datos o crear varias hojas dentro de un solo libro de trabajo. IronXL admite operaciones de hoja de cálculo avanzadas, lo que le permite organizar los datos exportados de forma lógica. Además, puede seleccionar rangos específicos para operaciones de datos específicas u ordenar celdas para presentar los datos en un orden significativo.

Hoja de cálculo de Excel que muestra la exportación del inventario de productos con columnas para SKU, nombre del producto, categoría, precio, nivel de existencias, estado de activo, fecha de última reposición y valor calculado, mostrando diversos productos electrónicos y suministros de oficina.

¿Cómo agregar formato profesional?

Transforme exportaciones básicas en informes pulidos con las capacidades de estilo integrales de IronXL . El formato profesional eleva sus exportaciones de Excel desde simples volcados de datos a informes listos para ejecutivos que comunican información de manera efectiva. IronXL ofrece amplias opciones de formato que incluyen personalización de fuentes y tamaños de celdas , patrones y colores de fondo y configuraciones de bordes y alineación :

// After importing data, apply professional formatting
var headerRange = worksheet["A1:H1"];
headerRange.Style.Font.Bold = true;
headerRange.Style.BackgroundColor = "#4472C4";
headerRange.Style.Font.Color = "#FFFFFF";
// Format currency columns for Excel export
var priceColumn = worksheet["D2:D100"];
priceColumn.Style.NumberFormat = "$#,##0.00";
// Apply conditional formatting to highlight business metrics
for (int row = 2; row <= products.Count + 1; row++)
{
    var stockCell = worksheet[$"E{row}"];
    if (stockCell.IntValue < 10)
    {
        stockCell.Style.BackgroundColor = "#FF6B6B";
    }
}
// Export formatted list to Excel file
workbook.SaveAs("FormattedInventory.xlsx");

// After importing data, apply professional formatting
var headerRange = worksheet["A1:H1"];
headerRange.Style.Font.Bold = true;
headerRange.Style.BackgroundColor = "#4472C4";
headerRange.Style.Font.Color = "#FFFFFF";
// Format currency columns for Excel export
var priceColumn = worksheet["D2:D100"];
priceColumn.Style.NumberFormat = "$#,##0.00";
// Apply conditional formatting to highlight business metrics
for (int row = 2; row <= products.Count + 1; row++)
{
    var stockCell = worksheet[$"E{row}"];
    if (stockCell.IntValue < 10)
    {
        stockCell.Style.BackgroundColor = "#FF6B6B";
    }
}
// Export formatted list to Excel file
workbook.SaveAs("FormattedInventory.xlsx");

Estas opciones de estilo transforman exportaciones de datos en bruto en informes listos para ejecutivos. Encabezados en negrita con colores de fondo crean jerarquía visual al exportar colecciones a Excel. El formato de números garantiza que los valores de la moneda se muestren de manera profesional. El formato condicional resalta métricas comerciales críticas, como niveles bajos de existencias, lo que hace que la hoja de cálculo de Excel exportada sea inmediatamente procesable para la gestión del inventario. Obtenga más información sobre el formato de celda avanzado y los estilos de borde para mejorar aún más sus exportaciones.

Más allá del formato básico, IronXL admite funciones avanzadas como la creación de gráficos de Excel para visualizar los datos exportados. También puede agregar hipervínculos para conectar puntos de datos relacionados o recursos externos, congelar paneles para una mejor navegación en grandes conjuntos de datos e incluso fusionar celdas para crear diseños de informes sofisticados.

Hoja de cálculo de inventario de Excel con formato profesional que muestra SKU, nombre del producto, categoría, precio, nivel de existencias con formato condicional que resalta en rojo el stock cero, el estado "IsActive", las fechas de "Último reabastecimiento" y las columnas "Valor calculado".

¿Cuál es la mejor manera de empezar a utilizar IronXL?

IronXL transforma la compleja tarea de generación de Excel en un código sencillo y mantenible. Su método inteligente ImportData elimina la necesidad de dependencias de Microsoft Office a la vez que proporciona resultados profesionales que cumplen los requisitos de la empresa. El conjunto de características integral de la biblioteca maneja desde exportaciones de listas básicas hasta transformaciones de datos complejas con estilo y formato.

Comenzar a utilizar IronXL es sencillo. La biblioteca admite varios escenarios de implementación, incluidos contenedores Docker , entornos Linux y sistemas macOS . Para implementaciones empresariales, IronXL ofrece opciones de licencia integrales con administración de claves de licencia flexible.

La biblioteca también sobresale en operaciones de intercambio de datos. Puede convertir XLSX a CSV , escribir archivos CSV , leer datos CSV e incluso convertir DataTables al formato CSV . Para aplicaciones web, IronXL se integra perfectamente con los marcos ASP.NET MVC y Blazor .

Al trabajar con archivos Excel existentes, IronXL proporciona potentes funciones para editar archivos Excel , abrir hojas de cálculo y leer archivos XLSX . También puede trabajar con archivos Excel VB.NET si su proyecto requiere integración con Visual Basic.

Empiece con IronXL ahora.

Comience gratis

¿Listo para optimizar tus exportaciones de Excel en C#? Descarga IronXL ahora que se ajusta a tus necesidades. Visite nuestra documentación completa para obtener más tutoriales y ejemplos. Explore la referencia de API para obtener especificaciones técnicas detalladas y descubra cómo IronXL puede transformar sus flujos de trabajo de automatización de Excel.