IronXL permite que você abra e leia arquivos Excel em C# sem o Microsoft Office instalado -- basta instalar o pacote NuGet, carregar uma planilha com WorkBook.Load("file.xlsx") e acessar qualquer planilha, célula ou intervalo com valores tipados e detecção automática de formato.

Se você já tentou abrir arquivos Excel programaticamente sem o Microsoft Office, sabe o quão complicado pode ser a abordagem tradicional do Interop. Interop depende do próprio Excel estar instalado, requer referências COM complexas e muitas vezes causa conflitos de versão -- especialmente em servidores ou ambientes de nuvem onde o Office não está disponível.

IronXL é uma biblioteca moderna .NET que permite ler arquivos XLSX, XLS, CSV e TSV diretamente, sem necessidade de dependência do Office. Você pode escrever código C# limpo e confiável, processar arquivos Excel no Windows, Linux, ou na nuvem, e evitar todo o atrito da automação COM. Este guia aborda tudo, desde a instalação até padrões prontos para produção para abrir e ler workbooks do Excel.

Como instalar o IronXL em um projeto .NET?

Começar leva apenas alguns segundos. Abra seu projeto e use um dos seguintes gerenciadores de pacotes:

Install-Package IronXL.Excel

Alternativamente, abra o Visual Studio, clique com o botão direito no seu projeto, selecione "Gerenciar Pacotes NuGet", procure por "IronXL" e clique em Instalar. O guia de instalação abrange todos os ambientes suportados, incluindo Docker e Azure.

Uma vez instalado, adicione o namespace no topo do seu arquivo:

using IronXL;

using IronXL;

Imports IronXL

Imports IronXL

Essa única linha é tudo o que você precisa. Não há referências COM complexas, sem dependências do Office, e sem conjuntos de versões específicas. Para uma chave de avaliação gratuita, visite a página de licença de avaliação do IronXL.

Por que o IronXL é Mais Fácil que o Interop Tradicional?

O Interop tradicional do Excel requer o Microsoft Office em cada máquina que executa seu código. Isso é impraticável para implantações em servidor, funções do AWS Lambda e aplicações conteinerizadas. IronXL lida com toda a análise de arquivo Excel internamente, oferecendo uma API limpa que funciona sem quaisquer dependências externas.

Com Interop, você também precisa gerenciar cuidadosamente os tempos de vida dos objetos COM para evitar vazamentos de memória -- cada objeto Application, Workbook, e Worksheet deve ser liberado explicitamente, caso contrário, processos do Excel se acumulam em segundo plano. IronXL usa coleta de lixo padrão do .NET, então você nunca precisa pensar na limpeza de COM.

A biblioteca suporta o .NET Framework 4.6.2 e superior, bem como .NET 5, 6, 7, 8 e 10. Ela funciona em Windows, macOS e Linux sem modificações. Se você está buscando cenários multiplataforma, isso sozinho faz do IronXL uma opção substancialmente melhor do que o Office Interop, que é exclusivo para Windows.

Como Verificar se a Instalação Funcionou?

Após a instalação, crie um teste simples carregando qualquer arquivo do Excel e imprimindo o valor de uma célula. Se o projeto compilar sem erros e a saída corresponder aos dados esperados, a configuração está completa. A documentação do IronXL inclui uma seção de início rápido que detalha essa etapa de verificação.

Um erro comum durante a configuração é esquecer de aplicar uma chave de licença antes de carregar uma planilha em produção. No modo de avaliação, a biblioteca adiciona uma pequena marca d'água a quaisquer arquivos gerados. Defina IronXL.License.LicenseKey na inicialização do aplicativo para que todas as operações ocorram sob a licença correta desde o início.

Como Abrir uma Planilha do Excel e Ler Valores de Células?

A API principal é simples. Carregue uma planilha, selecione uma planilha e acesse as células por endereço ou por iteração.

using IronXL;

// Load any Excel file -- XLSX, XLS, CSV, or TSV
WorkBook workbook = WorkBook.Load("example.xlsx");

// Access the second worksheet (zero-indexed)
WorkSheet worksheet = workbook.WorkSheets[1];

// Read a specific cell value
decimal revenue = worksheet["E2"].DecimalValue;
Console.WriteLine($"Order Total: {revenue}");

