Trabalhar com arquivos Microsoft Excel é uma exigência diária para muitos desenvolvedores .NET. Seja importando dados de clientes, processando relatórios financeiros, ou migrando dados de planilhas para bancos de dados, os desenvolvedores precisam de uma maneira confiável de ler arquivos Excel sem dependências complexas ou a necessidade de instalação do Excel. Abordagens tradicionais, como automação COM através do Microsoft.Office.Interop, exigem uma instalação completa do Office, introduzem restrições de plataforma, e criam dependências frágeis de implantação. IronXL oferece uma solução direta que funciona entre plataformas, eliminando todos esses problemas e permitindo operações Excel diretamente do código .NET gerenciado.
Começar a importar Excel em C# leva apenas minutos com IronXL. A biblioteca do Excel é compatível com os formatos XLS (legados) e XLSX (modernos), além de CSV , TSV e outros formatos de planilha. 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":
Para obter detalhes completos sobre a instalação, incluindo compatibilidade de versões e notas sobre dependências, consulte o guia de instalação do IronXL NuGet . 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);Imports IronXL
' Load any Excel file
Dim workBook As WorkBook = WorkBook.Load("ProductData.xlsx")
' Access the first worksheet
Dim sheet As WorkSheet = workBook.WorkSheets(0)
' Read a cell value
Dim value As String = 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 ele 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.
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 várias abordagens que se mapeiam diretamente aos 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}"
);
}Imports IronXL
' Load the Excel file
Dim workBook As WorkBook = WorkBook.Load("ProductData.xlsx")
Dim sheet As WorkSheet = workBook.DefaultWorkSheet
' Map rows to typed objects
Dim products As New List(Of Product)()
For Each row In sheet.Rows
Dim product As New Product With {
.Id = row.Columns(0).IntValue,
.Name = row.Columns(1).StringValue,
.Price = row.Columns(2).DecimalValue,
.IsAvailable = row.Columns(3).BoolValue
}
products.Add(product)
Next
For Each product In products
Console.WriteLine(
$"Id: {product.Id}, Name: {product.Name}, " &
$"Price: {product.Price}, Available: {product.IsAvailable}"
)
NextAs propriedades tipadas -- IntValue, StringValue, DecimalValue e BoolValue -- lidam com a conversão de tipos 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.
Para cálculos agregados e consultas filtradas, o IronXL suporta operações de intervalo com compatibilidade LINQ embutida:
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);
}Imports IronXL
Dim workBook As WorkBook = WorkBook.Load("ProductData.xlsx")
Dim sheet As WorkSheet = workBook.DefaultWorkSheet
' Read a named cell range
Dim dataRange As Range = sheet("A1:D5")
' Calculate aggregates directly on a range
Dim sum As Decimal = sheet("C1:C5").Sum()
Console.WriteLine($"Sum of C1:C5: {sum}")
Dim max As Decimal = sheet("C1:C5").Max(Function(c) c.DecimalValue)
Console.WriteLine($"Max of C1:C5: {max}")
' Filter using LINQ
Dim highValueOrders = dataRange _
.Where(Function(cell) cell.DecimalValue > 100) _
.Select(Function(cell) cell.Value) _
.ToList()
Console.WriteLine("Orders above 100:")
For Each order In highValueOrders
Console.WriteLine(order)
NextA classe Range fornece acesso semelhante a coleção para múltiplas células simultaneamente. A compatibilidade com LINQ significa que você pode filtrar, transformar e agregar dados do Excel usando padrões familiares de C# sem converter primeiro para coleções intermediárias. Os métodos de agregação embutidos, como Sum() e Max(), operam diretamente nos intervalos de células. Para obter mais detalhes sobre como ler dados de planilhas, consulte o guia de leitura de arquivos Excel do IronXL .
A conversão de DataTable é essencial para operações de banco de dados e cenários de vinculação de dados. O IronXL fornece métodos integrados 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 mudanças 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);
}Imports IronXL
Imports System.Data
Imports System.Data.SqlClient
' Load Excel file
Dim workBook As WorkBook = WorkBook.Load("inventory.xlsx")
' Select the first worksheet
Dim sheet As WorkSheet = workBook.WorkSheets.First()
' Convert to DataTable -- first row becomes column headers
Dim dataTable As DataTable = sheet.ToDataTable(True)
' Use SqlBulkCopy to insert directly into SQL Server
Dim connectionString As String = "Data Source=.;Initial Catalog=InventoryDB;Integrated Security=True;"
Using bulkCopy As New SqlBulkCopy(connectionString)
bulkCopy.DestinationTableName = "Inventory"
bulkCopy.WriteToServer(dataTable)
End UsingO método ToDataTable() aceita um parâmetro booleano indicando se a primeira linha contém cabeçalhos. Quando ajustado para true, o IronXL usa automaticamente os valores da primeira linha como nomes de coluna. 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();
}Imports IronXL
Imports System.Data
Dim workBook As WorkBook = WorkBook.Load("inventory.xlsx")
Dim sheet As WorkSheet = workBook.WorkSheets.First()
' Build DataTable manually for custom column types or validation
Dim customTable As New DataTable()
For col As Integer = 0 To sheet.ColumnCount - 1
customTable.Columns.Add($"Column{col + 1}", GetType(String))
Next
For Each row In sheet.Rows
Dim dataRow = customTable.NewRow()
For col As Integer = 0 To sheet.ColumnCount - 1
dataRow(col) = If(row.Columns(col).Value, DBNull.Value)
Next
customTable.Rows.Add(dataRow)
Next
' Print headers
For Each column As DataColumn In customTable.Columns
Console.Write($"{column.ColumnName}" & vbTab)
Next
Console.WriteLine()
' Print data rows
For Each row As DataRow In customTable.Rows
For Each item In row.ItemArray
Console.Write($"{item}" & vbTab)
Next
Console.WriteLine()
NextEsta abordagem oferece total flexibilidade durante a importação. Valores nulos são tratados graciosamente convertendo-os para DBNull.Value, garantindo compatibilidade com restrições de colunas do banco de dados. Para obter mais orientações sobre como gravar dados de volta em arquivos, consulte o guia de gravação de arquivos Excel do IronXL .
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 planilhas complexas do Excel , 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)"Imports IronXL
Dim workBook As WorkBook = WorkBook.Load("FinancialReport.xlsx")
Dim sheet As WorkSheet = workBook.GetWorkSheet("Reports")
' Read the evaluated result of a formula cell
Dim calculatedTotal As Decimal = sheet("E10").DecimalValue
Console.WriteLine($"Total: {calculatedTotal}")
' Read the formula string itself
Dim formula As String = sheet("E10").Formula
Console.WriteLine($"Formula: {formula}") ' e.g. "=SUM(E2:E9)"O suporte a fórmulas significa que importar arquivos Excel com cálculos complexos funciona sem recriar a lógica de negócios no código. A biblioteca avalia fórmulas automaticamente, retornando valores calculados enquanto preserva a string original da fórmula. Isto se mostra inestimável ao importar modelos financeiros ou templates de relatórios que contêm fórmulas aninhadas.
Compatibilidade multiplataforma garante comportamento consistente em Windows, Linux, macOS e ambientes de contêineres. Isso torna o IronXL bem adequado para implantações em nuvem e microserviços onde a instalação do Office não é viável. A documentação da .NET Foundation destaca como as aplicações modernas .NET se beneficiam da independência de plataforma.
A integração com o Entity Framework cria pipelines diretos de Excel para banco de dados. O padrão a seguir funciona limpo com declarações de nível superior do .NET 10:
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.");Imports IronXL
Dim workBook As WorkBook = WorkBook.Load("ProductData.xlsx")
Dim sheet As WorkSheet = workBook.DefaultWorkSheet
' Skip the header row, map remaining rows to entity objects
Dim products = sheet.Rows _
.Skip(1) _
.Select(Function(row) New Product With {
.Name = row.Columns(0).StringValue,
.Price = row.Columns(1).DecimalValue
}) _
.ToList()
Using context As New AppDbContext()
Await context.Products.AddRangeAsync(products)
Await context.SaveChangesAsync()
End Using
Console.WriteLine($"Imported {products.Count} products.")Esse padrão permite a migração direta de Excel para banco de dados com código mínimo, tornando-o bem adequado para processos ETL, migrações de dados únicas e trabalhos de importação agendados. Como a projeção LINQ é executada na memória antes do contexto ser salvo, você pode aplicar lógica de validação ou transformação na mesma etapa. Para criar novos arquivos do Excel a partir de dados C#, consulte o guia de criação de arquivos do Excel do IronXL .
IronXL lida com uma ampla gama de formatos de planilha sem bibliotecas adicionais ou instalação do Office. A tabela a seguir resume os formatos suportados e seus casos de uso:
| Formatar | Extensão | Notas |
|---|---|---|
| Planilha do Excel | .xlsx | Formataro padrão para Excel 2007 e posteriores |
| Pasta de Trabalho Excel Legado | .xls | Compatível com versões mais antigas do Excel |
| Valores Separados por Vírgula | .csv | Dados tabulares em texto simples, amplamente suportados |
| Valores Separados por Tabulação | .tsv | Adequado para dados com vírgulas embutidas |
| Pasta de Trabalho Binária do Excel | .xlsb | Formataro binário compacto para arquivos grandes |
Para exportar dados de volta para esses formatos, consulte o guia de exportação do IronXL para Excel .
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}");
}Imports IronXL
Dim workBook As WorkBook = WorkBook.Load("StyledReport.xlsx")
Dim sheet As WorkSheet = workBook.DefaultWorkSheet
For Each row In sheet.Rows
Dim firstCell = row.Columns(0)
' Skip rows where the first cell is bold (typically header or total rows)
If firstCell.Style.Font.Bold Then
Continue For
End If
Console.WriteLine($"Data row: {firstCell.StringValue}")
NextPara obter informações completas sobre formatação de células e intervalos, incluindo cadeias de formato de números e acesso à cor de fundo, consulte 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.
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:
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.
Curtis Chau é bacharel em Ciência da Computação (Universidade Carleton) e se especializa em desenvolvimento front-end, com experiência em Node.js, TypeScript, JavaScript e React. Apaixonado por criar interfaces de usuário intuitivas e esteticamente agradáveis, Curtis gosta de trabalhar com frameworks modernos e criar manuais bem estruturados e visualmente atraentes.
IronXL faz parte do IRON SUITE.
10 produtos de API .NET para seus documentos de escritório
A API do Excel que você precisa, sem as complicações do Office Interop.
