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

C# Exportar un objeto de lista a Excel

Jordi Bardia
Jordi Bardia
Actualizado:

Exportar colecciones de objetos a archivos de Excel es un requisito fundamental en aplicaciones empresariales. Ya sea generando informes, compartiendo información sobre datos o creando hojas de cálculo de Excel para copias de seguridad, los desarrolladores necesitan una forma confiable de transformar objetos List<t> en hojas de cálculo profesionales. IronXL ofrece una solución que elimina las dificultades tradicionales de crear archivos Excel en .NET 10, .NET Core o .NET Framework , sin necesidad de Microsoft Office en el servidor.

¿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 MS Excel en el servidor y genera dolores de cabeza en la 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 con un mapeo de propiedades inteligente entre fuentes de datos y encabezados de 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 en operaciones de Excel en C# sin interoperabilidad , IronXL es la opción ideal para proyectos .NET modernos que necesitan capacidades confiables de generación de Excel y de importación/exportación de datos.

¿Cómo simplifica IronXL la exportación de objetos?

IronXL elimina la necesidad de registro COM, licencias de Office y ensamblados de interoperabilidad. Cuando exporta un List<t> a Excel, la biblioteca:

  • Asigna propiedades de objetos directamente a los encabezados de columna
  • Convierte los tipos .NET (DateTime, decimal, bool) a sus representaciones correctas en Excel
  • Permite un control detallado sobre los valores de celda, rangos y formato.
  • Guarda la salida en XLSX, XLS, CSV y otros formatos con una única llamada de método

Este enfoque significa que obtendrás una hoja de cálculo limpia y profesional sin tener que escribir cientos de líneas de código repetitivo. También puede importar datos desde Excel más tarde, lo que hace que los flujos de trabajo de datos de ida y vuelta sean sencillos.

¿Cómo se instala IronXL?

Comenzar a usar IronXL requiere una configuración mínima. Instale la biblioteca a través de la consola del administrador de paquetes NuGet :

Install-Package IronXL
Install-Package IronXL
SHELL

O usa la CLI de .NET:

dotnet add package IronXL
dotnet add package IronXL
SHELL

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

¿Cómo exportar una lista simple a Excel?

El siguiente ejemplo demuestra cómo exportar una lista de objetos Employee a un archivo XLSX utilizando declaraciones 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.");
$vbLabelText   $csharpLabel

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

C# Exportar lista de objetos a Excel con IronXL: Imagen 1 - Imagen 1 de 3 relacionadas con C# Exportar lista de objetos a Excel con IronXL

¿Cómo exportar objetos comerciales 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.");
$vbLabelText   $csharpLabel

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

C# Exportar lista de objetos a Excel con IronXL: Imagen 2 - Ejemplo de salida para objetos comerciales complejos

¿Cómo controlar el ancho de columna y la altura de fila?

Después de escribir los datos, puede controlar el diseño visual de la hoja de cálculo mediante programación. El método AutoSizeColumn de IronXL ajusta cada columna para que se ajuste a su contenido. Alternativamente, puede establecer anchos de columna explícitos o agregar y eliminar filas y columnas para ajustar la estructura de la hoja antes de guardar.

Para la altura de fila, IronXL expone propiedades a nivel de fila que le permiten establecer una altura de píxel fija, lo cual es útil cuando la hoja de trabajo se imprimirá o compartirá como PDF. Un tamaño uniforme de columnas y filas también mejora la legibilidad cuando el archivo de Excel se abre en diferentes resoluciones de pantalla o se imprime en diferentes escalas, lo que es particularmente importante para los informes distribuidos a partes interesadas externas.

¿Cómo agregar formato profesional?

El formato transforma las exportaciones básicas en informes pulidos. La API de estilo de IronXL expone configuraciones de fuente, color, borde y formato de número 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.");
$vbLabelText   $csharpLabel

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 de números garantiza que los valores de la moneda 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 de celda avanzado y los estilos de borde para mejorar aún más las exportaciones.

C# Exportar lista de objetos a Excel con IronXL: Imagen 3 - Hoja de cálculo formateada

¿Cómo se aplica el formato condicional mediante programación?

IronXL admite reglas de formato condicional que reflejan la función integrada de Excel. Puede definir reglas basadas en umbrales de valores de celda, coincidencia de texto o rangos de fechas. Una vez que se aplica una regla a un rango, IronXL escribe los metadatos en formato XLSX correspondientes para que el archivo se comporte exactamente como se espera cuando se abre en Excel o Google Sheets.

Esto es particularmente útil cuando el archivo exportado será visto por partes interesadas no técnicas que esperan informes codificados por colores en lugar de datos tabulares simples.

¿Cómo ordenar y filtrar datos antes de exportarlos?

Puede ordenar y filtrar su List<t> antes de escribirlo en Excel. Usando LINQ estándar, puede ordenar empleados por departamento y salario, o filtrar productos solo por artículos activos. Una vez que la lista filtrada esté lista, escríbala en la hoja de trabajo utilizando el mismo enfoque columna por columna que se muestra arriba.