// Iterate over a range of cells
foreach (var cell in worksheet["C2:C6"])
{
    Console.WriteLine($"Product: {cell.Text}");
}

using IronXL;

// Load any Excel file -- XLSX, XLS, CSV, or TSV
WorkBook workbook = WorkBook.Load("example.xlsx");

// Access the second worksheet (zero-indexed)
WorkSheet worksheet = workbook.WorkSheets[1];

// Read a specific cell value
decimal revenue = worksheet["E2"].DecimalValue;
Console.WriteLine($"Order Total: {revenue}");

// Iterate over a range of cells
foreach (var cell in worksheet["C2:C6"])
{
    Console.WriteLine($"Product: {cell.Text}");
}

Imports IronXL

' Load any Excel file -- XLSX, XLS, CSV, or TSV
Dim workbook As WorkBook = WorkBook.Load("example.xlsx")

' Access the second worksheet (zero-indexed)
Dim worksheet As WorkSheet = workbook.WorkSheets(1)

' Read a specific cell value
Dim revenue As Decimal = worksheet("E2").DecimalValue
Console.WriteLine($"Order Total: {revenue}")

' Iterate over a range of cells
For Each cell In worksheet("C2:C6")
    Console.WriteLine($"Product: {cell.Text}")
Next

Imports IronXL

' Load any Excel file -- XLSX, XLS, CSV, or TSV
Dim workbook As WorkBook = WorkBook.Load("example.xlsx")

' Access the second worksheet (zero-indexed)
Dim worksheet As WorkSheet = workbook.WorkSheets(1)

' Read a specific cell value
Dim revenue As Decimal = worksheet("E2").DecimalValue
Console.WriteLine($"Order Total: {revenue}")

' Iterate over a range of cells
For Each cell In worksheet("C2:C6")
    Console.WriteLine($"Product: {cell.Text}")
Next

WorkBook.Load() detecta automaticamente o formato do arquivo -- não há necessidade de especificar se o arquivo é XLS ou XLSX. Acesse planilhas por índice ou por nome usando workbook.GetWorkSheet("Sheet1"). Cada célula expõe propriedades tipadas como IntValue, DecimalValue, Data e horaValue, e Text.

Para obter mais opções sobre como abrir arquivos, consulte o guia de instruções para abrir uma pasta de trabalho .

Como Acessar Planilhas por Nome?

Usar nomes de planilhas é mais sustentável do que índices numéricos, especialmente quando planilhas são editadas por outras pessoas. O exemplo a seguir mostra como procurar uma planilha por nome e iterar por todas as planilhas:

using IronXL;

WorkBook workbook = WorkBook.Load("inventory.xlsx");

// Access worksheet by exact name
WorkSheet salesSheet = workbook.GetWorkSheet("Sales Data");
Console.WriteLine($"Sales sheet rows: {salesSheet.RowCount}");

// Iterate all worksheets in the workbook
foreach (WorkSheet sheet in workbook.WorkSheets)
{
    if (sheet.Name.Contains("Inventory"))
    {
        Console.WriteLine($"Found inventory sheet: {sheet.Name}");
    }
}

using IronXL;

WorkBook workbook = WorkBook.Load("inventory.xlsx");

// Access worksheet by exact name
WorkSheet salesSheet = workbook.GetWorkSheet("Sales Data");
Console.WriteLine($"Sales sheet rows: {salesSheet.RowCount}");

// Iterate all worksheets in the workbook
foreach (WorkSheet sheet in workbook.WorkSheets)
{
    if (sheet.Name.Contains("Inventory"))
    {
        Console.WriteLine($"Found inventory sheet: {sheet.Name}");
    }
}

Imports IronXL

Dim workbook As WorkBook = WorkBook.Load("inventory.xlsx")

' Access worksheet by exact name
Dim salesSheet As WorkSheet = workbook.GetWorkSheet("Sales Data")
Console.WriteLine($"Sales sheet rows: {salesSheet.RowCount}")

' Iterate all worksheets in the workbook
For Each sheet As WorkSheet In workbook.WorkSheets
    If sheet.Name.Contains("Inventory") Then
        Console.WriteLine($"Found inventory sheet: {sheet.Name}")
    End If
Next

Imports IronXL

Dim workbook As WorkBook = WorkBook.Load("inventory.xlsx")

