Abrir e trabalhar com arquivos Excel em C# é algo que quase todo desenvolvedor .NET encontra cedo ou tarde. Seja você automatizando relatórios semanais, processando importações de dados ou criando ferramentas que geram planilhas rapidamente, a biblioteca que você escolher pode fazer uma diferença significativa em termos de velocidade, confiabilidade e flexibilidade de implantação.
Este tutorial explica como abrir arquivos Excel em C# usando o IronXL -- uma biblioteca leve de Excel que lê, edita e escreve cadernos de trabalho sem exigir a instalação do Microsoft Office. Você verá como é simples carregar dados, acessar planilhas e trabalhar com células programaticamente, tudo dentro do seu aplicativo C#.
Embora o Microsoft.Office.Interop.Excel tenha sido a abordagem tradicional para automação do Excel, ele apresenta limitações significativas que tornam o IronXL a melhor escolha para aplicações modernas. A própria Microsoft recomenda não usar o Office Interop em servidores, citando instabilidade, problemas de escalabilidade e cenários de implantação não suportados.
| Recurso | IronXL | Microsoft.Office.Interop.Excel |
|---|---|---|
| Instalação do Excel Necessária | Não | Sim |
| Suporte Multiplataforma | Windows, Linux, macOS | Somente para Windows |
| Implantação em Servidor | Totalmente suportado | Não recomendado pela Microsoft |
| Gerenciamento de Memória | Automático | Limpeza manual de COM necessária |
| Complexidade da API | Simples e intuitiva | Interfaces COM complexas |
| Suporte a Formato de Arquivo | XLS, XLSX, CSV, TSV, JSON | Limitado a formatos do Excel |
| Segurança de Threads | Apoiado | Apenas monothread |
IronXL elimina a dependência do Microsoft Excel, tornando-o ideal para ambientes de servidor, contêineres Docker e plataformas em nuvem como Azure. A biblioteca oferece uma API limpa e moderna que remove a necessidade de lidar com objetos COM ou gerenciamento manual de memória. Além de abrir arquivos, o IronXL lida com tudo, desde a avaliação de fórmulas até a geração de gráficos e a formatação de células .
Começar com o IronXL é simples -- ele pode ser adicionado ao seu projeto em minutos através do Gerenciador de Pacotes do NuGet. Abra o Console do Gerenciador de Pacotes no Visual Studio e execute:
Ambos os comandos instalam o mesmo pacote. Use o primeiro no Console do Gerenciador de Pacotes do Visual Studio, e o segundo com o CLI do .NET. Após a instalação, você pode verificar se a referência do pacote aparece em seu arquivo de projeto sob <PackageReference Include="IronXL.Excel" />.
IronXL é voltado para todo o espectro de versões modernas do .NET, incluindo .NET 10, .NET 8, .NET 6, .NET Framework 4.6.2 e superiores, e .NET Standard 2.0. Esta ampla gama de suporte significa que você pode usar IronXL em novos projetos direcionados ao .NET 10, bem como em aplicativos legados que rodam no tradicional .NET Framework.
A biblioteca está disponível como um único pacote NuGet que seleciona automaticamente o binário correto para o seu framework de destino. Sem dependências adicionais, sem instalações específicas de plataforma e sem necessidade de licença do Excel. Consulte o guia de compatibilidade do IronXL para obter uma lista completa dos ambientes de execução e plataformas suportados.
Abrir arquivos Excel existentes com o IronXL requer apenas algumas linhas de código. A biblioteca suporta leitura de arquivos XLS e XLSX, assim como os formatos CSV e TSV, através de uma API unificada. O exemplo a seguir demonstra o fluxo de trabalho essencial:
// Load an existing Excel file
WorkBook workbook = WorkBook.Load("sales-data.xlsx");
// Access the first worksheet by index
WorkSheet sheet = workbook.WorkSheets[0];
// Or access a worksheet by name
WorkSheet namedSheet = workbook.GetWorkSheet("January Sales");
// Read a specific cell value
string cellValue = sheet["A1"].StringValue;
Console.WriteLine($"Cell A1 contains: {cellValue}");
// Read a numeric value
decimal revenue = sheet["B2"].DecimalValue;
Console.WriteLine($"Revenue: {revenue:C}");
// Check cell data type before reading
var cell = sheet["C3"];
Console.WriteLine($"Type: {cell.Type}, Value: {cell.Value}");' Load an existing Excel file
Dim workbook As WorkBook = WorkBook.Load("sales-data.xlsx")
' Access the first worksheet by index
Dim sheet As WorkSheet = workbook.WorkSheets(0)
' Or access a worksheet by name
Dim namedSheet As WorkSheet = workbook.GetWorkSheet("January Sales")
' Read a specific cell value
Dim cellValue As String = sheet("A1").StringValue
Console.WriteLine($"Cell A1 contains: {cellValue}")
' Read a numeric value
Dim revenue As Decimal = sheet("B2").DecimalValue
Console.WriteLine($"Revenue: {revenue:C}")
' Check cell data type before reading
Dim cell = sheet("C3")
Console.WriteLine($"Type: {cell.Type}, Value: {cell.Value}")O método WorkBook.Load() detecta automaticamente o formato do arquivo -- XLS, XLSX, CSV ou TSV -- e lida com o parsing sem qualquer configuração adicional. Você acessa planilhas individualmente por índice usando workbook.WorkSheets[0] ou por nome usando GetWorkSheet(). Valores de células individuais são lidos por meio da notação de colchetes (sheet["A1"]), tornando o código conciso e expressivo. Para a lista completa de tipos de arquivos suportados, consulte a documentação do Open XML SDK sobre SpreadsheetML e a página do pacote IronXL no NuGet.
Para acesso tipado, IronXL expõe propriedades como .StringValue, .DecimalValue, .IntValue, .BoolValue, e .DateTimeValue diretamente nas células. Isso elimina a adivinhação de tipo comum com APIs baseadas em objetos genéricos. Para cenários mais complexos, visite o guia de trabalho com intervalos do Excel e a documentação de formatos de dados de células.
Em aplicações web e funções em nuvem, você frequentemente recebe dados de arquivo como um stream ou byte array, em vez de um caminho de arquivo. IronXL lida com ambos os casos:
// Load from a byte array (e.g., from a database or HTTP response)
byte[] fileBytes = File.ReadAllBytes("sales-data.xlsx");
WorkBook workbookFromBytes = WorkBook.Load(fileBytes);
// Load from a MemoryStream
using var memStream = new MemoryStream(fileBytes);
WorkBook workbookFromStream = WorkBook.Load(memStream);
// Access data the same way regardless of source
WorkSheet sheet = workbookFromStream.DefaultWorkSheet;
Console.WriteLine(sheet["A1"].StringValue);Imports System
Imports System.IO
' Load from a byte array (e.g., from a database or HTTP response)
Dim fileBytes As Byte() = File.ReadAllBytes("sales-data.xlsx")
Dim workbookFromBytes As WorkBook = WorkBook.Load(fileBytes)
' Load from a MemoryStream
Using memStream As New MemoryStream(fileBytes)
Dim workbookFromStream As WorkBook = WorkBook.Load(memStream)
' Access data the same way regardless of source
Dim sheet As WorkSheet = workbookFromStream.DefaultWorkSheet
Console.WriteLine(sheet("A1").StringValue)
End UsingO carregamento baseado em fluxo é particularmente útil em controladores ASP.NET Core onde você recebe um upload IFormFile. Basta chamar formFile.OpenReadStream() e passar o resultado para WorkBook.Load(). Para padrões de integração completos do ASP.NET Core, consulte o tutorial de Excel no ASP.NET Core.
Criar novos arquivos do Excel é igualmente simples com as capacidades de criação de planilhas do IronXL. O exemplo a seguir constrói um relatório trimestral formatado:
// Create a new workbook in XLSX format
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
// Add metadata
workbook.Metadata.Author = "Sales Department";
workbook.Metadata.Title = "Q1 Revenue Report";
// Create a named worksheet
WorkSheet sheet = workbook.CreateWorkSheet("Q1 Report");
// Add header row
sheet["A1"].Value = "Product";
sheet["B1"].Value = "Units Sold";
sheet["C1"].Value = "Revenue";
// Add data rows
sheet["A2"].Value = "Software Licenses";
sheet["B2"].Value = 120;
sheet["C2"].Value = 45000;
sheet["A3"].Value = "Support Contracts";
sheet["B3"].Value = 55;
sheet["C3"].Value = 27500;
// Add a SUM formula
sheet["C4"].Formula = "=SUM(C2:C3)";
// Apply number formatting
sheet["C2:C4"].FormatString = "$#,##0.00";
// Save the workbook to disk
workbook.SaveAs("quarterly-report.xlsx");
Console.WriteLine("Workbook saved successfully.");' Create a new workbook in XLSX format
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
' Add metadata
workbook.Metadata.Author = "Sales Department"
workbook.Metadata.Title = "Q1 Revenue Report"
' Create a named worksheet
Dim sheet As WorkSheet = workbook.CreateWorkSheet("Q1 Report")
' Add header row
sheet("A1").Value = "Product"
sheet("B1").Value = "Units Sold"
sheet("C1").Value = "Revenue"
' Add data rows
sheet("A2").Value = "Software Licenses"
sheet("B2").Value = 120
sheet("C2").Value = 45000
sheet("A3").Value = "Support Contracts"
sheet("B3").Value = 55
sheet("C3").Value = 27500
' Add a SUM formula
sheet("C4").Formula = "=SUM(C2:C3)"
' Apply number formatting
sheet("C2:C4").FormatString = "$#,##0.00"
' Save the workbook to disk
workbook.SaveAs("quarterly-report.xlsx")
Console.WriteLine("Workbook saved successfully.")O método WorkBook.Create() inicializa um novo livro no formato especificado. Você pode adicionar várias planilhas usando CreateWorkSheet(), preencher células com vários tipos de dados, incluindo strings, números, booleanos e datas, e aplicar fórmulas do Excel diretamente através da propriedade Formula. A biblioteca lida automaticamente com a conversão de tipos de dados e requisitos de formatação específicos do Excel.
Para estilizar cabeçalhos e adicionar bordas, use a API de estilização de células. Para geração de relatórios baseada em modelos, consulte o guia de exportação de modelos de Excel existentes.
IronXL lida com extração de dados e processamento em massa eficientemente através de operações baseadas em intervalo e conversão para DataTable:
// Load a workbook and select the default sheet
WorkBook workbook = WorkBook.Load("inventory.xlsx");
WorkSheet sheet = workbook.DefaultWorkSheet;
// Read a rectangular range of cells
var range = sheet["A1:D10"];
foreach (var cell in range)
{
Console.WriteLine($"{cell.AddressString}: {cell.Text}");
}
// Convert the worksheet to a DataTable for database integration
System.Data.DataTable dataTable = sheet.ToDataTable(useFirstRowAsColumnHeaders: true);
Console.WriteLine($"Rows: {dataTable.Rows.Count}, Columns: {dataTable.Columns.Count}");
// Use aggregate functions directly on a range
decimal total = sheet["C2:C10"].Sum();
decimal average = sheet["C2:C10"].Avg();
decimal maxValue = sheet["C2:C10"].Max();
Console.WriteLine($"Total: {total:C}");
Console.WriteLine($"Average: {average:C}");
Console.WriteLine($"Max: {maxValue:C}");
// Filter and find rows using LINQ on the DataTable
var highValue = dataTable.AsEnumerable()
.Where(row => row.Field<decimal>("Revenue") > 10000)
.ToList();
Console.WriteLine($"High-value rows: {highValue.Count}");Imports System
Imports System.Data
Imports System.Linq
' Load a workbook and select the default sheet
Dim workbook As WorkBook = WorkBook.Load("inventory.xlsx")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
' Read a rectangular range of cells
Dim range = sheet("A1:D10")
For Each cell In range
Console.WriteLine($"{cell.AddressString}: {cell.Text}")
Next
' Convert the worksheet to a DataTable for database integration
Dim dataTable As DataTable = sheet.ToDataTable(useFirstRowAsColumnHeaders:=True)
Console.WriteLine($"Rows: {dataTable.Rows.Count}, Columns: {dataTable.Columns.Count}")
' Use aggregate functions directly on a range
Dim total As Decimal = sheet("C2:C10").Sum()
Dim average As Decimal = sheet("C2:C10").Avg()
Dim maxValue As Decimal = sheet("C2:C10").Max()
Console.WriteLine($"Total: {total:C}")
Console.WriteLine($"Average: {average:C}")
Console.WriteLine($"Max: {maxValue:C}")
' Filter and find rows using LINQ on the DataTable
Dim highValue = dataTable.AsEnumerable() _
.Where(Function(row) row.Field(Of Decimal)("Revenue") > 10000) _
.ToList()
Console.WriteLine($"High-value rows: {highValue.Count}")A sintaxe de seleção de intervalo (sheet["A1:D10"]) fornece uma maneira elegante de trabalhar com múltiplas células de uma só vez. O método ToDataTable() converte dados de planilhas em um System.Data.DataTable, que se integra diretamente com Entity Framework, controles de vinculação de dados e operações de cópia em massa do SQL. IronXL também suporta funções agregadas -- Sum(), Avg(), Max(), e Min() -- diretamente em intervalos, eliminando a necessidade de escrever código de iteração manual.
Para lidar eficientemente com conjuntos de dados muito grandes, consulte a referência completa da API do IronXL para padrões de processamento por streaming e fragmentados.
Além do acesso baseado em intervalos, o IronXL permite que você procure células por valor, aplique lógica condicional e itere linhas e colunas programaticamente:
WorkBook workbook = WorkBook.Load("products.xlsx");
WorkSheet sheet = workbook.DefaultWorkSheet;
// Get total row and column counts
int rowCount = sheet.RowCount;
int colCount = sheet.ColumnCount;
Console.WriteLine($"Sheet dimensions: {rowCount} rows x {colCount} columns");
// Iterate over all rows and columns
for (int row = 1; row <= rowCount; row++)
{
for (int col = 1; col <= colCount; col++)
{
var cell = sheet.GetCellAt(row, col);
if (cell != null && !string.IsNullOrEmpty(cell.Text))
{
Console.WriteLine($"[{row},{col}] = {cell.Text}");
}
}
}
// Find the first cell containing specific text
var searchResult = sheet["A1:Z100"]
.FirstOrDefault(c => c.StringValue.Contains("discontinued", StringComparison.OrdinalIgnoreCase));
if (searchResult != null)
{
Console.WriteLine($"Found 'discontinued' at: {searchResult.AddressString}");
}Imports System
Imports System.Linq
Dim workbook As WorkBook = WorkBook.Load("products.xlsx")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
' Get total row and column counts
Dim rowCount As Integer = sheet.RowCount
Dim colCount As Integer = sheet.ColumnCount
Console.WriteLine($"Sheet dimensions: {rowCount} rows x {colCount} columns")
' Iterate over all rows and columns
For row As Integer = 1 To rowCount
For col As Integer = 1 To colCount
Dim cell = sheet.GetCellAt(row, col)
If cell IsNot Nothing AndAlso Not String.IsNullOrEmpty(cell.Text) Then
Console.WriteLine($"[{row},{col}] = {cell.Text}")
End If
Next
Next
' Find the first cell containing specific text
Dim searchResult = sheet("A1:Z100") _
.FirstOrDefault(Function(c) c.StringValue.Contains("discontinued", StringComparison.OrdinalIgnoreCase))
If searchResult IsNot Nothing Then
Console.WriteLine($"Found 'discontinued' at: {searchResult.AddressString}")
End IfEsse padrão é comum em fluxos de trabalho de validação de dados onde você precisa escanear um arquivo carregado buscando valores específicos antes de processá-lo mais adiante. Para casos de uso de filtragem avançada, revise a documentação de seleção de intervalo do Excel.
Uma das vantagens mais práticas de usar o IronXL é sua capacidade de operar sem o Microsoft Office instalado em qualquer lugar do sistema. Isso cria uma flexibilidade de implantação que as soluções baseadas em Interop simplesmente não conseguem igualar:
IronXL roda no Azure App Service, AWS Lambda e Google Cloud Run sem nenhuma configuração especial. Como não possui dependência do Office, você evita tanto o custo de licenciamento quanto a complexidade de incluir o Office em uma imagem de container. Um Dockerfile mínimo para um aplicativo .NET 10 usando IronXL precisa apenas da imagem de execução padrão do .NET.
A implantação baseada em Docker é igualmente direta. O guia Docker do IronXL cobre configurações de containers Debian, Alpine e Windows. Em todos os casos, você instala o IronXL via NuGet e ele roda sem pacotes adicionais do sistema.
Ambientes de servidor geralmente não têm uma GUI e não podem rodar aplicações que dependem de uma sessão de desktop do Windows. IronXL roda inteiramente em modo sem cabeça, tornando-o adequado para:
Para o ASP.NET Core especificamente, veja o tutorial de exportação de Excel no ASP.NET Core, que cobre streaming de arquivos, cabeçalhos de resposta e padrões adequados de descarte.
IronXL direciona o .NET Standard 2.0 e roda nativamente no Linux e macOS, permitindo fluxos de trabalho de desenvolvimento multi-plataforma. Desenvolvedores no macOS podem escrever e testar código de geração de Excel localmente com total confiança de que o mesmo binário funcionará de forma idêntica em um servidor de produção Linux. Não há APIs específicas da plataforma ou blocos de compilação condicional necessários.
Para obter mais detalhes sobre os ambientes suportados, visite a visão geral de introdução ao IronXL .
Ler e escrever células é apenas a base. A automação do Excel no mundo real normalmente envolve formatação, fórmulas, gestão de planilhas e conversão de formatos.
IronXL expõe uma API completa de estilo cobrindo fontes, cores, bordas, alinhamento e formatos numéricos:
WorkBook workbook = WorkBook.Load("report.xlsx");
WorkSheet sheet = workbook.DefaultWorkSheet;
// Apply bold, font size, and background color to header row
var headerRange = sheet["A1:F1"];
headerRange.Style.Font.Bold = true;
headerRange.Style.Font.Height = 12;
headerRange.Style.SetBackgroundColor("#4472C4");
headerRange.Style.Font.Color = "#FFFFFF";
headerRange.Style.HorizontalAlignment = IronXL.Styles.HorizontalAlignment.Center;
// Format a currency column
sheet["D2:D100"].FormatString = "$#,##0.00";
// Apply a date format
sheet["E2:E100"].FormatString = "yyyy-MM-dd";
// Add borders to a data range
var dataRange = sheet["A1:F20"];
dataRange.Style.Border.Bottom.Type = IronXL.Styles.BorderType.Thin;
dataRange.Style.Border.Right.Type = IronXL.Styles.BorderType.Thin;
workbook.SaveAs("formatted-report.xlsx");Imports IronXL
Dim workbook As WorkBook = WorkBook.Load("report.xlsx")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
' Apply bold, font size, and background color to header row
Dim headerRange = sheet("A1:F1")
headerRange.Style.Font.Bold = True
headerRange.Style.Font.Height = 12
headerRange.Style.SetBackgroundColor("#4472C4")
headerRange.Style.Font.Color = "#FFFFFF"
headerRange.Style.HorizontalAlignment = IronXL.Styles.HorizontalAlignment.Center
' Format a currency column
sheet("D2:D100").FormatString = "$#,##0.00"
' Apply a date format
sheet("E2:E100").FormatString = "yyyy-MM-dd"
' Add borders to a data range
Dim dataRange = sheet("A1:F20")
dataRange.Style.Border.Bottom.Type = IronXL.Styles.BorderType.Thin
dataRange.Style.Border.Right.Type = IronXL.Styles.BorderType.Thin
workbook.SaveAs("formatted-report.xlsx")Para um passo a passo completo das opções de estilo, veja como estilizar células, bordas e fontes.
IronXL lida diretamente com a conversão de formatos, permitindo carregar um CSV e salvá-lo como XLSX, ou exportar um arquivo XLSX para CSV para processamento posterior:
// Load a CSV file and save as XLSX
WorkBook csvBook = WorkBook.Load("data-import.csv");
csvBook.SaveAs("data-import.xlsx");
// Load an XLSX file and export as CSV
WorkBook xlsxBook = WorkBook.Load("report.xlsx");
xlsxBook.DefaultWorkSheet.SaveAsCsv("report.csv");' Load a CSV file and save as XLSX
Dim csvBook As WorkBook = WorkBook.Load("data-import.csv")
csvBook.SaveAs("data-import.xlsx")
' Load an XLSX file and export as CSV
Dim xlsxBook As WorkBook = WorkBook.Load("report.xlsx")
xlsxBook.DefaultWorkSheet.SaveAsCsv("report.csv")Para mais detalhes sobre o manuseio de CSV, incluindo configuração de delimitadores e opções de codificação, veja o tutorial de leitura CSV em C# e o guia de conversão de CSV para XLSX.
IronXL está disponível para download com uma licença de desenvolvimento gratuita que permite testar o conjunto completo de recursos antes de efetuar uma compra. Não há restrições de recursos durante o teste - a mesma biblioteca que é executada em produção é aquela que você avalia.
Para começar:
Instale o pacote via NuGet:
Visite a página de licenciamento do IronXL para obter uma chave de teste gratuita.
Aplique a chave no código antes de qualquer chamada ao IronXL:
IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";Imports IronXL
IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"Licenças estão disponíveis para desenvolvedores individuais, equipes e organizações. A página do produto IronXL fornece detalhes completos de preços e opções de implantação, incluindo direitos de distribuição sem royalties. Para uma visão mais abrangente de todos os produtos da Iron Software e como eles se integram, veja a suíte de produtos Iron Software.
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.
