Í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;
$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}");
}
$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}");
    }
}
$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}");
$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);
    }
}
$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");
$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}");
$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";
$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

Iron Support Team

We're online 24 hours, 5 days a week.
Chat
Email
Call Me