' Access worksheet by exact name
Dim salesSheet As WorkSheet = workbook.GetWorkSheet("Sales Data")
Console.WriteLine($"Sales sheet rows: {salesSheet.RowCount}")

' Iterate all worksheets in the workbook
For Each sheet As WorkSheet In workbook.WorkSheets
    If sheet.Name.Contains("Inventory") Then
        Console.WriteLine($"Found inventory sheet: {sheet.Name}")
    End If
Next

O guia de leitura de arquivos do Excel explica padrões adicionais de acesso a planilhas, incluindo como trabalhar com pastas de trabalho que possuem nomes de planilhas gerados dinamicamente.

Como Ler Diferentes Tipos de Dados das Células do Excel?

IronXL expõe accessores tipados para cada tipo comum de dados do Excel. Você pode ler strings, inteiros, decimais, datas, booleanos e resultados de fórmulas sem qualquer análise manual.

using IronXL;

WorkBook wb = WorkBook.Load(@"C:\Data\Inventory.xlsx");
WorkSheet ws = wb.GetWorkSheet("Products");

// Read different data types directly
string productName = ws["A2"].StringValue;
int quantity       = ws["B2"].IntValue;
decimal price      = ws["C2"].DecimalValue;
Data e hora updated   = ws["D2"].Data e horaValue;

// Use aggregate functions on ranges for performance
decimal totalStock = ws["B2:B100"].Sum();
decimal maxPrice   = ws["C2:C100"].Max();

Console.WriteLine($"Product: {productName}, Qty: {quantity}, Price: {price:C}");
Console.WriteLine($"Total stock units: {totalStock}, Highest price: {maxPrice:C}");

using IronXL;

WorkBook wb = WorkBook.Load(@"C:\Data\Inventory.xlsx");
WorkSheet ws = wb.GetWorkSheet("Products");

// Read different data types directly
string productName = ws["A2"].StringValue;
int quantity       = ws["B2"].IntValue;
decimal price      = ws["C2"].DecimalValue;
Data e hora updated   = ws["D2"].Data e horaValue;

// Use aggregate functions on ranges for performance
decimal totalStock = ws["B2:B100"].Sum();
decimal maxPrice   = ws["C2:C100"].Max();

Console.WriteLine($"Product: {productName}, Qty: {quantity}, Price: {price:C}");
Console.WriteLine($"Total stock units: {totalStock}, Highest price: {maxPrice:C}");

A tabela abaixo resume os accessores tipados disponíveis:

Para obter detalhes completos sobre como ler e gravar dados de células, consulte o guia de formatação de células e o guia de instruções para importação de dados.

Como Lidar com Células Vazias ou Nulas de Forma Segura?

Células vazias são comuns em arquivos Excel do mundo real. Use a propriedade IsEmpty ou verifique Value para null antes de ler acessadores tipados:

using IronXL;

WorkBook workbook = WorkBook.Load("data.xlsx");
WorkSheet ws = workbook.DefaultWorkSheet;

// Check if a cell is empty before reading
if (!ws["A1"].IsEmpty)
{
    Console.WriteLine(ws["A1"].StringValue);
}

// Provide a fallback value using a null-coalescing pattern
string cellText = ws["A1"].StringValue ?? "Default Value";

// Iterate a range and skip empty cells
foreach (var cell in ws["A1:A20"])
{
    if (!cell.IsEmpty)
    {
        Console.WriteLine(cell.Text);
    }
}

using IronXL;

WorkBook workbook = WorkBook.Load("data.xlsx");
WorkSheet ws = workbook.DefaultWorkSheet;

// Check if a cell is empty before reading
if (!ws["A1"].IsEmpty)
{
    Console.WriteLine(ws["A1"].StringValue);
}

// Provide a fallback value using a null-coalescing pattern
string cellText = ws["A1"].StringValue ?? "Default Value";

// Iterate a range and skip empty cells
foreach (var cell in ws["A1:A20"])
{
    if (!cell.IsEmpty)
    {
        Console.WriteLine(cell.Text);
    }
}

Imports IronXL

Dim workbook As WorkBook = WorkBook.Load("data.xlsx")
Dim ws As WorkSheet = workbook.DefaultWorkSheet

' Check if a cell is empty before reading
If Not ws("A1").IsEmpty Then
    Console.WriteLine(ws("A1").StringValue)
End If

