Ícono de mensaje
Saltar al pie de página
  1. IronXL
  2. Blog de IronXL
  3. Usando IronXL
  4. C# Exportar un objeto de lista a Excel
USANDO IRONXL

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

Jordi Bardia
Jordi Bardia
Publicado:

Exportar colecciones de objetos a archivos de Excel es un requisito fundamental en aplicaciones empresariales. Ya sea generando informes, exportando datos para compartir información o creando hojas de cálculo de Excel para copias de seguridad, los desarrolladores necesitan una forma confiable de transformar objetos List en hojas de cálculo profesionales. IronXL proporciona una solución optimizada que elimina las complejidades tradicionales de crear archivos de Excel en .NET, .NET Core o el .NET Framework.

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

Los enfoques tradicionales para exportar datos a Excel a menudo implican Microsoft Office Interop, lo que requiere la instalación de MS Excel en el servidor y crea problemas 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 inteligente de propiedades entre las fuentes de datos y los encabezados de las columnas de Excel, sin requerir 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 Interop, IronXL es la opción ideal para proyectos modernos de .NET que necesitan capacidades robustas de generación e importación/exportación de datos de Excel.

¿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

En el siguiente ejemplo de código, exploraremos cómo puedes exportar datos usando 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");
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

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 un DataTable, luego escribe manualmente los encabezados de columna y las filas en una hoja de trabajo. IronXL maneja automáticamente tipos de datos como int, string y DateTime, asegurando un formato limpio en la hoja de cálculo generada. Finalmente, la función de guardar en Excel produce un archivo XLSX, que puede guardarse como EmployeeReport.xlsx, proporcionando una manera simple y eficiente de convertir datos estructurados de C# en un informe de Excel profesional.

Cómo Exportar una Lista de Objetos a Excel en C#: Figura 1

¿Cómo exportar objetos de negocio complejos?

Las aplicaciones de .NET del mundo real a menudo implican estructuras de datos más complejas. Aquí se muestra cómo exportar un inventario de productos con propiedades anidadas, utilizando la exportación de lista de objetos de C# a Excel:

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");
    }
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

Este código demuestra cómo generar un reporte dinámico de inventario de productos en Excel usando IronXL. Construye una lista de objetos Producto que contiene detalles como SKU, precio, nivel de stock y fecha de reabastecimiento, luego calcula un ValorCalculado derivado para cada artículo. Los datos se convierten en un DataTable, se escriben en una hoja de trabajo de Excel con encabezados y se formatean para facilidad de lectura utilizando columnas con 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.xlsx, proporciona una exportación de inventario limpia y orientada a los datos, ideal para informes empresariales o análisis.

Cómo Exportar una Lista de Objetos a Excel en C#: Figura 2 - Ejemplo de salida para objetos empresariales complejos

¿Cómo agregar formato profesional?

Transforma exportaciones básicas en informes pulidos con las capacidades de estilo integrales de IronXL:

// 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");
IRON VB CONVERTER ERROR developers@ironsoftware.com
$vbLabelText   $csharpLabel

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 monetarios se muestren profesionalmente. El formato condicional resalta métricas empresariales críticas, como niveles bajos de stock, haciendo el archivo Excel exportado inmediatamente utilizable para la gestión de inventario. Aprende más sobre formateo avanzado de celdas y estilos de bordes para dar más realce a tus exportaciones.

Cómo Exportar una Lista de Objetos a Excel en C#: Figura 3 - Hoja de trabajo formateada

Comience a exportar listas a Excel hoy mismo

IronXL transforma la compleja tarea de generación de Excel en un código sencillo y mantenible. Su método ImportData inteligente elimina la necesidad de dependencias de Microsoft Office mientras ofrece resultados profesionales que cumplen con los requisitos empresariales. 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.

Empiece con IronXL ahora.
green arrow pointer

¿Listo para optimizar tus exportaciones de Excel en C#? Descarga IronXL ahora que se ajusta a tus necesidades. Visita nuestra documentación completa para más tutoriales y ejemplos.

Preguntas Frecuentes

¿Cuál es la función principal de IronXL?

IronXL proporciona una solución simplificada para exportar colecciones de objetos, como List, a archivos de Excel en entornos .NET sin las complejidades de los métodos tradicionales.

¿Cómo simplifica IronXL la exportación de datos a Excel?

IronXL simplifica el proceso al ofrecer un método ImportData, que permite a los desarrolladores transformar fácilmente listas de C# y objetos complejos en hojas de cálculo Excel profesionales sin necesidad de Office Interop.

¿Puede usarse IronXL con .NET Core?

Sí, IronXL es compatible con .NET Core, así como con .NET y el .NET Framework, lo que lo hace versátil para diversos entornos de desarrollo.

¿Es necesario el Office Interop al usar IronXL?

No, IronXL no requiere Office Interop, lo que simplifica el proceso y reduce las dependencias al exportar datos a Excel.

¿Qué tipos de listas de C# pueden ser exportadas usando IronXL?

IronXL puede exportar tanto listas genéricas como objetos complejos a Excel, ofreciendo opciones flexibles para desarrolladores que manejan diversas estructuras de datos.

¿Por qué es importante exportar datos a Excel para aplicaciones empresariales?

Exportar datos a Excel es crucial para generar informes, compartir información y crear copias de seguridad, todo lo cual es fundamental para operaciones empresariales eficaces y la toma de decisiones.

¿Soporta IronXL la creación de hojas de cálculo profesionales?

Sí, IronXL está diseñado para transformar listas de C# en hojas de cálculo Excel de calidad profesional, adecuadas para informes empresariales y análisis de datos.

¿Qué beneficio proporciona IronXL sobre los métodos tradicionales de creación de archivos Excel?

IronXL elimina las complejidades tradicionales y las dependencias involucradas en la creación de archivos Excel, ofreciendo un enfoque más eficiente y fiable para los desarrolladores.

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. Comenzar prueba gratuita