Como importar dados do Excel em C# usando o IronXL

Como Você Instala o IronXL e Começa a Importar Excel?

Começar a importar Excel em C# leva apenas minutos com IronXL. A biblioteca Excel lida tanto com os formatos XLS legados quanto os modernos XLSX, junto com CSV, TSV, e outros formatos de planilhas. Ao contrário das soluções que dependem do Microsoft.Office.Interop.Excel, o IronXL funciona de forma independente em qualquer plataforma .NET ou .NET Core.

Instale o IronXL através do Gerenciador de Pacotes NuGet ou do CLI do .NET. Você também pode usar a caixa de diálogo Gerenciar Pacotes NuGet no Visual Studio e procurar por "IronXL":

Install-Package IronXL
dotnet add package IronXL

Install-Package IronXL
dotnet add package IronXL

Para detalhes completos de instalação, incluindo compatibilidade de versão e notas de dependência, consulte o guia de instalação do NuGet do IronXL. Nenhuma dependência de runtime adicional ou componentes do Office são necessários -- o pacote é autossuficiente. Uma vez que o pacote é instalado, importar dados do Excel é simples:

using IronXL;

// Load any Excel file
WorkBook workBook = WorkBook.Load("ProductData.xlsx");
// Access the first worksheet
WorkSheet sheet = workBook.WorkSheets[0];
// Read a cell value
string value = sheet["B1"].StringValue;
Console.WriteLine(value);

using IronXL;

// Load any Excel file
WorkBook workBook = WorkBook.Load("ProductData.xlsx");
// Access the first worksheet
WorkSheet sheet = workBook.WorkSheets[0];
// Read a cell value
string value = sheet["B1"].StringValue;
Console.WriteLine(value);

Este código demonstra o fluxo de trabalho principal: carregando um livro, acessando uma planilha, e lendo valores de célula. O método WorkBook.Load() detecta automaticamente o formato do arquivo -- seja XLS, XLSX ou CSV. A sintaxe intuitiva do indexador sheet["B1"] torna o acesso às células tão natural quanto trabalhar com arrays. Para uma referência completa dos membros e sobrecargas disponíveis, consulte a documentação da API do IronXL.

Como Você Lê Dados do Excel em Objetos C#?

Aplicações reais precisam de mais do que valores de célula única. IronXL se destaca na importação de conjuntos de dados inteiros e na conversão deles em objetos C# utilizáveis. Quando você precisa importar dados estruturados do Excel, a biblioteca oferece múltiplas abordagens que se mapeiam diretamente para os seus modelos de domínio.

O exemplo abaixo lê linhas de uma planilha e mapeia cada linha para um objeto Product tipado:

using IronXL;

// Load the Excel file
WorkBook workBook = WorkBook.Load("ProductData.xlsx");
WorkSheet sheet = workBook.DefaultWorkSheet;

// Map rows to typed objects
var products = new List<Product>();
foreach (var row in sheet.Rows)
{
    var product = new Product
    {
        Id = row.Columns[0].IntValue,
        Name = row.Columns[1].StringValue,
        Price = row.Columns[2].DecimalValue,
        IsAvailable = row.Columns[3].BoolValue
    };
    products.Add(product);
}

foreach (var product in products)
{
    Console.WriteLine(
        $"Id: {product.Id}, Name: {product.Name}, " +
        $"Price: {product.Price}, Available: {product.IsAvailable}"
    );
}

using IronXL;

// Load the Excel file
WorkBook workBook = WorkBook.Load("ProductData.xlsx");
WorkSheet sheet = workBook.DefaultWorkSheet;

// Map rows to typed objects
var products = new List<Product>();
foreach (var row in sheet.Rows)
{
    var product = new Product
    {
        Id = row.Columns[0].IntValue,
        Name = row.Columns[1].StringValue,
        Price = row.Columns[2].DecimalValue,
        IsAvailable = row.Columns[3].BoolValue
    };
    products.Add(product);
}

foreach (var product in products)
{
    Console.WriteLine(
        $"Id: {product.Id}, Name: {product.Name}, " +
        $"Price: {product.Price}, Available: {product.IsAvailable}"
    );
}