' Provide a fallback value using a null-coalescing pattern
Dim cellText As String = If(ws("A1").StringValue, "Default Value")

' Iterate a range and skip empty cells
For Each cell In ws("A1:A20")
    If Not cell.IsEmpty Then
        Console.WriteLine(cell.Text)
    End If
Next

Imports IronXL

Dim workbook As WorkBook = WorkBook.Load("data.xlsx")
Dim ws As WorkSheet = workbook.DefaultWorkSheet

' Check if a cell is empty before reading
If Not ws("A1").IsEmpty Then
    Console.WriteLine(ws("A1").StringValue)
End If

' Provide a fallback value using a null-coalescing pattern
Dim cellText As String = If(ws("A1").StringValue, "Default Value")

' Iterate a range and skip empty cells
For Each cell In ws("A1:A20")
    If Not cell.IsEmpty Then
        Console.WriteLine(cell.Text)
    End If
Next

A documentação sobre leitura de arquivos Excel aborda padrões adicionais para lidar com dados esparsos, incluindo como detectar a última linha e coluna utilizadas em uma planilha.

Outra consideração ao lidar com células vazias é a diferença entre uma célula realmente em branco e uma célula que contém uma string vazia. IsEmpty retorna verdadeiro somente quando a célula não contém valor algum, enquanto StringValue retorna uma string vazia para ambas as células em branco e células explicitamente definidas para "". Se seus dados contiverem células formatadas como texto que parecem vazias, verifique tanto IsEmpty quanto string.IsNullOrWhiteSpace(cell.StringValue) para o resultado mais preciso.

Como Construir um Leitor de Excel Pronto para Produção?

Um leitor de Excel do mundo real precisa de validação de arquivo, tratamento de erros, suporte a múltiplas planilhas e geração de saída opcional. O exemplo a seguir demonstra todos esses padrões em uma única classe:

using IronXL;
using System.IO;

