Ícone de mensagem
Ir para o conteúdo do rodapé
  1. IronXL
  2. Blog IronXL
  3. Usando o IronXL
  4. VB.NET Abra o Excel
USANDO O IRONXL

Como abrir um arquivo do Excel em C# sem o Microsoft Office

Jordi Bardia
Jordi Bardia
Atualizado:

IronXL permite abrir e ler arquivos do 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 inteiroervalo 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 seguinteiroes gerenciadores de pacotes:

Install-Package IronXL
dotnet add package IronXL
Install-Package IronXL
dotnet add package IronXL
SHELL

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.

Gerenciador de Pacotes NuGet do Visual Studio mostrando o pacote IronXl.Excel com a versão 2025.9.1 disponível para instalação

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

using IronXL;
using IronXL;
Imports IronXL
$vbLabelText   $csharpLabel

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 inteiroernamente, oferecendo uma API limpa que funciona sem quaisquer dependências externas.

Com Interop, você também precisa gerenciar cuidadosamente o tempo de vida dos objetos COM para evitar vazamento de memória -- todo objeto Application, Workbook e Worksheet deve ser explicitamente liberado, 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 sejam executadas 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
$vbLabelText   $csharpLabel

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

Para mais opções sobre como abrir arquivos, consulte o guia de como abrir uma planilha.

Tela dividida mostrando uma planilha do Excel com dados de pedidos à esquerda e um console de depuração do Visual Studio exibindo os dados extraídos à direita

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
$vbLabelText   $csharpLabel

O guia de leitura de arquivos Excel explica padrões adicionais de acesso a planilhas, incluindo o trabalho com planilhas que têm 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 cordas, inteiroeiros, decimais, datas, booleanoeanos 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
corda productName = ws["A2"].StringValue;
inteiro quantity       = ws["B2"].IntValue;
decimal price      = ws["C2"].DecimalValue;
DateTime updated   = ws["D2"].DateTimeValue;

// 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
corda productName = ws["A2"].StringValue;
inteiro quantity       = ws["B2"].IntValue;
decimal price      = ws["C2"].DecimalValue;
DateTime updated   = ws["D2"].DateTimeValue;

// 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}");
Imports IronXL

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

' Read different data types directly
Dim productName As String = ws("A2").StringValue
Dim quantity As Integer = ws("B2").IntValue
Dim price As Decimal = ws("C2").DecimalValue
Dim updated As DateTime = ws("D2").DateTimeValue

' Use aggregate functions on ranges for performance
Dim totalStock As Decimal = ws("B2:B100").Sum()
Dim maxPrice As Decimal = ws("C2:C100").Max()

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

A tabela abaixo resume os accessores tipados disponíveis:

Accessóres de valores de célula do IronXL por tipo de dado
Accessór Tipo de Retorno Notas
`StringValue` corda Sempre retorna uma corda, mesmo para células numéricas
`IntValue` inteiro Trunca valores decimais
`DecimalValue` decimal Melhor para dados financeiros
`DoubleValue` dobro Para valores científicos ou de ponto flutuante
`DateTimeValue` DateTime Analisa automaticamente os números de datas seriais do Excel
`BoolValue` booleano Lê células TRUE/FALSE
`Formula` corda Retorna o texto da fórmula, e.g. `=SUM(A2:D2)`

Para detalhes completos sobre leitura e escrita de dados de células, consulte o guia de formatação de células e o como importar dados.

Planilha do Excel mostrando dados de inventário de produtos com colunas para Produto, Quantidade, Preço, e Última Atualização, juntamente com o Console de Depuração do Visual Studio exibindo os mesmos dados programaticamente lidos usando C#

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 nulo antes de ler os 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
corda 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
corda 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
$vbLabelText   $csharpLabel

