C# Exportar un objeto de lista a Excel

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

Los enfoques tradicionales para exportar datos a Excel suelen implicar 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 funciones de importación de datos de IronXL resuelven estos problemas mediante una asignación inteligente de propiedades entre las fuentes de datos y los encabezados de las columnas de Excel, sin necesidad de MS Office ni de 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 .NET modernos que necesitan capacidades fiables de generación de Excel e importación/exportación de datos.

¿Cómo se instala IronXL?

Para empezar a utilizar IronXL se requiere una configuración mínima. Instala la biblioteca IronXL a través de la consola del gestor de paquetes NuGet:

Install-Package IronXL

Install-Package IronXL

O usa la CLI de .NET:

dotnet add package IronXL

dotnet add package IronXL

Una vez instalado, añada la directiva using IronXL; a su archivo. No se requieren dependencias adicionales de Office ni instalaciones de tiempo de ejecución.

¿Cómo se exporta una lista sencilla a Excel?

El siguiente ejemplo muestra cómo exportar una lista de objetos Employee a un archivo XLSX utilizando sentencias de nivel superior, el estilo preferido en .NET 10:

using IronXL;
using System.Data;

// Define the Employee model
record Employee(int Id, string Name, string Department, decimal Salary, DateTime HireDate);

// Create sample employee data
List<Employee> employees =
[
    new(1, "Alice Johnson", "Engineering", 95000, new DateTime(2020, 3, 15)),
    new(2, "Bob Smith",    "Marketing",   75000, new DateTime(2021, 7, 1)),
    new(3, "Carol Williams","Engineering",105000, new DateTime(2019, 11, 20))
];

// Build a DataTable from the list
DataTable dataTable = new();
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 emp in employees)
    dataTable.Rows.Add(emp.Id, emp.Name, emp.Department, emp.Salary, emp.HireDate);

// Create an IronXL workbook and worksheet
WorkBook workbook  = new();
WorkSheet worksheet = workbook.CreateWorkSheet("Employees");

// Write headers
for (int col = 0; col < dataTable.Columns.Count; col++)
    worksheet.SetCellValue(0, col, dataTable.Columns[col].ColumnName);

// Write data rows
for (int row = 0; row < dataTable.Rows.Count; row++)
    for (int col = 0; col < dataTable.Columns.Count; col++)
        worksheet.SetCellValue(row + 1, col, dataTable.Rows[row][col]);

// Save as XLSX
workbook.SaveAs("EmployeeReport.xlsx");
Console.WriteLine("EmployeeReport.xlsx saved.");

using IronXL;
using System.Data;

// Define the Employee model
record Employee(int Id, string Name, string Department, decimal Salary, DateTime HireDate);

// Create sample employee data
List<Employee> employees =
[
    new(1, "Alice Johnson", "Engineering", 95000, new DateTime(2020, 3, 15)),
    new(2, "Bob Smith",    "Marketing",   75000, new DateTime(2021, 7, 1)),
    new(3, "Carol Williams","Engineering",105000, new DateTime(2019, 11, 20))
];

// Build a DataTable from the list
DataTable dataTable = new();
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 emp in employees)
    dataTable.Rows.Add(emp.Id, emp.Name, emp.Department, emp.Salary, emp.HireDate);

// Create an IronXL workbook and worksheet
WorkBook workbook  = new();
WorkSheet worksheet = workbook.CreateWorkSheet("Employees");

// Write headers
for (int col = 0; col < dataTable.Columns.Count; col++)
    worksheet.SetCellValue(0, col, dataTable.Columns[col].ColumnName);

// Write data rows
for (int row = 0; row < dataTable.Rows.Count; row++)
    for (int col = 0; col < dataTable.Columns.Count; col++)
        worksheet.SetCellValue(row + 1, col, dataTable.Rows[row][col]);

// Save as XLSX
workbook.SaveAs("EmployeeReport.xlsx");
Console.WriteLine("EmployeeReport.xlsx saved.");

Imports IronXL
Imports System.Data

' Define the Employee model
Public Class Employee
    Public Property Id As Integer
    Public Property Name As String
    Public Property Department As String
    Public Property Salary As Decimal
    Public Property HireDate As DateTime

    Public Sub New(id As Integer, name As String, department As String, salary As Decimal, hireDate As DateTime)
        Me.Id = id
        Me.Name = name
        Me.Department = department
        Me.Salary = salary
        Me.HireDate = hireDate
    End Sub