As propriedades tipadas -- IntValue, StringValue, DecimalValue e BoolValue -- lidam com a conversão de tipo automaticamente. Esta abordagem elimina a análise manual e reduz erros ao trabalhar com colunas de tipos de dados mistos. Muitos desenvolvedores no Stack Overflow apreciam essa abordagem segura para o tipo na importação de dados do Excel.

using IronXL;

WorkBook workBook = WorkBook.Load("ProductData.xlsx");
WorkSheet sheet = workBook.DefaultWorkSheet;

// Read a named cell range
Range dataRange = sheet["A1:D5"];

// Calculate aggregates directly on a range
decimal sum = sheet["C1:C5"].Sum();
Console.WriteLine($"Sum of C1:C5: {sum}");

decimal max = sheet["C1:C5"].Max(c => c.DecimalValue);
Console.WriteLine($"Max of C1:C5: {max}");

// Filter using LINQ
var highValueOrders = dataRange
    .Where(cell => cell.DecimalValue > 100)
    .Select(cell => cell.Value)
    .ToList();

Console.WriteLine("Orders above 100:");
foreach (var order in highValueOrders)
{
    Console.WriteLine(order);
}

using IronXL;

WorkBook workBook = WorkBook.Load("ProductData.xlsx");
WorkSheet sheet = workBook.DefaultWorkSheet;

// Read a named cell range
Range dataRange = sheet["A1:D5"];

// Calculate aggregates directly on a range
decimal sum = sheet["C1:C5"].Sum();
Console.WriteLine($"Sum of C1:C5: {sum}");

decimal max = sheet["C1:C5"].Max(c => c.DecimalValue);
Console.WriteLine($"Max of C1:C5: {max}");

// Filter using LINQ
var highValueOrders = dataRange
    .Where(cell => cell.DecimalValue > 100)
    .Select(cell => cell.Value)
    .ToList();

Console.WriteLine("Orders above 100:");
foreach (var order in highValueOrders)
{
    Console.WriteLine(order);
}

Como Você Converte Excel para DataTable em C#?

A conversão de DataTable é essencial para operações de banco de dados e cenários de vinculação de dados. IronXL fornece métodos internos que lidam com a conversão de Excel para DataSet ou DataTable. Este recurso é particularmente útil quando você precisa importar planilhas do Excel para o SQL Server ou outros bancos de dados relacionais. Como o objeto resultante é um System.Data.DataTable padrão, ele funciona com qualquer caminho de código compatível com ADO.NET sem exigir alterações na sua camada de acesso a dados.

using IronXL;
using System.Data;
using System.Data.SqlClient;

// Load Excel file
WorkBook workBook = WorkBook.Load("inventory.xlsx");
// Select the first worksheet
WorkSheet sheet = workBook.WorkSheets.First();

// Convert to DataTable -- first row becomes column headers
DataTable dataTable = sheet.ToDataTable(true);

// Use SqlBulkCopy to insert directly into SQL Server
string connectionString = "Data Source=.;Initial Catalog=InventoryDB;Integrated Security=True;";
using (SqlBulkCopy bulkCopy = new SqlBulkCopy(connectionString))
{
    bulkCopy.DestinationTableName = "Inventory";
    bulkCopy.WriteToServer(dataTable);
}

using IronXL;
using System.Data;
using System.Data.SqlClient;

// Load Excel file
WorkBook workBook = WorkBook.Load("inventory.xlsx");
// Select the first worksheet
WorkSheet sheet = workBook.WorkSheets.First();

// Convert to DataTable -- first row becomes column headers
DataTable dataTable = sheet.ToDataTable(true);

// Use SqlBulkCopy to insert directly into SQL Server
string connectionString = "Data Source=.;Initial Catalog=InventoryDB;Integrated Security=True;";
using (SqlBulkCopy bulkCopy = new SqlBulkCopy(connectionString))
{
    bulkCopy.DestinationTableName = "Inventory";
    bulkCopy.WriteToServer(dataTable);
}

O método ToDataTable() aceita um parâmetro booleano indicando se a primeira linha contém cabeçalhos. Quando configurado para true, o IronXL utiliza automaticamente os valores da primeira linha como nomes de colunas. O DataTable resultante se integra com ADO.NET, Entity Framework e controles de vinculação de dados sem necessidade de configuração adicional.

