USANDO O IRONXL

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

Atualizado:fevereiro 27, 2026

O IronXL permite abrir e ler arquivos do Excel em C# sem o Microsoft Office instalado -- basta instalar o pacote NuGet, carregar uma pasta de trabalho com WorkBook.Load("file.xlsx") e acessar qualquer planilha, célula ou inteiroervalo com valores digitados e detecção automática de formatação.

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.

O Gerenciador de Pacotes NuGet do Visual Studio mostra o pacote IronXL.Excel na 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 o Interop, você também precisa gerenciar cuidadosamente o tempo de vida dos objetos COM para evitar vazamentos de memória -- cada objeto Application, Workbook e Worksheet deve ser liberado explicitamente, caso contrário, os 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 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 .

! 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 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 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;
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
corda productName = ws["A2"].StringValue;
inteiro 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}");

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
`Data e horaValue`	Data e hora	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 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.

Planilha do Excel exibindo dados de estoque 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 lidos programaticamente 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 se Value é 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 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 corda vazia. IsEmpty retorna verdadeiro apenas quando a célula não contém nenhum valor, enquanto StringValue retorna uma corda vazia tanto para células em branco quanto para células explicitamente definidas como "". Se os seus dados tiverem células formatadas como texto que aparecem vazias, verifique IsEmpty e corda.IsNullOrWhiteSpace(cell.StringValue) para obter 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 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 os arquivos de origem e saída separados é uma boa prática para trilhas de auditoria e evita a sobrescrita acidental de dados dos quais outros processos dependem. Se precisar adicionar 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 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

A conversão para um DataSet é particularmente eficaz quando você precisa executar consultas LINQ em várias planilhas ou carregar dados em um banco de dados relacional. Cada planilha se torna um DataTable dentro do DataSet, facilitando o trabalho com o 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"

$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 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 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 agregadas como Sum(), Avg() e Max() lidam com grandes conjuntos de dados sem a sobrecarga da 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, pois o IronXL lança exceções padrão do .NET que podem ser capturadas com os padrões familiares try/catch -- sem códigos de erro de inteiroeroperabilidade 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.

!{--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

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 ...

Destaque do cliente:

Destaque do desenvolvedor:

Webinários:

Experimente gratuitamente por 30 dias.

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

Como instalar o IronXL em um projeto .NET?

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

Como Verificar se a Instalação Funcionou?

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

Como Acessar Planilhas por Nome?

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

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

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

Como você processa arquivos Excel grandes de forma eficiente?

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

Quais são os principais pontos para abrir arquivos Excel em C#?

Perguntas frequentes

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

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

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

Preciso instalar algum software adicional para usar o IronXL?

O IronXL pode ser usado em ambientes de nuvem?

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

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

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

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

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

Equipe de suporte de ferro

Experimente gratuitamente por 30 dias.

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

Como instalar o IronXL em um projeto .NET?

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

Como Verificar se a Instalação Funcionou?

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

Como Acessar Planilhas por Nome?

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

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

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

Como você processa arquivos Excel grandes de forma eficiente?

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

Quais são os principais pontos para abrir arquivos Excel em C#?

Perguntas frequentes

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

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

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

Preciso instalar algum software adicional para usar o IronXL?

O IronXL pode ser usado em ambientes de nuvem?

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

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

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

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

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

Artigos relacionados

Leia arquivos do Excel usando o Microsoft Office Interop Excel C#: e uma maneira mais rápida de criar arquivos do Excel sem o Office.

Baixe arquivos do Excel em .NET C#: Exporte dados para XLSX, CSV e muito mais.

Como criar tabelas dinâmicas no Excel com C# sem interoperabilidade

Want to deploy IronSuite to a live project for FREE?

What’s included?

Thank You

Want to deploy IronSuite to a live project for FREE?

What’s included?

Aprovado por milhões de engenheiros em todo o mundo.

Equipe de suporte de ferro