Ícone de mensagem
Ir para o conteúdo do rodapé
  1. IronXL
  2. Blog IronXL
  3. Usando o IronXL
  4. Exportar objeto de lista para o Excel em C#
USANDO O IRONXL

Exportar objeto de lista para o Excel em C#

Jordi Bardia
Jordi Bardia
Atualizado:

Exportar coleções de objetos para arquivos Excel é um requisito fundamental em aplicativos de negócios. Seja gerando relatórios, compartilhando insights de dados ou criando planilhas Excel para backups, os desenvolvedores precisam de uma maneira confiável para transformar objetos List<t> em planilhas profissionais. IronXL oferece uma solução que elimina as dificuldades tradicionais de criar arquivos Excel em .NET 10, .NET Core, ou .NET Framework -- sem exigir o Microsoft Office no servidor.

Por Que Exportar Listas para Arquivos Excel é Desafiante?

Abordagens tradicionais para exportar dados para Excel muitas vezes envolvem o Interop do Microsoft Office, que exige a instalação do MS 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. As funções de importação de dados do IronXL resolvem esses problemas com mapeamento inteligente de propriedades entre fontes de dados e cabeçalhos de colunas Excel, sem exigir MS Office ou código de reflexão complexo.

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 que trabalham em operações Excel em C# sem Interop, IronXL é a escolha ideal para projetos modernos .NET que precisam de uma geração de Excel confiável e capacidades de importação/exportação de dados.

Como o IronXL Simplifica a Exportação de Objetos?

IronXL remove a necessidade de registro COM, licenças do Office e assemblies de interoperação. Quando você exporta um List<t> para Excel, a biblioteca:

  • Mapeia propriedades do objeto diretamente para cabeçalhos de coluna
  • Converte tipos .NET (DateTime, decimal, bool) para suas representações corretas no Excel.
  • Permite controle detalhado sobre valores de célula, intervalos e formatação
  • Salva a saída em formatos XLSX, XLS, CSV e outros com uma única chamada de método

Essa abordagem significa que você obtém uma saída de planilha limpa e profissional sem escrever centenas de linhas de código repetitivo. Você também pode importar dados de volta do Excel posteriormente, tornando os fluxos de trabalho de dados de ida e volta diretos.

Como Instalar o IronXL?

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

Install-Package IronXL
Install-Package IronXL
SHELL

Ou utilize a CLI do .NET :

dotnet add package IronXL
dotnet add package IronXL
SHELL

Uma vez instalado, adicione a diretiva using IronXL; ao seu arquivo. Não são necessárias dependências adicionais do Office ou instalações em tempo de execução.

Como Exportar uma Lista Simples para Excel?

O exemplo a seguir demonstra a exportação de uma lista de objetos Employee para um arquivo XLSX usando declarações de nível superior, o estilo preferencial no .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 exemplo converte um List<Employee> em um DataTable, depois escreve cabeçalhos e linhas em uma planilha IronXL. IronXL lida automaticamente com tipos de dados como int, string, e DateTime, garantindo formatação limpa na planilha gerada. A função de salvar Excel produz um arquivo XLSX pronto para abrir em qualquer aplicativo de planilha.

C# Export List of Objects to Excel with IronXL: Image 1 - Image 1 de 3 relacionado a C# Export List of Objects to Excel with IronXL

Como Exportar Objetos de Negócios Complexos?

Aplicações .NET do mundo real frequentemente envolvem estruturas de dados mais complexas. O exemplo a seguir gera um relatório de inventário de produtos com uma propriedade 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 constrói uma lista de objetos Product contendo detalhes como SKU, preço, nível de estoque e data de reabastecimento, então calcula um CalculatedValue derivado para cada item. IronXL lida com tipos de dados como decimais, booleanos e datas, garantindo uma saída de planilha profissional. O resultado, ProductInventory.xlsx, fornece uma exportação de inventário limpa e orientada a dados adequada para relatórios ou análises de negócios. Você também pode exportar uma DataTable para Excel diretamente se sua base de código existente já funcionar com objetos DataTable.

C# Export List of Objects to Excel with IronXL: Image 2 - Exemplo de saída para objetos de negócios complexos

Como você controla a largura da coluna e a altura da linha?

Após escrever os dados, você pode controlar o layout visual da planilha programaticamente. O método AutoSizeColumn do IronXL ajusta cada coluna para caber em seu conteúdo. Alternativamente, você pode definir larguras de coluna explícitas ou adicionar e remover linhas e colunas para ajustar a estrutura da planilha antes de salvar.