IronXL también admite la clasificación de celdas dentro de un rango ya poblado directamente en el libro de trabajo, lo que permite realizar clasificaciones posteriores a la población sin regresar a la colección original.

¿Cómo exportar listas a otros formatos de archivo?

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

  • XLSX : formato moderno predeterminado de Excel: workbook.SaveAs("output.xlsx")
  • XLS : formato heredado de Excel para versiones anteriores de Office
  • CSV : valores separados por comas para compatibilidad con la canalización 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 informes de usuario final, sino también para generar archivos de datos intermedios utilizados por pipelines ETL, herramientas de ciencia de datos o API de terceros. Para exportar datos de DataGridView (un patrón común en aplicaciones de Windows Forms), IronXL se integra perfectamente sin necesidad de adaptadores adicionales.

¿Cómo gestionar grandes conjuntos de datos de forma eficiente?

Al exportar miles de filas, el rendimiento se convierte en una preocupación. Tenga en cuenta las siguientes pautas:

  • Primero, complete un DataTable y escriba filas en un bucle en lugar de llamar a métodos de establecimiento de celdas individuales repetidamente desde la reflexión.
  • Llame a AutoSizeColumn solo después de que se hayan escrito todos los datos, porque es una operación de lectura y escaneo.
  • Evite abrir el libro de trabajo para volver a leerlo y volver a guardarlo en un bucle cerrado: construya el conjunto de datos completo en la memoria y luego llame a SaveAs una vez.
  • Para conjuntos de datos de más de 100 000 filas, considere dividir la exportación en varias hojas de cálculo para mantener los límites de cantidad de filas de Excel y mantener tamaños de archivo manejables.

IronXL también proporciona un flujo de trabajo de exportación de ASP.NET Core donde el archivo XLSX se escribe directamente en un MemoryStream y se devuelve como una respuesta de descarga de archivo, omitiendo por completo la E/S de disco.

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

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

El controlador inyecta un servicio que construye el WorkBook, llama a workbook.ToByteArray(), luego 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 un tutorial completo, consulte el tutorial de exportación de Excel de ASP.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 generación de Excel en código mantenible. Su API elimina las dependencias de Microsoft Office al tiempo que proporciona resultados profesionales que satisfacen los requisitos empresariales. El conjunto de características de la biblioteca maneja todo, desde exportaciones de listas básicas hasta transformaciones de datos complejas 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 informes resumidos. Combine cualquiera de estas capacidades con las opciones de formato que se muestran arriba para producir hojas de cálculo que no requieren ajustes manuales antes de su distribución.

IronXL está disponible en NuGet y funciona con cualquier proyecto orientado a .NET 10, .NET 8 o .NET Framework 4.6.2+ . El SDK Open XML es la base del formato de archivo XLSX que IronXL lee y escribe, lo que le brinda la seguridad de 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.
green arrow pointer

¿Está listo para comenzar a exportar listas de C# a Excel? Descargue IronXL ahora y experimente lo rápido que puede convertir objetos de lista a Excel en sus aplicaciones .NET . Para implementaciones de producción, explore las opciones de licencia flexibles que se adaptan a sus necesidades. Visita la documentación para obtener más tutoriales y ejemplos.

Preguntas Frecuentes

¿Cómo puedo exportar una lista de C# a un archivo Excel?

Puede exportar una lista de C# a un archivo de Excel utilizando el método ImportData de IronXL, que simplifica el proceso sin requerir Office Interop.

¿Por qué debería usar IronXL para exportar datos a Excel?

IronXL proporciona una solución simplificada para exportar datos a Excel eliminando las complejidades tradicionales y ofreciendo una integración sencilla con .NET, .NET Core o .NET Framework.

¿Necesito tener instalado Microsoft Office para usar IronXL?

No, IronXL no requiere la instalación de Microsoft Office. Funciona de forma independiente, lo que le permite crear y manipular archivos de Excel mediante programación.

¿Puede IronXL manejar objetos complejos en listas al exportar a Excel?

Sí, IronXL puede manejar tanto listas genéricas como objetos complejos, proporcionando flexibilidad en la exportación de varios tipos de datos a Excel.

¿Es IronXL compatible con .NET Core?

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

¿Cuál es la ventaja de utilizar el método ImportData de IronXL?

El método ImportData en IronXL simplifica el proceso de transferencia de datos de listas de C# a Excel, reduciendo la complejidad del código y mejorando la productividad.

¿Puedo crear hojas de cálculo profesionales con IronXL?

Absolutamente, IronXL permite a los desarrolladores transformar objetos List en hojas de cálculo profesionales fácilmente, adecuadas para informes, intercambio de datos o copias de seguridad.

¿Hay ejemplos de código disponibles para utilizar IronXL?

Sí, la documentación y los tutoriales de IronXL proporcionan ejemplos de código sencillos para exportar tanto listas genéricas como objetos complejos a Excel.

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. Prueba gratis

Iron Support Team

We're online 24 hours, 5 days a week.
Chat
Email
Call Me