Í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
Actualizado:

IronXL lets developers export List objects directly to Excel files in C# without MS Office dependencies, automatically handling type conversion and property mapping through simple ImportData methods that transform collections into professional XLSX spreadsheets.

Exportar colecciones de objetos a archivos de Excel es un requisito fundamental en aplicaciones empresariales. Whether you're generating reports, sharing insights, or creating backups, you need a reliable way to transform List<t> objects into professional spreadsheets. IronXL provides a streamlined solution that eliminates the traditional complexities of creating Excel files in .NET, .NET Core, or the .NET Framework.

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

Traditional approaches to export data to Excel often involve Microsoft Office Interop, which requires Excel installation on the server and creates deployment headaches. La población manual de celda por celda usando reflexiones es un proceso que consume tiempo y es propenso a errores. IronXL's powerful data import features solve these problems with intelligent property mapping between data sources and Excel column headers, without requiring MS Office or complex reflection code.

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. For developers working with C# Excel operations without Interop, IronXL is ideal for modern .NET projects that need robust Excel generation and data import/export capabilities. The library seamlessly integrates with .NET MAUI applications and supports deployment to Azure and AWS cloud platforms.

When working with large datasets, traditional methods often struggle with memory management and performance. IronXL addresses these concerns with optimized internal data structures that efficiently handle converting between different spreadsheet formats while maintaining excellent performance characteristics.

¿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

Once installed, you can immediately begin creating Excel spreadsheets from your C# data structures. Let's explore how to export data using an Employee model:

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

This sample code demonstrates how to export data to Excel from a List<Employee> using IronXL. It first converts the employee list into a DataTable, then manually writes column headers and rows into a worksheet. IronXL handles data types like int, string, and DateTime automatically, ensuring clean formatting in the generated spreadsheet. Finally, the Excel save function produces an XLSX file saved as EmployeeReport.xlsx, providing a simple and efficient way to turn structured C# data into a professional Excel report.

The approach shown above represents a foundational pattern that can be extended for more complex scenarios. For instance, you might need to export datasets and datatables from existing database queries or import Excel data from external sources. IronXL provides comprehensive methods for both scenarios, making it a versatile tool for data interchange operations.

Excel spreadsheet displaying exported employee data with columns for Id, Name, Department, Salary, and HireDate, showing 3 sample employee records with proper data formatting

¿Cómo exportar objetos de negocio complejos?

Las aplicaciones de .NET del mundo real a menudo implican estructuras de datos más complejas. When dealing with nested properties, calculated fields, or hierarchical data, you need a more sophisticated approach. IronXL excels at handling these scenarios, providing robust support for working with data in various formats. Here's how to export a product inventory with nested properties:

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

Este código demuestra cómo generar un reporte dinámico de inventario de productos en Excel usando IronXL. It builds a list of Product objects containing details like SKU, price, stock level, and restock date, then calculates a derived CalculatedValue for each item. The data is converted into a DataTable, written to an Excel worksheet with headers, and formatted for readability using auto-sized columns. IronXL maneja sin problemas tipos de datos como decimales, booleanos y fechas, asegurando una salida de hoja de cálculo profesional. The result, ProductInventory.xlsx, provides a clean, data-driven inventory export ideal for business reporting or analytics.

When working with complex objects, you might also need to manage worksheets for different data categories or create multiple sheets within a single workbook. IronXL supports advanced worksheet operations, allowing you to organize your exported data logically. Additionally, you can select specific ranges for targeted data operations or sort cells to present data in a meaningful order.

Excel spreadsheet displaying product inventory export with columns for SKU, ProductName, Category, Price, StockLevel, IsActive status, LastRestocked date, and CalculatedValue showing various electronics and office supplies

¿Cómo agregar formato profesional?

Transform basic exports into polished reports with IronXL's comprehensive styling capabilities. Professional formatting elevates your Excel exports from simple data dumps to executive-ready reports that communicate insights effectively. IronXL provides extensive formatting options including cell font and size customization, background patterns and colors, and border and alignment settings:

// 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");
$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. Number formatting ensures currency values display professionally. Conditional formatting highlights critical business metrics, such as low stock levels, making the exported Excel spreadsheet immediately actionable for inventory management. Learn more about advanced cell formatting and border styles to enhance your exports further.

Beyond basic formatting, IronXL supports advanced features like creating Excel charts to visualize your exported data. You can also add hyperlinks to connect related data points or external resources, freeze panes for better navigation of large datasets, and even merge cells for creating sophisticated report layouts.

Excel inventory spreadsheet with professional formatting showing SKU, ProductName, Category, Price, StockLevel with conditional formatting highlighting zero stock in red, IsActive status, LastRestocked dates, and CalculatedValue columns

What's the Best Way to Get Started with IronXL?

IronXL transforma la compleja tarea de generación de Excel en un código sencillo y mantenible. Its intelligent ImportData method eliminates the need for Microsoft Office dependencies while providing professional results that meet enterprise requirements. 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.

Getting started with IronXL is straightforward. The library supports various deployment scenarios including Docker containers, Linux environments, and macOS systems. For enterprise deployments, IronXL provides comprehensive licensing options with flexible license key management.

The library also excels at data interchange operations. You can convert XLSX to CSV, write CSV files, read CSV data, and even convert DataTables to CSV format. For web applications, IronXL integrates seamlessly with ASP.NET MVC and Blazor frameworks.

When working with existing Excel files, IronXL provides powerful features to edit Excel files, open worksheets, and read XLSX files. You can also work with VB.NET Excel files if your project requires Visual Basic integration.

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. Visit our comprehensive documentation for more tutorials and examples. Explore the API reference for detailed technical specifications and discover how IronXL can transform your Excel automation workflows.

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

Equipo de soporte de Iron

Estamos disponibles online las 24 horas, 5 días a la semana.
Chat
Email
Llámame