Para mais controle sobre o processo de conversão, você pode construir o DataTable manualmente:

using IronXL;
using System.Data;

WorkBook workBook = WorkBook.Load("inventory.xlsx");
WorkSheet sheet = workBook.WorkSheets.First();

// Build DataTable manually for custom column types or validation
DataTable customTable = new DataTable();

for (int col = 0; col < sheet.ColumnCount; col++)
{
    customTable.Columns.Add($"Column{col + 1}", typeof(string));
}

foreach (var row in sheet.Rows)
{
    var dataRow = customTable.NewRow();
    for (int col = 0; col < sheet.ColumnCount; col++)
    {
        dataRow[col] = row.Columns[col].Value ?? DBNull.Value;
    }
    customTable.Rows.Add(dataRow);
}

// Print headers
foreach (DataColumn column in customTable.Columns)
{
    Console.Write($"{column.ColumnName}\t");
}
Console.WriteLine();

// Print data rows
foreach (DataRow row in customTable.Rows)
{
    foreach (var item in row.ItemArray)
    {
        Console.Write($"{item}\t");
    }
    Console.WriteLine();
}

using IronXL;
using System.Data;

WorkBook workBook = WorkBook.Load("inventory.xlsx");
WorkSheet sheet = workBook.WorkSheets.First();

// Build DataTable manually for custom column types or validation
DataTable customTable = new DataTable();

for (int col = 0; col < sheet.ColumnCount; col++)
{
    customTable.Columns.Add($"Column{col + 1}", typeof(string));
}

foreach (var row in sheet.Rows)
{
    var dataRow = customTable.NewRow();
    for (int col = 0; col < sheet.ColumnCount; col++)
    {
        dataRow[col] = row.Columns[col].Value ?? DBNull.Value;
    }
    customTable.Rows.Add(dataRow);
}

// Print headers
foreach (DataColumn column in customTable.Columns)
{
    Console.Write($"{column.ColumnName}\t");
}
Console.WriteLine();

// Print data rows
foreach (DataRow row in customTable.Rows)
{
    foreach (var item in row.ItemArray)
    {
        Console.Write($"{item}\t");
    }
    Console.WriteLine();
}

Esta abordagem oferece total flexibilidade durante a importação. Valores nulos são tratados de forma eficaz convertendo-os para DBNull.Value, garantindo compatibilidade com restrições de coluna de banco de dados. Para mais orientações sobre como escrever dados de volta para arquivos, veja o guia de escrita de arquivo Excel do IronXL.

Como Você Trabalha com Fórmulas, Livros de Trabalho Multiplos e Entity Framework?

IronXL vai além da leitura básica com recursos para cenários do mundo real complexos. A biblioteca preserva fórmulas do Excel, permitindo que os cálculos sejam avaliados dinamicamente. Para desenvolvedores que trabalham com livros de trabalho Excel complexos, isso mantém a integridade dos dados durante todo o processo de importação.

using IronXL;

WorkBook workBook = WorkBook.Load("FinancialReport.xlsx");
WorkSheet sheet = workBook.GetWorkSheet("Reports");

// Read the evaluated result of a formula cell
decimal calculatedTotal = sheet["E10"].DecimalValue;
Console.WriteLine($"Total: {calculatedTotal}");

// Read the formula string itself
string formula = sheet["E10"].Formula;
Console.WriteLine($"Formula: {formula}"); // e.g. "=SUM(E2:E9)"

using IronXL;

WorkBook workBook = WorkBook.Load("FinancialReport.xlsx");
WorkSheet sheet = workBook.GetWorkSheet("Reports");

// Read the evaluated result of a formula cell
decimal calculatedTotal = sheet["E10"].DecimalValue;
Console.WriteLine($"Total: {calculatedTotal}");

// Read the formula string itself
string formula = sheet["E10"].Formula;
Console.WriteLine($"Formula: {formula}"); // e.g. "=SUM(E2:E9)"

using IronXL;

WorkBook workBook = WorkBook.Load("ProductData.xlsx");
WorkSheet sheet = workBook.DefaultWorkSheet;