// Validate and load the file
static List<string> CheckLowStock(string filePath)
{
    var lowStockItems = new List<string>();

    if (!File.Exists(filePath))
    {
        Console.WriteLine($"File not found: {filePath}");
        return lowStockItems;
    }

    string ext = Path.GetExtension(filePath).ToLower();
    if (ext is not (".xlsx" or ".xls" or ".csv"))
    {
        Console.WriteLine($"Unsupported file type: {ext}");
        return lowStockItems;
    }

    try
    {
        WorkBook workbook = WorkBook.Load(filePath);

        foreach (WorkSheet sheet in workbook.WorkSheets)
        {
            Console.WriteLine($"Checking sheet: {sheet.Name}");

            for (int row = 2; row <= sheet.RowCount; row++)
            {
                string itemName  = sheet[$"A{row}"].StringValue;
                int stockLevel   = sheet[$"B{row}"].IntValue;

                if (stockLevel < 10 && !string.IsNullOrEmpty(itemName))
                {
                    lowStockItems.Add($"{itemName} -- {stockLevel} units ({sheet.Name})");
                }
            }
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Error reading Excel file: {ex.Message}");
    }

    return lowStockItems;
}

// Export results to a new workbook
static void ExportReport(List<string> items, string outputPath)
{
    WorkBook report     = WorkBook.Create();
    WorkSheet sheet     = report.CreateWorkSheet("Low Stock Report");

    sheet["A1"].Value   = "Item Description";
    sheet["B1"].Value   = "Source Sheet";

    sheet["A1:B1"].Style.Font.Bold        = true;
    sheet["A1:B1"].Style.BackgroundColor  = "#4472C4";
    sheet["A1:B1"].Style.Font.Color       = "#FFFFFF";

    int rowIndex = 2;
    foreach (string item in items)
    {
        sheet[$"A{rowIndex}"].Value = item;
        rowIndex++;
    }

    report.SaveAs(outputPath);
    Console.WriteLine($"Report saved to: {outputPath}");
}

// Run
var lowStockItems = CheckLowStock("inventory.xlsx");
ExportReport(lowStockItems, "low-stock-report.xlsx");

using IronXL;
using System.IO;

// Validate and load the file
static List<string> CheckLowStock(string filePath)
{
    var lowStockItems = new List<string>();

    if (!File.Exists(filePath))
    {
        Console.WriteLine($"File not found: {filePath}");
        return lowStockItems;
    }

    string ext = Path.GetExtension(filePath).ToLower();
    if (ext is not (".xlsx" or ".xls" or ".csv"))
    {
        Console.WriteLine($"Unsupported file type: {ext}");
        return lowStockItems;
    }

    try
    {
        WorkBook workbook = WorkBook.Load(filePath);

        foreach (WorkSheet sheet in workbook.WorkSheets)
        {
            Console.WriteLine($"Checking sheet: {sheet.Name}");

            for (int row = 2; row <= sheet.RowCount; row++)
            {
                string itemName  = sheet[$"A{row}"].StringValue;
                int stockLevel   = sheet[$"B{row}"].IntValue;

                if (stockLevel < 10 && !string.IsNullOrEmpty(itemName))
                {
                    lowStockItems.Add($"{itemName} -- {stockLevel} units ({sheet.Name})");
                }
            }
        }
    }
    catch (Exception ex)
    {
        Console.WriteLine($"Error reading Excel file: {ex.Message}");
    }

    return lowStockItems;
}

// Export results to a new workbook
static void ExportReport(List<string> items, string outputPath)
{
    WorkBook report     = WorkBook.Create();
    WorkSheet sheet     = report.CreateWorkSheet("Low Stock Report");

    sheet["A1"].Value   = "Item Description";
    sheet["B1"].Value   = "Source Sheet";

    sheet["A1:B1"].Style.Font.Bold        = true;
    sheet["A1:B1"].Style.BackgroundColor  = "#4472C4";
    sheet["A1:B1"].Style.Font.Color       = "#FFFFFF";

    int rowIndex = 2;
    foreach (string item in items)
    {
        sheet[$"A{rowIndex}"].Value = item;
        rowIndex++;
    }

    report.SaveAs(outputPath);
    Console.WriteLine($"Report saved to: {outputPath}");
}

// Run
var lowStockItems = CheckLowStock("inventory.xlsx");
ExportReport(lowStockItems, "low-stock-report.xlsx");

Imports IronXL
Imports System.IO

' Validate and load the file
Private Shared Function CheckLowStock(filePath As String) As List(Of String)
    Dim lowStockItems As New List(Of String)()

    If Not File.Exists(filePath) Then
        Console.WriteLine($"File not found: {filePath}")
        Return lowStockItems
    End If

    Dim ext As String = Path.GetExtension(filePath).ToLower()
    If ext <> ".xlsx" AndAlso ext <> ".xls" AndAlso ext <> ".csv" Then
        Console.WriteLine($"Unsupported file type: {ext}")
        Return lowStockItems
    End If

    Try
        Dim workbook As WorkBook = WorkBook.Load(filePath)

        For Each sheet As WorkSheet In workbook.WorkSheets
            Console.WriteLine($"Checking sheet: {sheet.Name}")

            For row As Integer = 2 To sheet.RowCount
                Dim itemName As String = sheet($"A{row}").StringValue
                Dim stockLevel As Integer = sheet($"B{row}").IntValue

                If stockLevel < 10 AndAlso Not String.IsNullOrEmpty(itemName) Then
                    lowStockItems.Add($"{itemName} -- {stockLevel} units ({sheet.Name})")
                End If
            Next
        Next
    Catch ex As Exception
        Console.WriteLine($"Error reading Excel file: {ex.Message}")
    End Try

    Return lowStockItems
End Function

' Export results to a new workbook
Private Shared Sub ExportReport(items As List(Of String), outputPath As String)
    Dim report As WorkBook = WorkBook.Create()
    Dim sheet As WorkSheet = report.CreateWorkSheet("Low Stock Report")

    sheet("A1").Value = "Item Description"
    sheet("B1").Value = "Source Sheet"

    sheet("A1:B1").Style.Font.Bold = True
    sheet("A1:B1").Style.BackgroundColor = "#4472C4"
    sheet("A1:B1").Style.Font.Color = "#FFFFFF"

    Dim rowIndex As Integer = 2
    For Each item As String In items
        sheet($"A{rowIndex}").Value = item
        rowIndex += 1
    Next

    report.SaveAs(outputPath)
    Console.WriteLine($"Report saved to: {outputPath}")
End Sub

' Run
Dim lowStockItems As List(Of String) = CheckLowStock("inventory.xlsx")
ExportReport(lowStockItems, "low-stock-report.xlsx")

Imports IronXL
Imports System.IO

' Validate and load the file
Private Shared Function CheckLowStock(filePath As String) As List(Of String)
    Dim lowStockItems As New List(Of String)()

    If Not File.Exists(filePath) Then
        Console.WriteLine($"File not found: {filePath}")
        Return lowStockItems
    End If

    Dim ext As String = Path.GetExtension(filePath).ToLower()
    If ext <> ".xlsx" AndAlso ext <> ".xls" AndAlso ext <> ".csv" Then
        Console.WriteLine($"Unsupported file type: {ext}")
        Return lowStockItems
    End If

    Try
        Dim workbook As WorkBook = WorkBook.Load(filePath)

        For Each sheet As WorkSheet In workbook.WorkSheets
            Console.WriteLine($"Checking sheet: {sheet.Name}")

            For row As Integer = 2 To sheet.RowCount
                Dim itemName As String = sheet($"A{row}").StringValue
                Dim stockLevel As Integer = sheet($"B{row}").IntValue

                If stockLevel < 10 AndAlso Not String.IsNullOrEmpty(itemName) Then
                    lowStockItems.Add($"{itemName} -- {stockLevel} units ({sheet.Name})")
                End If
            Next
        Next
    Catch ex As Exception
        Console.WriteLine($"Error reading Excel file: {ex.Message}")
    End Try

    Return lowStockItems
End Function

' Export results to a new workbook
Private Shared Sub ExportReport(items As List(Of String), outputPath As String)
    Dim report As WorkBook = WorkBook.Create()
    Dim sheet As WorkSheet = report.CreateWorkSheet("Low Stock Report")

    sheet("A1").Value = "Item Description"
    sheet("B1").Value = "Source Sheet"

    sheet("A1:B1").Style.Font.Bold = True
    sheet("A1:B1").Style.BackgroundColor = "#4472C4"
    sheet("A1:B1").Style.Font.Color = "#FFFFFF"

    Dim rowIndex As Integer = 2
    For Each item As String In items
        sheet($"A{rowIndex}").Value = item
        rowIndex += 1
    Next

    report.SaveAs(outputPath)
    Console.WriteLine($"Report saved to: {outputPath}")
End Sub

' Run
Dim lowStockItems As List(Of String) = CheckLowStock("inventory.xlsx")
ExportReport(lowStockItems, "low-stock-report.xlsx")

Este exemplo utiliza instruções de nível superior e abrange todo o fluxo de trabalho: validar o caminho e a extensão do arquivo, carregar a pasta de trabalho, iterar por todas as planilhas, aplicar a lógica de negócios e gravar os resultados em um novo arquivo. Para obter mais informações sobre como escrever e salvar pastas de trabalho, consulte o guia de gravação de arquivos do Excel e o guia de exportação do Excel .

Observe que o método ExportReport cria uma nova planilha com WorkBook.Create() em vez de modificar o arquivo de origem. Manter arquivos de origem e saída separados é uma boa prática para trilhas de auditoria e evita sobrescrever acidentalmente dados dos quais outros processos dependem. Se você precisar anexar dados a uma planilha existente, carregue-a com WorkBook.Load(), adicione linhas à planilha apropriada e chame SaveAs() para um novo caminho ou sobrescreva no local.

Como você processa arquivos Excel grandes de forma eficiente?

Para arquivos com milhares de linhas, funções agregadas superam loops manuais porque operam internamente sem materializar cada célula como um objeto separado:

using IronXL;

WorkBook workbook = WorkBook.Load("large-dataset.xlsx");
WorkSheet ws      = workbook.DefaultWorkSheet;

// Fast: aggregate functions operate on the range directly
decimal total   = ws["B2:B5000"].Sum();
decimal average = ws["B2:B5000"].Avg();
int count       = ws["B2:B5000"].Count();

Console.WriteLine($"Total: {total:C}, Average: {average:C}, Rows: {count}");

// Export the worksheet to a DataSet for LINQ or database operations
var dataSet = workbook.ToDataSet();
Console.WriteLine($"DataSet tables: {dataSet.Tables.Count}");

using IronXL;

WorkBook workbook = WorkBook.Load("large-dataset.xlsx");
WorkSheet ws      = workbook.DefaultWorkSheet;

// Fast: aggregate functions operate on the range directly
decimal total   = ws["B2:B5000"].Sum();
decimal average = ws["B2:B5000"].Avg();
int count       = ws["B2:B5000"].Count();

Console.WriteLine($"Total: {total:C}, Average: {average:C}, Rows: {count}");

// Export the worksheet to a DataSet for LINQ or database operations
var dataSet = workbook.ToDataSet();
Console.WriteLine($"DataSet tables: {dataSet.Tables.Count}");

Imports IronXL

Dim workbook As WorkBook = WorkBook.Load("large-dataset.xlsx")
Dim ws As WorkSheet = workbook.DefaultWorkSheet

' Fast: aggregate functions operate on the range directly
Dim total As Decimal = ws("B2:B5000").Sum()
Dim average As Decimal = ws("B2:B5000").Avg()
Dim count As Integer = ws("B2:B5000").Count()

Console.WriteLine($"Total: {total:C}, Average: {average:C}, Rows: {count}")

' Export the worksheet to a DataSet for LINQ or database operations
Dim dataSet = workbook.ToDataSet()
Console.WriteLine($"DataSet tables: {dataSet.Tables.Count}")

Imports IronXL

Dim workbook As WorkBook = WorkBook.Load("large-dataset.xlsx")
Dim ws As WorkSheet = workbook.DefaultWorkSheet

' Fast: aggregate functions operate on the range directly
Dim total As Decimal = ws("B2:B5000").Sum()
Dim average As Decimal = ws("B2:B5000").Avg()
Dim count As Integer = ws("B2:B5000").Count()

Console.WriteLine($"Total: {total:C}, Average: {average:C}, Rows: {count}")

' Export the worksheet to a DataSet for LINQ or database operations
Dim dataSet = workbook.ToDataSet()
Console.WriteLine($"DataSet tables: {dataSet.Tables.Count}")

Converter para um DataSet é particularmente eficaz quando você precisa executar consultas LINQ em várias folhas ou carregar dados em um banco de dados relacional. Cada planilha se torna um DataTable dentro do DataSet, tornando simples trabalhar com código de acesso a dados existente. Consulte o guia "Excel para DataSet" para obter detalhes completos.

Como você obtém uma licença e implanta em produção?

IronXL é uma biblioteca comercial com uma avaliação gratuita que permite funcionalidade completa durante o desenvolvimento e teste. Para implantações em produção, você precisará de uma chave de licença válida. Detalhes sobre níveis de licenciamento, incluindo opções para desenvolvedor, equipe e empresa, estão na página de licenciamento do IronXL.

Para aplicar uma chave de licença, defina-a antes de qualquer chamada do IronXL:

IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";

IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";

Imports IronXL

IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"

Imports IronXL

IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"

O resumo de funcionalidades do IronXL resume todas as capacidades, desde a leitura e escrita de arquivos até a criação de gráficos, aplicação de formatação condicional e trabalho com intervalos nomeados. O guia para criar arquivos do Excel e o tutorial sobre como mesclar células são pontos de partida úteis para a criação de novas planilhas.

Para discussões comunitárias e perguntas sobre automação de Excel em C#, os fóruns de perguntas e respostas da Microsoft e o Stack Overflow são bons recursos. A página do pacote NuGet oficial fornece histórico de versões e estatísticas de download.

Quais são as principais considerações para abrir arquivos Excel em C#?

IronXL remove a dependência do Microsoft Office completamente, tornando prático processar arquivos Excel em servidores, em contêineres e em funções de nuvem. A API segue um padrão simples: carregar uma planilha, acessar planilhas por nome ou índice e ler células usando acessores tipados. Funções de agregação como Sum(), Avg(), e Max() lidam com grandes conjuntos de dados sem a sobrecarga de iteração manual.

A biblioteca suporta formatos XLSX, XLS, CSV e TSV, roda no .NET 10 e em todas as versões recentes do .NET, e funciona em todas as plataformas. O tratamento de erros é simples porque o IronXL lança exceções padrão .NET que você pode capturar com padrões familiares try/catch -- sem códigos de erro de interoperabilidade COM para decodificar. Para explorar todas as opções disponíveis, comece pela página inicial da documentação do IronXL ou experimente o guia passo a passo em formato de planilha aberta .

Inicie uma avaliação gratuita do IronXL para avaliar a biblioteca em seus próprios projetos sem qualquer compromisso.

Primeiro passo:

Comece gratuitamente