End Class

' Create sample employee data
Dim employees As New List(Of Employee) From {
    New Employee(1, "Alice Johnson", "Engineering", 95000D, New DateTime(2020, 3, 15)),
    New Employee(2, "Bob Smith", "Marketing", 75000D, New DateTime(2021, 7, 1)),
    New Employee(3, "Carol Williams", "Engineering", 105000D, New DateTime(2019, 11, 20))
}

' Build a DataTable from the list
Dim dataTable As New DataTable()
dataTable.Columns.Add("Id", GetType(Integer))
dataTable.Columns.Add("Name", GetType(String))
dataTable.Columns.Add("Department", GetType(String))
dataTable.Columns.Add("Salary", GetType(Decimal))
dataTable.Columns.Add("HireDate", GetType(DateTime))

For Each emp In employees
    dataTable.Rows.Add(emp.Id, emp.Name, emp.Department, emp.Salary, emp.HireDate)
Next

' Create an IronXL workbook and worksheet
Dim workbook As New WorkBook()
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Employees")

' Write headers
For col As Integer = 0 To dataTable.Columns.Count - 1
    worksheet.SetCellValue(0, col, dataTable.Columns(col).ColumnName)
Next

' Write data rows
For row As Integer = 0 To dataTable.Rows.Count - 1
    For col As Integer = 0 To dataTable.Columns.Count - 1
        worksheet.SetCellValue(row + 1, col, dataTable.Rows(row)(col))
    Next
Next

' Save as XLSX
workbook.SaveAs("EmployeeReport.xlsx")
Console.WriteLine("EmployeeReport.xlsx saved.")

Este ejemplo convierte un List<Employee> en un DataTable y, a continuación, escribe encabezados y filas en una hoja de cálculo de IronXL. IronXL gestiona automáticamente tipos de datos como int, string y DateTime, lo que garantiza un formato limpio en la hoja de cálculo generada. La función de guardar de Excel genera un archivo XLSX listo para abrirse en cualquier aplicación de hojas de cálculo.

¿Cómo se exportan objetos de negocio complejos?

Las aplicaciones de .NET del mundo real a menudo implican estructuras de datos más complejas. El siguiente ejemplo genera un informe de inventario de productos con una propiedad calculada:

using IronXL;
using System.Data;

// Define the Product model with a computed property
record Product(
    string SKU,
    string ProductName,
    string Category,
    decimal Price,
    int StockLevel,
    bool IsActive,
    DateTime LastRestocked)
{
    public decimal CalculatedValue => Price * StockLevel;
}

// Build the product list
List<Product> products =
[
    new("TECH-001", "Wireless Mouse",      "Electronics",     29.99m, 150, true,  DateTime.Now.AddDays(-5)),
    new("TECH-002", "Mechanical Keyboard", "Electronics",     89.99m,  75, true,  DateTime.Now.AddDays(-12)),
    new("OFF-001",  "Desk Organizer",      "Office Supplies", 15.99m,   0, false, DateTime.Now.AddMonths(-1))
];

// Populate a DataTable
DataTable dt = new();
dt.Columns.Add("SKU",             typeof(string));
dt.Columns.Add("ProductName",     typeof(string));
dt.Columns.Add("Category",        typeof(string));
dt.Columns.Add("Price",           typeof(decimal));
dt.Columns.Add("StockLevel",      typeof(int));
dt.Columns.Add("IsActive",        typeof(bool));
dt.Columns.Add("LastRestocked",   typeof(DateTime));
dt.Columns.Add("CalculatedValue", typeof(decimal));

foreach (var p in products)
    dt.Rows.Add(p.SKU, p.ProductName, p.Category, p.Price,
                p.StockLevel, p.IsActive, p.LastRestocked, p.CalculatedValue);

// Create the workbook
WorkBook  wb = WorkBook.Create();
WorkSheet ws = wb.CreateWorkSheet("Inventory");

// Write column headers
string[] headers = ["SKU","ProductName","Category","Price",
                    "StockLevel","IsActive","LastRestocked","CalculatedValue"];
for (int col = 0; col < headers.Length; col++)
    ws.SetCellValue(0, col, headers[col]);