// Skip the header row, map remaining rows to entity objects
var products = sheet.Rows
    .Skip(1)
    .Select(row => new Product
    {
        Name = row.Columns[0].StringValue,
        Price = row.Columns[1].DecimalValue
    })
    .ToList();

using var context = new AppDbContext();
await context.Products.AddRangeAsync(products);
await context.SaveChangesAsync();

Console.WriteLine($"Imported {products.Count} products.");

using IronXL;

WorkBook workBook = WorkBook.Load("ProductData.xlsx");
WorkSheet sheet = workBook.DefaultWorkSheet;

// Skip the header row, map remaining rows to entity objects
var products = sheet.Rows
    .Skip(1)
    .Select(row => new Product
    {
        Name = row.Columns[0].StringValue,
        Price = row.Columns[1].DecimalValue
    })
    .ToList();

using var context = new AppDbContext();
await context.Products.AddRangeAsync(products);
await context.SaveChangesAsync();

Console.WriteLine($"Imported {products.Count} products.");

Como Você Lida com a Formataração de Células Durante a Importação?

Quando você importa arquivos Excel, preservar ou inspecionar a formatação das células é frequentemente tão importante quanto ler os valores brutos. O IronXL expõe propriedades de fonte, cor, alinhamento e borda para cada célula, permitindo que você aplique regras de validação ou reproduza estilos de forma programática. Isso é particularmente útil para relatórios onde a formatação visual carrega significado semântico -- por exemplo, células coloridas indicando níveis de risco, ou linhas em negrito marcando totais.

Por exemplo, você pode querer verificar se as células contêm texto em negrito -- um sinal comum de que uma linha é um resumo ou linha de total -- antes de decidir se ela deve ser incluída em seu conjunto de dados importado:

using IronXL;

WorkBook workBook = WorkBook.Load("StyledReport.xlsx");
WorkSheet sheet = workBook.DefaultWorkSheet;

foreach (var row in sheet.Rows)
{
    var firstCell = row.Columns[0];

    // Skip rows where the first cell is bold (typically header or total rows)
    if (firstCell.Style.Font.Bold)
    {
        continue;
    }

    Console.WriteLine($"Data row: {firstCell.StringValue}");
}

using IronXL;

WorkBook workBook = WorkBook.Load("StyledReport.xlsx");
WorkSheet sheet = workBook.DefaultWorkSheet;

foreach (var row in sheet.Rows)
{
    var firstCell = row.Columns[0];

    // Skip rows where the first cell is bold (typically header or total rows)
    if (firstCell.Style.Font.Bold)
    {
        continue;
    }

    Console.WriteLine($"Data row: {firstCell.StringValue}");
}

Para uma referência completa sobre formatação de células e intervalos, incluindo strings de formato de número e acesso à cor de fundo, veja o guia de formatação de células do IronXL. Você também pode aplicar operações de mesclagem aos arquivos de saída após o processamento -- veja o guia de mesclagem de células do IronXL.

Como Você Escolhe a Licença IronXL Correta para Seu Projeto?

O IronXL oferece opções de licenciamento flexíveis para corresponder à escala do seu projeto. Uma licença de avaliação gratuita está disponível para avaliação, que lhe dá acesso a todos os recursos sem restrições de tempo durante o desenvolvimento. A avaliação adiciona uma marca d'água aos arquivos de saída, que é removida com uma licença de produção válida.

Para equipes que desenvolvem aplicações de produção, o licenciamento do IronXL inclui opções para desenvolvedores individuais, equipes e implantações em toda a organização. Todas as licenças de produção incluem:

• Direitos de redistribuição sem royalties
• Suporte prioritário da equipe de desenvolvimento do IronXL
• Acesso a todas as atualizações atuais e de versão secundária durante o período da licença

Se você está avaliando o IronXL junto a outras bibliotecas Excel, a visão geral de recursos do IronXL fornece um detalhamento completo do que está incluído em cada nível.

Para começar a usar o IronXL em seu projeto hoje, visite a página do produto IronXL ou comece diretamente com a documentação do IronXL para guias de configuração, artigos de instrução e referências da API que cobrem todos os recursos da biblioteca.