A documentação de leitura de arquivo Excel cobre padrões adicionais para lidar com dados esparsos, incluindo como detectar a última linha e coluna usadas 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 corda vazia. IsEmpty retorna verdadeiro somente quando a célula não contém valor algum, enquanto StringValue retorna uma corda vazia tanto para células em branco quanto para células explicitamente definidas como "". Se seus dados contêm células formatadas como texto que parecem vazias, verifique tanto IsEmpty quanto corda.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<corda> CheckLowStock(corda filePath)
{
    var lowStockItems = new List<corda>();

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

    corda 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 (inteiro row = 2; row <= sheet.RowCount; row++)
            {
                corda itemName  = sheet[$"A{row}"].StringValue;
                inteiro stockLevel   = sheet[$"B{row}"].IntValue;

                if (stockLevel < 10 && !corda.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<corda> items, corda 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";

    inteiro rowIndex = 2;
    foreach (corda 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<corda> CheckLowStock(corda filePath)
{
    var lowStockItems = new List<corda>();

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

    corda 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 (inteiro row = 2; row <= sheet.RowCount; row++)
            {
                corda itemName  = sheet[$"A{row}"].StringValue;
                inteiro stockLevel   = sheet[$"B{row}"].IntValue;

                if (stockLevel < 10 && !corda.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<corda> items, corda 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";

    inteiro rowIndex = 2;
    foreach (corda 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")
$vbLabelText   $csharpLabel

Este exemplo utiliza instruções de nível superior e cobre o fluxo de trabalho completo: validar o caminho e a extensão do arquivo, carregar a planilha, iterar todas as planilhas, aplicar lógica de negócios e gravar resultados em um novo arquivo. Para mais informações sobre como escrever e salvar planilhas, consulte o guia de escrita de arquivo Excel e o como exportar Excel.

Observe que o método ExportReport cria uma nova planilha com WorkBook.Create() ao invés de modificar o arquivo de origem. Manter arquivos de origem e saída separados é uma boa prática para trilhas de auditoria e evita sobreescrever dados dos quais outros processos dependem acidentalmente. Se você precisar adicionar dados a uma planilha existente, carregue-a com WorkBook.Load(), adicione linhas à planilha apropriada, e chame SaveAs() para um novo caminho ou sobreescreva 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 inteiroernamente 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();
inteiro 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();
inteiro 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}")
$vbLabelText   $csharpLabel

Converter para um DataSet é particularmente eficaz quando você precisa executar consultas LINQ em múltiplas planilhas ou carregar dados em um banco de dados relacional. Cada planilha torna-se um DataTable dentro do DataSet, tornando simples trabalhar com o código de acesso a dados existente. Veja o guia de Excel para DataSet para 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"
$vbLabelText   $csharpLabel

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 inteiroervalos nomeados. O guia de criação de arquivo Excel e o como mesclar células são pontos de partida úteis para escrever 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 os principais pontos 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 é direto porque o IronXL lança exceções padrão do .NET que você pode capturar com padrões try/catch familiares -- sem códigos de erro de inteiroeroperabilidade COM para decodificar. Para explorar todas as opções disponíveis, comece com a página da documentação do IronXL ou experimente o como abrir planilha para uma referência passo a passo.

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

!{--010011000100100101000010010100100100000101010010010110010101111101000111010001010101010100010111110101001101010100010000010101001001010100010001010100010001011111010101110100100 101010100010010000101111101010000010100100111101000100010101010100001101010100010111110101010001010010010010010010010100000101001100010111110100001001001100010011110100001101001011--}

Perguntas frequentes

Como posso abrir um arquivo do Excel em VB.NET sem o Microsoft Office?

Você pode abrir e ler arquivos do Excel em VB.NET sem o Microsoft Office usando a biblioteca IronXL. O IronXL oferece uma maneira simples de trabalhar com arquivos do Excel sem a necessidade do Microsoft Office ou de métodos de interoperabilidade complexos.

Quais são os benefícios de usar o IronXL para processamento de Excel em VB.NET?

IronXL simplifica o processamento do Excel em VB.NET, eliminando a necessidade do Microsoft Office e evitando referências COM complexas. Ele garante a compatibilidade em diferentes ambientes, como servidores e plataformas em nuvem, e ajuda a prevenir conflitos de versão.

É possível processar arquivos XLSX e XLS usando o IronXL?

Sim, o IronXL suporta o processamento de arquivos nos formatos XLSX e XLS, permitindo que você abra, leia e manipule esses arquivos do Excel em seus aplicativos VB.NET.

Preciso instalar algum software adicional para usar o IronXL?

Não é necessário nenhum software adicional para usar o IronXL para processamento de arquivos Excel em VB.NET. O IronXL é uma biblioteca independente que se integra diretamente aos seus projetos VB.NET.

O IronXL pode ser usado em ambientes de nuvem?

Sim, o IronXL foi projetado para funcionar perfeitamente em ambientes de nuvem, evitando os problemas comuns dos métodos tradicionais de interoperabilidade do Excel, que frequentemente encontram conflitos de versão em servidores ou plataformas de nuvem.

Como o IronXL lida com a compatibilidade de arquivos do Excel?

O IronXL garante a compatibilidade ao suportar vários formatos de arquivo do Excel, como XLSX e XLS, e ao fornecer funcionalidades robustas para manipular e processar esses arquivos sem depender do Microsoft Office.

O IronXL é compatível com diferentes versões do VB.NET?

O IronXL é compatível com diversas versões do VB.NET, tornando-se uma solução versátil para desenvolvedores que trabalham com diferentes versões do framework .NET.

Quais são os desafios comuns ao usar métodos de interoperabilidade tradicionais para Excel em VB.NET?

Os métodos tradicionais de interoperabilidade geralmente exigem o Microsoft Office, envolvem referências COM complexas e são propensos a conflitos de versão, especialmente em ambientes de servidor ou nuvem. O IronXL oferece uma solução para esses desafios, fornecendo uma abordagem mais confiável e direta.

O IronXL pode ser usado para manipulação de arquivos do Excel, como edição ou exportação de dados?

Sim, o IronXL oferece funcionalidades não apenas para leitura de arquivos Excel, mas também para edição e exportação de dados, tornando-se uma ferramenta completa para manipulação de arquivos Excel em VB.NET.

Onde posso encontrar exemplos de código funcionais para usar o IronXL em VB.NET?

Você pode encontrar exemplos de código funcionais para usar o IronXL em VB.NET na documentação e nos tutoriais do IronXL, que fornecem orientações passo a passo sobre como processar arquivos do Excel sem o Microsoft Office.

Jordi Bardia
Jordi Bardia
  Converse agora mesmo com a equipe de engenharia.
Engenheiro de Software
Jordi é extremamente proficiente em Python, C# e C++, e quando não está utilizando suas habilidades na Iron Software, dedica-se à programação de jogos. Compartilhando as responsabilidades por testes, desenvolvimento e pesquisa de produtos, Jordi agrega imenso valor à melhoria contínua dos produtos. Essa experiência diversificada o mantém ...
Leia mais

Artigos relacionados
Teste grátis por 30 dias → Produto completo. Sem limites. Sem cartão. Comece seu teste gratuito

Equipe de suporte de ferro

Estamos online 24 horas por dia, 5 dias por semana.
Bater papo
E-mail
Liga para mim