// Write data rows
for (int row = 0; row < dt.Rows.Count; row++)
    for (int col = 0; col < dt.Columns.Count; col++)
        ws.SetCellValue(row + 1, col, dt.Rows[row][col]);

// Auto-size columns for readability
for (int col = 0; col < headers.Length; col++)
    ws.AutoSizeColumn(col);

wb.SaveAs("ProductInventory.xlsx");
Console.WriteLine("ProductInventory.xlsx saved.");

using IronXL;
using System.Data;

// Define the Product model with a computed property
record Product(
    string SKU,
    string ProductName,
    string Category,
    decimal Price,
    int StockLevel,
    bool IsActive,
    DateTime LastRestocked)
{
    public decimal CalculatedValue => Price * StockLevel;
}

// Build the product list
List<Product> products =
[
    new("TECH-001", "Wireless Mouse",      "Electronics",     29.99m, 150, true,  DateTime.Now.AddDays(-5)),
    new("TECH-002", "Mechanical Keyboard", "Electronics",     89.99m,  75, true,  DateTime.Now.AddDays(-12)),
    new("OFF-001",  "Desk Organizer",      "Office Supplies", 15.99m,   0, false, DateTime.Now.AddMonths(-1))
];

// Populate a DataTable
DataTable dt = new();
dt.Columns.Add("SKU",             typeof(string));
dt.Columns.Add("ProductName",     typeof(string));
dt.Columns.Add("Category",        typeof(string));
dt.Columns.Add("Price",           typeof(decimal));
dt.Columns.Add("StockLevel",      typeof(int));
dt.Columns.Add("IsActive",        typeof(bool));
dt.Columns.Add("LastRestocked",   typeof(DateTime));
dt.Columns.Add("CalculatedValue", typeof(decimal));

foreach (var p in products)
    dt.Rows.Add(p.SKU, p.ProductName, p.Category, p.Price,
                p.StockLevel, p.IsActive, p.LastRestocked, p.CalculatedValue);

// Create the workbook
WorkBook  wb = WorkBook.Create();
WorkSheet ws = wb.CreateWorkSheet("Inventory");

// Write column headers
string[] headers = ["SKU","ProductName","Category","Price",
                    "StockLevel","IsActive","LastRestocked","CalculatedValue"];
for (int col = 0; col < headers.Length; col++)
    ws.SetCellValue(0, col, headers[col]);

// Write data rows
for (int row = 0; row < dt.Rows.Count; row++)
    for (int col = 0; col < dt.Columns.Count; col++)
        ws.SetCellValue(row + 1, col, dt.Rows[row][col]);

// Auto-size columns for readability
for (int col = 0; col < headers.Length; col++)
    ws.AutoSizeColumn(col);

wb.SaveAs("ProductInventory.xlsx");
Console.WriteLine("ProductInventory.xlsx saved.");

Imports IronXL
Imports System.Data

' Define the Product model with a computed property
Public Class Product
    Public Property SKU As String
    Public Property ProductName As String
    Public Property Category As String
    Public Property Price As Decimal
    Public Property StockLevel As Integer
    Public Property IsActive As Boolean
    Public Property LastRestocked As DateTime

    Public ReadOnly Property CalculatedValue As Decimal
        Get
            Return Price * StockLevel
        End Get
    End Property

    Public Sub New(sku As String, productName As String, category As String, price As Decimal, stockLevel As Integer, isActive As Boolean, lastRestocked As DateTime)
        Me.SKU = sku
        Me.ProductName = productName
        Me.Category = category
        Me.Price = price
        Me.StockLevel = stockLevel
        Me.IsActive = isActive
        Me.LastRestocked = lastRestocked
    End Sub
End Class

' Build the product list
Dim products As New List(Of Product) From {
    New Product("TECH-001", "Wireless Mouse", "Electronics", 29.99D, 150, True, DateTime.Now.AddDays(-5)),
    New Product("TECH-002", "Mechanical Keyboard", "Electronics", 89.99D, 75, True, DateTime.Now.AddDays(-12)),
    New Product("OFF-001", "Desk Organizer", "Office Supplies", 15.99D, 0, False, DateTime.Now.AddMonths(-1))
}

