Ler e processar arquivos OpenDocument Spreadsheet (ODS) e Excel em C# é simples quando você usa a biblioteca correta. Com IronXL, você carrega qualquer arquivo XLS, XLSX, ODS ou CSV em um objeto WorkBook usando uma única chamada de método -- sem necessidade de instalação do Microsoft Excel, sem registro COM e sem dores de cabeça com Interop. Este guia o orienta em cada etapa: instalar o pacote, carregar arquivos, extrair valores de células tipadas, trabalhar com planilhas nomeadas, lidar com células mescladas e implantar em ambientes Linux ou containerizados.
Adicione o IronXL ao seu projeto através do Gerenciador de Pacotes NuGet. Abra o Console do Gerenciador de Pacotes no Visual Studio e execute:
IronXL é compatível com .NET 8, .NET 9, .NET 10, .NET Framework 4.6.2+ e .NET Standard 2.0, portanto, adequa-se a bases de código modernas e legadas. Após a instalação do pacote, adicione a diretiva using IronXL; no topo de qualquer arquivo que trabalhe com planilhas, e você estará pronto para carregar seu primeiro workbook.
Para Azure Functions, contêineres Docker ou APIs hospedadas em Linux, nenhuma configuração adicional de runtime é necessária. A biblioteca reúne internamente tudo o que precisa e não chama componentes de automação do Excel.
IronXL trata arquivos ODS, XLS, XLSX e CSV de forma idêntica através do método WorkBook.Load. Você passa um caminho absoluto ou relativo do arquivo, e a biblioteca detecta o formato a partir do cabeçalho do arquivo – não apenas a extensão. Isso significa que um arquivo renomeado de .ods para .xlsx ainda é lido corretamente.
using IronXL;
// Load an OpenDocument Spreadsheet (.ods) produced by LibreOffice Calc or OpenOffice
WorkBook workbook = WorkBook.Load("quarterly_report.ods");
// Access the first worksheet by index
WorkSheet sheet = workbook.WorkSheets[0];
// Read a cell value
string companyName = sheet["A1"].StringValue;
int recordCount = sheet["B1"].IntValue;
Console.WriteLine($"Company : {companyName}");
Console.WriteLine($"Records : {recordCount}");Imports IronXL
' Load an OpenDocument Spreadsheet (.ods) produced by LibreOffice Calc or OpenOffice
Dim workbook As WorkBook = WorkBook.Load("quarterly_report.ods")
' Access the first worksheet by index
Dim sheet As WorkSheet = workbook.WorkSheets(0)
' Read a cell value
Dim companyName As String = sheet("A1").StringValue
Dim recordCount As Integer = sheet("B1").IntValue
Console.WriteLine($"Company : {companyName}")
Console.WriteLine($"Records : {recordCount}")A mesma chamada funciona para arquivos XLSX e XLS – basta mudar o caminho. WorkBook.Load retorna o mesmo objeto fortemente tipado independentemente do formato de origem, então o restante do seu código permanece idêntico, seja o arquivo originário do Microsoft Excel, LibreOffice, ou qualquer outro aplicativo compatível com ODF.
Iterar sobre todas as linhas e células é a tarefa de processamento do Excel mais comum -- seja validando os dados de importação, transformando registros ou alimentando um pipeline de relatórios. IronXL expõe uma coleção Rows em cada WorkSheet:
using IronXL;
WorkBook workbook = WorkBook.Load("customers.xlsx");
WorkSheet worksheet = workbook.WorkSheets[0];
Console.WriteLine($"Total rows : {worksheet.RowCount}");
Console.WriteLine($"Total columns : {worksheet.ColumnCount}");
Console.WriteLine();
foreach (var row in worksheet.Rows)
{
foreach (var cell in row)
{
if (!cell.IsEmpty)
Console.Write($"{cell.StringValue,-20}");
}
Console.WriteLine();
}Imports IronXL
Dim workbook As WorkBook = WorkBook.Load("customers.xlsx")
Dim worksheet As WorkSheet = workbook.WorkSheets(0)
Console.WriteLine($"Total rows : {worksheet.RowCount}")
Console.WriteLine($"Total columns : {worksheet.ColumnCount}")
Console.WriteLine()
For Each row In worksheet.Rows
For Each cell In row
If Not cell.IsEmpty Then
Console.Write($"{cell.StringValue,-20}")
End If
Next
Console.WriteLine()
NextAs propriedades RowCount e ColumnCount retornam apenas o intervalo preenchido -- linhas e colunas finais vazias não são incluídas. Verificar cell.IsEmpty antes de ler previne processamento desnecessário em planilhas esparsas.
Para arquivos grandes, considere usar acesso baseado em intervalo (worksheet["A1:D500"]) em vez de iteração completa da planilha. Isso limita as células carregadas na memória e acelera o processamento quando você precisa apenas de um subconjunto dos dados.
Células em uma planilha do mundo real contêm strings, inteiros, decimais, booleanos e datas. IronXL expõe propriedades tipadas dedicadas para que você nunca tenha que fazer parsing de strings brutas manualmente:
using IronXL;
WorkBook workbook = WorkBook.Load("inventory.xlsx");
WorkSheet sheet = workbook.GetWorkSheet("Products");
// Typed accessors handle conversion automatically
string productName = sheet["A2"].StringValue;
int quantity = sheet["B2"].IntValue;
decimal unitPrice = sheet["C2"].DecimalValue;
bool inStock = sheet["D2"].BoolValue;
DateTime? lastAudit = sheet["E2"].DateTimeValue;
Console.WriteLine($"Product : {productName}");
Console.WriteLine($"Qty : {quantity}");
Console.WriteLine($"Price : {unitPrice:C}");
Console.WriteLine($"In Stock : {inStock}");
Console.WriteLine($"Audited : {lastAudit?.ToString("d") ?? "Never"}");Imports IronXL
Dim workbook As WorkBook = WorkBook.Load("inventory.xlsx")
Dim sheet As WorkSheet = workbook.GetWorkSheet("Products")
' Typed accessors handle conversion automatically
Dim productName As String = sheet("A2").StringValue
Dim quantity As Integer = sheet("B2").IntValue
Dim unitPrice As Decimal = sheet("C2").DecimalValue
Dim inStock As Boolean = sheet("D2").BoolValue
Dim lastAudit As DateTime? = sheet("E2").DateTimeValue
Console.WriteLine($"Product : {productName}")
Console.WriteLine($"Qty : {quantity}")
Console.WriteLine($"Price : {unitPrice:C}")
Console.WriteLine($"In Stock : {inStock}")
Console.WriteLine($"Audited : {If(lastAudit?.ToString("d"), "Never")}")Quando uma célula contém uma fórmula, o IronXL a avalia e retorna o resultado calculado pelas mesmas propriedades tipadas. Você não precisa chamar um método de avaliação separado. Para células que podem estar vazias ou conter um tipo incompatível, a biblioteca retorna o valor padrão para aquele tipo em vez de lançar uma exceção, o que simplifica a lógica de validação de entrada.
| Propriedade | Tipo .NET | Retorna Quando Vazio | Notas |
|---|---|---|---|
StringValue | string | String vazia | Sempre seguro; converte qualquer célula para texto |
IntValue | int | 0 | Trunca decimais |
DecimalValue | decimal | 0m | Preserva precisão para dados financeiros |
DoubleValue | double | 0.0 | Use para valores científicos ou estatísticos |
BoolValue | bool | false | Lê células Excel VERDADEIRO/FALSO |
DateTimeValue | DateTime? | null | Nullable -- verificar antes de usar |
Planilhas empresariais frequentemente contêm várias planilhas nomeadas -- uma por mês, uma por região, ou uma por linha de produto. IronXL oferece várias maneiras de acessá-las:
using IronXL;
WorkBook workbook = WorkBook.Load("annual_sales.xlsx");
// Option 1: access by name (throws if the sheet does not exist)
WorkSheet januarySheet = workbook.GetWorkSheet("January");
// Option 2: iterate all sheets in the workbook
foreach (WorkSheet ws in workbook.WorkSheets)
{
Console.WriteLine($"Sheet: {ws.Name} | Rows: {ws.RowCount}");
// Read the header row from each sheet
string header = ws["A1"].StringValue;
Console.WriteLine($" Header: {header}");
}
// Option 3: access by zero-based index
WorkSheet lastSheet = workbook.WorkSheets[workbook.WorkSheets.Count - 1];
Console.WriteLine($"Last sheet: {lastSheet.Name}");Imports IronXL
Dim workbook As WorkBook = WorkBook.Load("annual_sales.xlsx")
' Option 1: access by name (throws if the sheet does not exist)
Dim januarySheet As WorkSheet = workbook.GetWorkSheet("January")
' Option 2: iterate all sheets in the workbook
For Each ws As WorkSheet In workbook.WorkSheets
Console.WriteLine($"Sheet: {ws.Name} | Rows: {ws.RowCount}")
' Read the header row from each sheet
Dim header As String = ws("A1").StringValue
Console.WriteLine($" Header: {header}")
Next
' Option 3: access by zero-based index
Dim lastSheet As WorkSheet = workbook.WorkSheets(workbook.WorkSheets.Count - 1)
Console.WriteLine($"Last sheet: {lastSheet.Name}")Quando o nome da planilha é conhecido em tempo de design, GetWorkSheet é a opção mais clara. Para processamento dinâmico -- onde os nomes das planilhas vêm da entrada do usuário ou configuração -- iterar sobre a coleção WorkSheets previne suposições codificadas e lida com planilhas com números variáveis de folhas.
Relatórios e painéis frequentemente usam células mescladas para cabeçalhos, rótulos agrupados e linhas de resumo. IronXL lê o valor da célula no canto superior esquerdo de uma região mesclada, exatamente como o Excel exibe:
using IronXL;
WorkBook workbook = WorkBook.Load("report_with_merges.xlsx");
WorkSheet sheet = workbook.DefaultWorkSheet;
// The merged region A1:D1 stores its value in cell A1
string reportTitle = sheet["A1"].StringValue;
Console.WriteLine($"Report title : {reportTitle}");
// Read cell formatting metadata
var titleCell = sheet["A1"];
Console.WriteLine($"Bold : {titleCell.Style.Font.Bold}");
Console.WriteLine($"Font size : {titleCell.Style.Font.Height}");
// Scan an entire column for non-empty section headers
foreach (var cell in sheet["A1:A100"])
{
if (!cell.IsEmpty && cell.Style.Font.Bold)
Console.WriteLine($"Section header at {cell.AddressString}: {cell.StringValue}");
}Imports IronXL
Dim workbook As WorkBook = WorkBook.Load("report_with_merges.xlsx")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
' The merged region A1:D1 stores its value in cell A1
Dim reportTitle As String = sheet("A1").StringValue
Console.WriteLine($"Report title : {reportTitle}")
' Read cell formatting metadata
Dim titleCell = sheet("A1")
Console.WriteLine($"Bold : {titleCell.Style.Font.Bold}")
Console.WriteLine($"Font size : {titleCell.Style.Font.Height}")
' Scan an entire column for non-empty section headers
For Each cell In sheet("A1:A100")
If Not cell.IsEmpty AndAlso cell.Style.Font.Bold Then
Console.WriteLine($"Section header at {cell.AddressString}: {cell.StringValue}")
End If
NextA árvore de propriedades Style espelha a estrutura da especificação OOXML SpreadsheetML, então os nomes das propriedades parecerão familiares se você já trabalhou com o Open XML SDK. No entanto, IronXL envolve toda essa complexidade em uma API limpa que não requer nenhuma manipulação de XML da sua parte.
Arquivos CSV produzidos por exportações de banco de dados, sistemas CRM e aplicativos legados podem ser lidos através da mesma chamada WorkBook.Load. IronXL infere o delimitador a partir do conteúdo do arquivo:
using IronXL;
// Load a comma-separated values file -- same method, same API
WorkBook csvWorkbook = WorkBook.Load("export.csv");
WorkSheet csvSheet = csvWorkbook.DefaultWorkSheet;
Console.WriteLine($"CSV rows loaded: {csvSheet.RowCount}");
// Process rows exactly like any other worksheet
foreach (var row in csvSheet.Rows)
{
string id = row[0].StringValue;
string name = row[1].StringValue;
Console.WriteLine($"{id,-10} {name}");
}Imports IronXL
' Load a comma-separated values file -- same method, same API
Dim csvWorkbook As WorkBook = WorkBook.Load("export.csv")
Dim csvSheet As WorkSheet = csvWorkbook.DefaultWorkSheet
Console.WriteLine($"CSV rows loaded: {csvSheet.RowCount}")
' Process rows exactly like any other worksheet
For Each row In csvSheet.Rows
Dim id As String = row(0).StringValue
Dim name As String = row(1).StringValue
Console.WriteLine($"{id,-10} {name}")
NextApós o carregamento, você pode salvar os dados como XLSX usando csvWorkbook.SaveAs("output.xlsx"). Este é um padrão comum para pipelines de conversão CSV-para-Excel -- receber um arquivo CSV, enriquecê-lo com colunas calculadas ou formatação, e retornar um relatório XLSX formatado ao usuário.
Para arquivos separados por tabulação ou delimitadores personalizados, use WorkBook.LoadCSV("file.tsv", fileFormatar: ExcelFileFormatar.TSV) para especificar o formato explicitamente.
| Formatar | Extensão | Produzido Por | Notas |
|---|---|---|---|
| XLSX | .xlsx | Excel 2007+, LibreOffice | Formataro moderno padrão; baseado em XML |
| XLS | .xls | Excel 97--2003 | Formataro binário; suporte completo de leitura/escrita |
| ODS | .ods | LibreOffice, OpenOffice | Padrão de Planilha OpenDocument |
| CSV | .csv | Qualquer aplicativo | Delimitador auto-detectado; sem formatação |
| TSV | .tsv | Exportações de banco de dados | Separado por tabulação; especifique o formato explicitamente |
A alternativa mais comum ao IronXL para automação de Excel em .NET é Microsoft.Office.Interop.Excel. Compreender os trade-offs ajuda a escolher a ferramenta certa para seu projeto.
O Interop da Microsoft envolve o modelo de objeto COM do Excel. Isso significa que o Excel deve estar instalado em todas as máquinas que executam seu código -- incluindo servidores web, agentes de build e VMs em nuvem. O gerenciamento do ciclo de vida do objeto COM é manual: você deve liberar explicitamente todos os objetos Range, Worksheet e Workbook, senão processos Excel se acumulam em segundo plano e consomem memória até que o servidor seja reiniciado. O licenciamento também é uma preocupação: o EULA do Office proíbe automação do lado do servidor em muitos cenários.
IronXL evita todas essas limitações. É uma biblioteca totalmente gerida sem dependência de COM. O objeto WorkBook é uma classe padrão do .NET; o coletor de lixo lida com a limpeza. Você pode executar o mesmo código em um laptop de desenvolvedor, um Azure App Service, um contêiner Docker ou um Raspberry Pi rodando Linux.
O Open XML SDK da Microsoft é outra alternativa. Ele fornece acesso direto ao formato de arquivo OOXML sem exigir o Excel, mas opera em um nível muito baixo -- você manipula elementos XML diretamente. Ler o valor de uma única célula requer navegar por tabelas de strings compartilhadas, referências de células e índices de estilo. IronXL engloba tudo isso em uma chamada sheet["A1"].StringValue de linha única mostrada ao longo deste guia.
Implementações de servidor são onde a independência do IronXL em relação ao Excel se torna mais valiosa. O mesmo código que você escreve no Windows roda inalterado no Ubuntu, Alpine Linux ou macOS. Para implementações em contêiner, seu Dockerfile não requer configuração especial:
# Standard .NET runtime image -- no Office packages needed
FROM mcr.microsoft.com/dotnet/runtime:10.0
WORKDIR /app
COPY --from=build /app/publish .
ENTRYPOINT ["dotnet", "ExcelProcessor.dll"]Para Azure Functions e AWS Lambda, IronXL funciona dentro do runtime gerido sem qualquer configuração adicional. O overhead de inicialização a frio é mínimo porque não há etapa de inicialização do COM.
A segurança de thread está embutida: múltiplos threads podem abrir diferentes instâncias WorkBook simultaneamente sem coordenação. Se você precisar processar milhares de arquivos em paralelo -- por exemplo, em um trabalho em segundo plano que processa planilhas enviadas por usuários -- você pode usar Parallel.ForEach ou Task.WhenAll em um pool de instâncias WorkBook sem risco de corrupção.
O uso de memória permanece previsível porque o IronXL carrega apenas a planilha solicitada na memória, não todo o livro na inicialização. Para arquivos muito grandes, essa distinção é importante: um livro com dez folhas de 50MB não requer 500MB de RAM apenas para ler uma única folha. A documentação de desempenho do IronXL cobre estratégias adicionais para lidar com cenários de processamento de arquivos em grande volume.
A maneira mais rápida de validar o IronXL no seu projeto é instalar o pacote NuGet e executar os exemplos deste guia contra um arquivo real do seu ambiente. Uma licença de teste gratuita desbloqueia todos os recursos sem a necessidade de alteração no código quando você estiver pronto para a produção.
Explore capacidades relacionadas do IronXL que complementam a leitura de arquivos:
Para dúvidas sobre licenciamento, suporte multiplataforma ou requisitos de formato de arquivo específico, a equipe de suporte do IronXL está disponível via chat ao vivo e email.
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.