Para a altura das linhas, o IronXL expõe propriedades no nível da linha que permitem definir uma altura fixa em pixels -- útil quando a planilha será impressa ou compartilhada como PDF. A consistência no tamanho das colunas e linhas também melhora a legibilidade quando o arquivo Excel é aberto em diferentes resoluções de tela ou impresso em escalas diferentes, o que é particularmente importante para relatórios distribuídos a stakeholders externos.

Como você adiciona formatação profissional?

A formatação transforma exportações básicas em relatórios elaborados. A API de estilização do IronXL expõe configurações de fonte, cor, borda e formato numérico em qualquer célula ou intervalo:

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

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. A formatação de números garante que os valores de moeda sejam exibidos corretamente. A formatação condicional destaca métricas de negócios críticas, como níveis baixos de estoque, tornando a planilha Excel exportada imediatamente acionável para gerenciamento de inventário. Você pode aprender mais sobre formatação avançada de células e estilos de borda para melhorar ainda mais as exportações.

C# Export List of Objects to Excel with IronXL: Image 3 - Planilha formatada

Como você aplica formatação condicional programaticamente?

O IronXL suporta regras de formatação condicional que espelham a funcionalidade incorporada do Excel. Você pode definir regras com base em limites de valor de célula, correspondência de texto ou intervalos de datas. Uma vez que a regra é aplicada a um intervalo, o IronXL grava os metadados de formato XLSX correspondentes para que o arquivo se comporte exatamente como esperado quando aberto no Excel ou no Google Sheets.

Isso é particularmente útil quando o arquivo exportado será visualizado por stakeholders não técnicos que esperam relatórios codificados por cores em vez de dados tabulares simples.

Como você classifica e filtra dados antes de exportar?

Você pode classificar e filtrar seu List<t> antes de escrevê-lo no Excel. Usando LINQ padrão, você pode ordenar funcionários por departamento e salário, ou filtrar produtos para apenas itens ativos. Uma vez que a lista filtrada está pronta, escreva-a na planilha usando a mesma abordagem coluna por coluna mostrada acima.

O IronXL também oferece suporte a ordenação de células dentro de um intervalo já populado diretamente na pasta de trabalho -- permitindo ordenações pós-população sem retornar à coleção original.

Como você exporta listas para outros formatos de arquivo?

O IronXL não está limitado ao XLSX. O mesmo objeto WorkBook pode ser salvo em vários formatos com uma única alteração de método:

  • XLSX -- Formato moderno padrão do Excel: workbook.SaveAs("output.xlsx")
  • XLS -- Formato legado do Excel para versões antigas do Office
  • CSV -- Valores separados por vírgulas para compatibilidade com pipeline de dados
  • TSV -- Valores separados por tabulação

Ao exportar para o formato CSV, cada planilha se torna um arquivo CSV separado. Isso torna o IronXL útil não apenas para relatórios de usuários finais, mas também para gerar arquivos de dados intermediários consumidos por pipelines ETL, ferramentas de ciência de dados ou APIs de terceiros. Para exportar dados do DataGridView -- um padrão comum em aplicativos Windows Forms -- o IronXL se encaixa perfeitamente sem exigir adaptadores adicionais.

Como você lida com grandes conjuntos de dados de maneira eficiente?

Ao exportar milhares de linhas, o desempenho torna-se uma preocupação. Mantenha as seguintes diretrizes em mente:

  • Popule inicialmente um DataTable e escreva linhas em um loop, ao invés de chamar métodos individuais de configuração de célula repetidamente da reflexão.
  • Chame AutoSizeColumn somente após todos os dados serem escritos, pois é uma operação de leitura-varredura.
  • Evite abrir o livro para reler e salvar novamente em um loop apertado -- construa o conjunto de dados completo na memória, depois chame SaveAs uma vez.
  • Para conjuntos de dados com mais de 100.000 linhas, considere dividir a exportação em várias planilhas para manter os limites de contagem de linhas do Excel e manter os tamanhos de arquivo gerenciáveis.

IronXL também fornece um fluxo de trabalho de exportação ASP.NET Core onde o arquivo XLSX é escrito diretamente para um MemoryStream e retornado como uma resposta de download de arquivo, ignorando totalmente a E/S do disco.

Como você exporta listas para Excel no ASP.NET Core?

Ao criar APIs da web ou aplicativos de Razor Pages, você geralmente quer retornar o arquivo Excel como uma resposta HTTP em vez de salvá-lo no disco. O padrão abaixo retorna um FileContentResult de uma ação do controlador:

O controlador injeta um serviço que constrói o WorkBook, chama workbook.ToByteArray(), depois retorna os bytes com o tipo MIME application/vnd.openxmlformats-officedocument.spreadsheetml.sheet e um cabeçalho Content-Disposition: attachment. Esta abordagem funciona em qualquer API mínima .NET 10 ou controlador MVC.

Para um tutorial completo, veja o tutorial de exportação Excel ASP.NET Core e o tutorial de exportação Blazor se você estiver construindo um aplicativo Blazor WebAssembly ou Blazor Server.

Como iniciar com o IronXL hoje?

O IronXL transforma a tarefa de geração de Excel em código sustentável. Sua API elimina dependências do Microsoft Office ao fornecer resultados profissionais que atendem aos requisitos empresariais. O conjunto de recursos da biblioteca lida com tudo, desde exportações básicas de listas até transformações de dados complexas com estilo e formatação.

Você também pode usar o IronXL para ler e editar planilhas existentes, exportar dados do Excel para DataTable para processamento adicional ou criar tabelas dinâmicas para relatórios de resumo. Combine qualquer uma dessas capacidades com as opções de formatação mostradas acima para produzir planilhas que não necessitem de ajustes manuais antes da distribuição.

IronXL está disponível no NuGet e funciona com qualquer projeto direcionado para .NET 10, .NET 8 ou .NET Framework 4.6.2+. O Open XML SDK é a base do formato de arquivo XLSX que o IronXL lê e escreve, dando-lhe confiança de que os arquivos gerados estão em conformidade com o padrão ECMA-376 e abrem corretamente em qualquer aplicativo compatível com OOXML.

!{--010011000100100101000010010100100100000101010010010110010101111101000111010001010101010100010111110101001101010100010000010101001001010100010001010100010001011111010101110100100 101010100010010000101111101010000010100100111101000100010101010100001101010100010111110101010001010010010010010010010100000101001100010111110100001001001100010011110100001101001011--}

Pronto para começar a exportar listas C# para Excel? Baixe o IronXL agora e veja quão rapidamente você pode converter objetos de lista para Excel em suas aplicações .NET. Para implantações de produção, explore as opções de licenciamento flexíveis que se adaptam às suas necessidades. Visite a documentação para mais tutoriais e exemplos.

Perguntas frequentes

Como posso exportar uma lista em C# para um arquivo do Excel?

Você pode exportar uma lista C# para um arquivo Excel usando o método ImportData do IronXL, o que simplifica o processo sem exigir o Office Interop.

Por que devo usar o IronXL para exportar dados para o Excel?

O IronXL oferece uma solução simplificada para exportar dados para o Excel, eliminando as complexidades tradicionais e proporcionando fácil integração com .NET, .NET Core ou .NET Framework.

Preciso ter o Microsoft Office instalado para usar o IronXL?

Não, o IronXL não requer a instalação do Microsoft Office. Ele funciona de forma independente, permitindo que você crie e manipule arquivos do Excel programaticamente.

O IronXL consegue lidar com objetos complexos em listas ao exportar para o Excel?

Sim, o IronXL consegue lidar tanto com listas genéricas quanto com objetos complexos, oferecendo flexibilidade na exportação de diversos tipos de dados para o Excel.

O IronXL é compatível com o .NET Core?

Sim, o IronXL é compatível com o .NET Core, bem como com o .NET e o .NET Framework, o que o torna versátil para diferentes ambientes de desenvolvimento.

Qual a vantagem de usar o método ImportData do IronXL?

O método ImportData do IronXL simplifica o processo de transferência de dados de listas C# para o Excel, reduzindo a complexidade do código e aumentando a produtividade.

Posso criar planilhas profissionais usando o IronXL?

Com certeza, o IronXL permite que os desenvolvedores transformem objetos List em planilhas profissionais facilmente, adequadas para relatórios, compartilhamento de dados ou backups.

Existem exemplos de código disponíveis para usar o IronXL?

Sim, a documentação e os tutoriais do IronXL fornecem exemplos de código simples para exportar tanto listas genéricas quanto objetos complexos para o Excel.

Jordi Bardia
Jordi Bardia
  Converse agora mesmo com a equipe de engenharia.
Engenheiro de Software
Jordi é extremamente proficiente em Python, C# e C++, e quando não está utilizando suas habilidades na Iron Software, dedica-se à programação de jogos. Compartilhando as responsabilidades por testes, desenvolvimento e pesquisa de produtos, Jordi agrega imenso valor à melhoria contínua dos produtos. Essa experiência diversificada o mantém ...
Leia mais

Artigos relacionados

Teste grátis por 30 dias → Produto completo. Sem limites. Sem cartão. Comece seu teste gratuito

Iron Support Team

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