' Populate a DataTable
Dim dt As New DataTable()
dt.Columns.Add("SKU", GetType(String))
dt.Columns.Add("ProductName", GetType(String))
dt.Columns.Add("Category", GetType(String))
dt.Columns.Add("Price", GetType(Decimal))
dt.Columns.Add("StockLevel", GetType(Integer))
dt.Columns.Add("IsActive", GetType(Boolean))
dt.Columns.Add("LastRestocked", GetType(DateTime))
dt.Columns.Add("CalculatedValue", GetType(Decimal))

For Each p In products
    dt.Rows.Add(p.SKU, p.ProductName, p.Category, p.Price, p.StockLevel, p.IsActive, p.LastRestocked, p.CalculatedValue)
Next

' Create the workbook
Dim wb As WorkBook = WorkBook.Create()
Dim ws As WorkSheet = wb.CreateWorkSheet("Inventory")

' Write column headers
Dim headers As String() = {"SKU", "ProductName", "Category", "Price", "StockLevel", "IsActive", "LastRestocked", "CalculatedValue"}
For col As Integer = 0 To headers.Length - 1
    ws.SetCellValue(0, col, headers(col))
Next

' Write data rows
For row As Integer = 0 To dt.Rows.Count - 1
    For col As Integer = 0 To dt.Columns.Count - 1
        ws.SetCellValue(row + 1, col, dt.Rows(row)(col))
    Next
Next

' Auto-size columns for readability
For col As Integer = 0 To headers.Length - 1
    ws.AutoSizeColumn(col)
Next

wb.SaveAs("ProductInventory.xlsx")
Console.WriteLine("ProductInventory.xlsx saved.")

Este código crea una lista de objetos Product que contienen detalles como el SKU, el precio, el nivel de existencias y la fecha de reposición, y luego calcula un CalculatedValue derivado para cada artículo. IronXL gestiona tipos de datos como decimales, booleanos y fechas, lo que garantiza un resultado profesional en hojas de cálculo. El resultado, ProductInventory.xlsx, proporciona una exportación de inventario limpia y basada en datos, adecuada para la elaboración de informes empresariales o análisis. También puede exportar una DataTable a Excel directamente si su código base actual ya funciona con objetos DataTable.

¿Cómo se añade un formato profesional?

El formato transforma las exportaciones básicas en informes pulidos. La API de estilo de IronXL permite configurar la fuente, el color, el borde y el formato numérico en cualquier celda o rango:

using IronXL;

WorkBook  wb = WorkBook.Load("ProductInventory.xlsx");
WorkSheet ws = wb.DefaultWorkSheet;

// Bold header row with a blue background and white text
Range headerRange = ws["A1:H1"];
headerRange.Style.Font.Bold            = true;
headerRange.Style.BackgroundColor      = "#4472C4";
headerRange.Style.Font.Color           = "#FFFFFF";

// Format the Price column as currency
Range priceColumn = ws["D2:D100"];
priceColumn.Style.NumberFormat = "$#,##0.00";

// Highlight low-stock rows in red
for (int row = 2; row <= 4; row++)
{
    var stockCell = ws[$"E{row}"];
    if (stockCell.IntValue < 10)
        stockCell.Style.BackgroundColor = "#FF6B6B";
}

wb.SaveAs("FormattedInventory.xlsx");
Console.WriteLine("FormattedInventory.xlsx saved.");

using IronXL;

WorkBook  wb = WorkBook.Load("ProductInventory.xlsx");
WorkSheet ws = wb.DefaultWorkSheet;

// Bold header row with a blue background and white text
Range headerRange = ws["A1:H1"];
headerRange.Style.Font.Bold            = true;
headerRange.Style.BackgroundColor      = "#4472C4";
headerRange.Style.Font.Color           = "#FFFFFF";

// Format the Price column as currency
Range priceColumn = ws["D2:D100"];
priceColumn.Style.NumberFormat = "$#,##0.00";

// Highlight low-stock rows in red
for (int row = 2; row <= 4; row++)
{
    var stockCell = ws[$"E{row}"];
    if (stockCell.IntValue < 10)
        stockCell.Style.BackgroundColor = "#FF6B6B";
}

wb.SaveAs("FormattedInventory.xlsx");
Console.WriteLine("FormattedInventory.xlsx saved.");

Imports IronXL

Dim wb As WorkBook = WorkBook.Load("ProductInventory.xlsx")
Dim ws As WorkSheet = wb.DefaultWorkSheet

