Como exportar uma lista de objetos para o Excel em C#

Por Que Exportar Listas para Arquivos Excel é Desafiante?

Abordagens tradicionais para exportar dados para Excel frequentemente envolvem o Microsoft Office Interop, que requer a instalação do Excel no servidor e cria dores de cabeça na implantação. O preenchimento manual de célula por célula usando reflexão é demorado e propenso a erros. Os poderosos recursos de importação de dados do IronXL resolvem esses problemas com mapeamento inteligente de propriedades entre fontes de dados e cabeçalhos de colunas do Excel, sem precisar de MS Office ou código de reflexão complexa.

A biblioteca lida com a conversão de tipos automaticamente, oferece suporte a objetos aninhados e mantém a integridade dos dados entre diferentes formatos como arquivos CSV e arquivos XLSX. Para desenvolvedores trabalhando com operações Excel em C# sem Interop, o IronXL é ideal para projetos modernos em .NET que precisam de geração robusta de Excel e capacidades de importação/exportação de dados. A biblioteca integra-se perfeitamente com aplicações .NET MAUI e suporta implantação nas plataformas de nuvem Azure e AWS.

Quando se trabalha com grandes conjuntos de dados, métodos tradicionais muitas vezes enfrentam dificuldades com gerenciamento de memória e desempenho. IronXL trata dessas preocupações com estruturas de dados internas otimizadas que lidam de maneira eficiente com a conversão entre diferentes formatos de planilha, mantendo excelentes características de desempenho.

Como Exportar Dados de Lista Simples para Excel?

Começar com o IronXL requer configuração mínima. Primeiro, instale a biblioteca através do Console do Gerenciador de Pacotes do NuGet:

Install-Package IronXl.Excel

Uma vez instalado, você pode imediatamente começar a criar planilhas Excel a partir de suas estruturas de dados C#. Vamos explorar como exportar dados usando um modelo de Empregado:

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 exemplo de código demonstra como exportar dados para Excel de um List<Employee> usando IronXL. Ele primeiro converte a lista de funcionários em um DataTable, depois escreve manualmente os cabeçalhos das colunas e as linhas em uma planilha. IronXL manipula tipos de dados como int, string, e DateTime automaticamente, garantindo uma formatação limpa na planilha gerada. Finalmente, a função de salvar do Excel produz um arquivo XLSX salvo como EmployeeReport.xlsx, proporcionando uma maneira simples e eficiente de transformar dados estruturados do C# em um relatório Excel profissional.

A abordagem mostrada acima representa um padrão fundamental que pode ser estendido para cenários mais complexos. Por exemplo, você pode precisar exportar conjuntos de dados e datatables de consultas de banco de dados existentes ou importar dados do Excel de fontes externas. IronXL fornece métodos abrangentes para ambos os cenários, tornando-a uma ferramenta versátil para operações de intercâmbio de dados.

Como Exportar Objetos de Negócio Complexos?

Aplicações .NET do mundo real frequentemente envolvem estruturas de dados mais complexas. Ao lidar com propriedades aninhadas, campos calculados ou dados hierárquicos, você precisa de uma abordagem mais sofisticada. IronXL se destaca em lidar com esses cenários, oferecendo suporte robusto para trabalhar com dados em diversos formatos. Aqui está como exportar um inventário de produtos com propriedades aninhadas:

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 demonstra como gerar um relatório dinâmico de inventário de produtos em Excel usando IronXL. Ele cria uma lista de objetos Produto contendo detalhes como SKU, preço, nível de estoque e data de reabastecimento, e então calcula um CalculatedValue derivado para cada item. Os dados são convertidos em um DataTable, escritos em uma planilha Excel com cabeçalhos, e formatados para legibilidade usando colunas dimensionadas automaticamente. IronXL lida perfeitamente com tipos de dados como decimais, booleanos e datas, garantindo uma saída profissional da planilha. O resultado, ProductInventory.xlsx, fornece uma exportação de inventário limpa e orientada por dados, ideal para relatórios empresariais ou análises.

Ao trabalhar com objetos complexos, você também pode precisar gerenciar planilhas para diferentes categorias de dados ou criar várias folhas dentro de um único livro de trabalho. IronXL suporta operações avançadas de planilha, permitindo que você organize seus dados exportados logicamente. Além disso, você pode selecionar intervalos específicos para operações de dados direcionadas ou ordenar células para apresentar os dados em uma ordem significativa.

Como Adicionar Formatação Profissional?

Transforme exportações básicas em relatórios polidos com as amplas capacidades de formatação do IronXL. A formatação profissional eleva suas exportações Excel de despejos de dados simples para relatórios prontos para executivos que comunicam insights de maneira eficaz. IronXL fornece amplas opções de formatação, incluindo personalização de fonte e tamanho de célula, padrões e cores de fundo, e configurações de borda e alinhamento:

// 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");

Essas opções de estilização transformam exportações de dados brutos em relatórios prontos para executivos. Cabeçalhos em negrito com cores de fundo criam hierarquia visual ao exportar coleções para Excel. A formatação de números garante que os valores de moeda sejam exibidos de forma profissional. A formatação condicional destaca métricas de negócios críticas, como baixos níveis de estoque, tornando a planilha Excel exportada imediatamente acionável para gestão de inventário. Saiba mais sobre formatação avançada de células e estilos de borda para melhorar ainda mais suas exportações.

Além da formatação básica, IronXL suporta recursos avançados como criando gráficos do Excel para visualizar seus dados exportados. Você também pode adicionar hiperlinks para conectar pontos de dados relacionados ou recursos externos, congelar painéis para melhor navegação em grandes conjuntos de dados, e até mesclar células para criar layouts de relatórios sofisticados.

Qual é a Melhor Maneira de Começar com IronXL?

O IronXL transforma a tarefa complexa de geração de Excel em código simples e fácil de manter. Seu método inteligente ImportData elimina a necessidade de dependências do Microsoft Office enquanto proporciona resultados profissionais que atendem aos requisitos empresariais. O conjunto abrangente de recursos da biblioteca lida com tudo, desde exportações de listas básicas até transformações de dados complexas com estilo e formatação.

Começar com IronXL é simples. A biblioteca suporta vários cenários de implementação, incluindo contêineres Docker, ambientes Linux, e sistemas macOS. Para implantações empresariais, IronXL oferece opções de licenciamento abrangentes com gestão flexível de chaves de licença.

A biblioteca também se destaca em operações de intercâmbio de dados. Você pode converter XLSX para CSV, escrever arquivos CSV, ler dados CSV, e até converter DataTables para o formato CSV. Para aplicações web, o IronXL se integra perfeitamente com frameworks ASP.NET MVC e Blazor.

Ao trabalhar com arquivos Excel existentes, IronXL fornece poderosos recursos para editar arquivos Excel, abrir planilhas, e ler arquivos XLSX. Você também pode trabalhar com arquivos VB.NET Excel se seu projeto exigir integração com Visual Basic.

!{--010011000100100101000010010100100100000101010010010110010101111101000111010001010101010100010111110101001101010100010000010101001001010100010001010100010001011111010101110100100 101010100010010000101111101010000010100100111101000100010101010100001101010100010111110101010001010010010010010010010100000101001100010111110100001001001100010011110100001101001011--}

Pronto para agilizar suas exportações de Excel em C#? Baixe o IronXL agora que se adapta às suas necessidades. Visite nossa documentação abrangente para mais tutoriais e exemplos. Explore a referência da API para especificações técnicas detalhadas e descubra como IronXL pode transformar seus fluxos de trabalho de automação do Excel.