' Bold header row with a blue background and white text
Dim headerRange As Range = ws("A1:H1")
headerRange.Style.Font.Bold = True
headerRange.Style.BackgroundColor = "#4472C4"
headerRange.Style.Font.Color = "#FFFFFF"

' Format the Price column as currency
Dim priceColumn As Range = ws("D2:D100")
priceColumn.Style.NumberFormat = "$#,##0.00"

' Highlight low-stock rows in red
For row As Integer = 2 To 4
    Dim stockCell = ws($"E{row}")
    If stockCell.IntValue < 10 Then
        stockCell.Style.BackgroundColor = "#FF6B6B"
    End If
Next

wb.SaveAs("FormattedInventory.xlsx")
Console.WriteLine("FormattedInventory.xlsx saved.")

Estas opciones de estilo transforman exportaciones de datos en bruto en informes listos para ejecutivos. Los encabezados en negrita con colores de fondo crean una jerarquía visual. El formato numérico garantiza que los valores monetarios se muestren correctamente. 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. Puede obtener más información sobre el formato avanzado de celdas y los estilos de borde para mejorar aún más las exportaciones.

¿Cómo se exportan listas a otros formatos de archivo?

IronXL no se limita a XLSX. El mismo objeto WorkBook se puede guardar en varios formatos con un único cambio de método:

• XLSX -- Formato Excel moderno predeterminado: workbook.SaveAs("output.xlsx")
• XLS: formato Excel heredado para versiones antiguas de Office
• CSV: valores separados por comas para la compatibilidad con el flujo de datos
• TSV -- Valores separados por tabulaciones

Al exportar a formato CSV, cada hoja de cálculo se convierte en un archivo CSV independiente. Esto hace que IronXL sea útil no solo para los informes de los usuarios finales, sino también para generar archivos de datos intermedios utilizados por canalizaciones ETL, herramientas de ciencia de datos o API de terceros. Para exportar datos de DataGridView —un patrón habitual en las aplicaciones de Windows Forms—, IronXL se integra perfectamente sin necesidad de adaptadores adicionales.

¿Cómo se exportan listas a Excel en ASP.NET Core?

Al crear API web o aplicaciones Razor Pages, lo habitual es devolver el archivo Excel como respuesta HTTP en lugar de guardarlo en el disco. El patrón siguiente devuelve un FileContentResult desde una acción del controlador:

El controlador inyecta un servicio que crea el WorkBook, llama a workbook.ToByteArray() y, a continuación, devuelve los bytes con el tipo MIME application/vnd.openxmlformats-officedocument.spreadsheetml.sheet y un encabezado Content-Disposition: attachment. Este enfoque funciona en cualquier API mínima de .NET 10 o controlador MVC.

Para obtener una guía completa, consulte el tutorial de exportación a Excel de .NET Core y el tutorial de exportación de Blazor si está creando una aplicación Blazor WebAssembly o Blazor Server.

¿Cómo empezar a utilizar IronXL hoy mismo?

IronXL transforma la tarea de generar archivos Excel en código fácil de mantener. Su API elimina las dependencias de Microsoft Office al tiempo que ofrece resultados profesionales que satisfacen los requisitos Enterprise. El conjunto de funciones de la biblioteca abarca desde exportaciones básicas de listas hasta transformaciones complejas de datos con estilo y formato.

También puede utilizar IronXL para leer y editar libros de trabajo existentes, exportar datos de Excel a DataTable para su posterior procesamiento o crear tablas dinámicas para la elaboración de informes resumidos. Combine cualquiera de estas funciones con las opciones de formato mostradas anteriormente para crear hojas de cálculo que no requieran ajustes manuales antes de su distribución.

IronXL está disponible en NuGet y funciona con cualquier proyecto destinado a .NET 10, .NET 8 o .NET Framework 4.6.2+. El SDK de Open XML es la base del formato de archivo XLSX que IronXL lee y escribe, lo que le garantiza que los archivos generados cumplen con el estándar ECMA-376 y se abren correctamente en cualquier aplicación compatible con OOXML.

Empiece con IronXL ahora.

Comience gratis

¿Listo para empezar a exportar listas de C# a Excel? Descarga IronXL ahora y comprueba lo rápido que puedes convertir objetos de lista a Excel en tus aplicaciones .NET. Para implementaciones en producción, explore las opciones de licencia flexibles que se adaptan a sus necesidades. Visita la documentación para ver más tutoriales y ejemplos.