Ícone de mensagem
Ir para o conteúdo do rodapé
  1. Iron Software
  2. Blog IronXL
  3. Comparar com outros componentes
  4. VB.NET: Ler matriz do Excel
COMPARAR COM OUTROS COMPONENTES

Leitura de arquivo Excel em matriz usando VB .NET : Interoperabilidade com IronXL vs Microsoft

Jordi Bardia
Jordi Bardia
Atualizado:

Ler dados do Excel em arrays no VB.NET requer carregar uma pasta de trabalho, selecionar uma planilha, iterar linhas e colunas e armazenar cada valor de célula em um array bidimensional. Com IronXL, você realiza isso em algumas linhas sem instalar o Microsoft Office. Instale o pacote NuGet, chame WorkBook.Load, obtenha um Range, então percorra sua coleção Rows para preencher seu array.

Comece sua avaliação gratuita para explorar como o IronXL simplifica a automação do Excel em seus projetos do Visual Studio.

Como Essas Soluções se Comparam à Primeira Vista?

IronXL vs Interoperabilidade com o Microsoft Office -- Comparação de Recursos para Operações de Array no VB.NET
Recurso IronXL Interoperabilidade com o Microsoft Office
Instalação do Office necessária Não Sim
Instalação do NuGet Sim -- um pacote Não -- referência COM
Suporte de ambiente Server/CI Sim Limitado
Gerenciamento do ciclo de vida de objetos COM Não é necessário Obrigatório
Formatos suportados XLSX, XLS, CSV, TSV, JSON XLSX, XLS (somente Excel)
API com segurança de tipos Sim Parcial -- COM com ligação tardia
Suporte Linux / macOS Sim (.NET 6+) Não
Estilo de tratamento de exceções Exceções padrão do .NET Exceções COM + limpeza manual

Como Instalar o IronXL em Projetos VB.NET?

A maneira mais rápida de adicionar o IronXL a qualquer projeto .NET é através do Gerenciador de Pacotes NuGet. Abra o Console do Gerenciador de Pacotes no Visual Studio e execute:

Install-Package IronXl.Excel
Install-Package IronXl.Excel
SHELL

Alternativamente, use o .NET CLI:

dotnet add package IronXl.Excel
dotnet add package IronXl.Excel
SHELL

Após a instalação, adicione Imports IronXL no topo do seu módulo VB.NET. Não é necessária a instalação do Office -- o IronXL lê e escreve arquivos Excel inteiramente através do seu próprio mecanismo de análise.

Para projetos que visam frameworks mais antigos ou que exigem fixação de versão específica, a página NuGet do IronXL lista todas as versões publicadas. A documentação do IronXL fornece guias de instalação para o Visual Studio 2019, 2022, e a CLI do .NET.

Como os Desenvolvedores Podem Ler Dados do Excel em Arrays Usando o IronXL?

O IronXL fornece uma API limpa para abrir livros, selecionar intervalos e iterar valores de células sem exigir uma instalação local do Office. O método WorkBook.Load aceita um caminho de arquivo e retorna um objeto WorkBook que expõe todas as planilhas.

Imports IronXL

Module ReadExcelToArray
    Sub Main()
        ' Load the Excel workbook from a file path
        Dim workbook As WorkBook = WorkBook.Load("SalesData.xlsx")

        ' Access the first worksheet in the workbook
        Dim sheet As WorkSheet = workbook.DefaultWorkSheet

        ' Define the cell range to extract
        Dim dataRange As IronXl.Range = sheet.GetRange("A1:D5")

        ' Determine array dimensions from the range
        Dim rowCount As Integer = dataRange.Rows.Count
        Dim colCount As Integer = dataRange.Columns.Count
        Dim salesArray(rowCount - 1, colCount - 1) As String

        ' Populate the two-dimensional array from cell values
        Dim rowIndex As Integer = 0
        For Each row As RangeRow In dataRange.Rows
            Dim colIndex As Integer = 0
            For Each cell As Cell In row
                salesArray(rowIndex, colIndex) = cell.StringValue
                colIndex += 1
            Next
            rowIndex += 1
        Next

        ' Print each row to the console
        Console.WriteLine("Data loaded into array:")
        For i As Integer = 0 To rowCount - 1
            For j As Integer = 0 To colCount - 1
                Console.Write(salesArray(i, j) & vbTab)
            Next
            Console.WriteLine()
        Next
    End Sub
End Module
Imports IronXL

Module ReadExcelToArray
    Sub Main()
        ' Load the Excel workbook from a file path
        Dim workbook As WorkBook = WorkBook.Load("SalesData.xlsx")

        ' Access the first worksheet in the workbook
        Dim sheet As WorkSheet = workbook.DefaultWorkSheet

        ' Define the cell range to extract
        Dim dataRange As IronXl.Range = sheet.GetRange("A1:D5")

        ' Determine array dimensions from the range
        Dim rowCount As Integer = dataRange.Rows.Count
        Dim colCount As Integer = dataRange.Columns.Count
        Dim salesArray(rowCount - 1, colCount - 1) As String

        ' Populate the two-dimensional array from cell values
        Dim rowIndex As Integer = 0
        For Each row As RangeRow In dataRange.Rows
            Dim colIndex As Integer = 0
            For Each cell As Cell In row
                salesArray(rowIndex, colIndex) = cell.StringValue
                colIndex += 1
            Next
            rowIndex += 1
        Next

        ' Print each row to the console
        Console.WriteLine("Data loaded into array:")
        For i As Integer = 0 To rowCount - 1
            For j As Integer = 0 To colCount - 1
                Console.Write(salesArray(i, j) & vbTab)
            Next
            Console.WriteLine()
        Next
    End Sub
End Module
$vbLabelText   $csharpLabel

Compreendendo os Objetos WorkBook e WorkSheet

WorkBook.Load suporta arquivos XLSX, XLS, CSV e TSV. Uma vez carregado, workbook.DefaultWorkSheet retorna a primeira planilha. Você também pode acessar planilhas pelo nome com workbook.GetWorkSheet("Sheet1") ou pelo índice com workbook.WorkSheets(0).

A chamada GetRange("A1:D5") retorna um IronXl.Range que expõe coleções Rows e Columns. Cada RangeRow itera objetos Cell, e cell.StringValue retorna a string de exibição independentemente do tipo de célula subjacente.

Como Você Lida com Valores de Célula Tipados?

As células do IronXL expõem propriedades tipadas juntamente com StringValue:

  • cell.IntValue -- analisa a célula como um inteiro
  • cell.DoubleValue -- analisa a célula como um double
  • cell.DateTimeValue -- analisa células formatadas como data
  • cell.IsFormula -- indica se a célula contém uma fórmula

Para dados financeiros, declare o array como Double e atribua cell.DoubleValue diretamente. Isso evita conversões de string para número durante o processamento subsequente.

Imports IronXL

Module ReadExcelToDoubleArray
    Sub Main()
        Dim workbook As WorkBook = WorkBook.Load("Revenue.xlsx")
        Dim sheet As WorkSheet = workbook.DefaultWorkSheet
        Dim dataRange As IronXl.Range = sheet.GetRange("B2:E10")

        Dim rowCount As Integer = dataRange.Rows.Count
        Dim colCount As Integer = dataRange.Columns.Count
        Dim revenueArray(rowCount - 1, colCount - 1) As Double

        Dim rowIndex As Integer = 0
        For Each row As RangeRow In dataRange.Rows
            Dim colIndex As Integer = 0
            For Each cell As Cell In row
                revenueArray(rowIndex, colIndex) = cell.DoubleValue
                colIndex += 1
            Next
            rowIndex += 1
        Next

        ' Calculate column totals
        For j As Integer = 0 To colCount - 1
            Dim total As Double = 0
            For i As Integer = 0 To rowCount - 1
                total += revenueArray(i, j)
            Next
            Console.WriteLine($"Column {j + 1} total: {total:C}")
        Next
    End Sub
End Module
Imports IronXL

Module ReadExcelToDoubleArray
    Sub Main()
        Dim workbook As WorkBook = WorkBook.Load("Revenue.xlsx")
        Dim sheet As WorkSheet = workbook.DefaultWorkSheet
        Dim dataRange As IronXl.Range = sheet.GetRange("B2:E10")

        Dim rowCount As Integer = dataRange.Rows.Count
        Dim colCount As Integer = dataRange.Columns.Count
        Dim revenueArray(rowCount - 1, colCount - 1) As Double

        Dim rowIndex As Integer = 0
        For Each row As RangeRow In dataRange.Rows
            Dim colIndex As Integer = 0
            For Each cell As Cell In row
                revenueArray(rowIndex, colIndex) = cell.DoubleValue
                colIndex += 1
            Next
            rowIndex += 1
        Next

        ' Calculate column totals
        For j As Integer = 0 To colCount - 1
            Dim total As Double = 0
            For i As Integer = 0 To rowCount - 1
                total += revenueArray(i, j)
            Next
            Console.WriteLine($"Column {j + 1} total: {total:C}")
        Next
    End Sub
End Module
$vbLabelText   $csharpLabel

Saída

VB .NET Ler Arquivo Excel Em Array: Comparação IronXL vs Interoperabilidade Microsoft: Imagem 1 - IronXL vs. Office Excel para fazer VB .NET ler Arquivo Excel em array

Este exemplo de código demonstra a API intuitiva do IronXL. O método WorkBook.Load abre o arquivo Excel diretamente da sua pasta designada, enquanto o objeto Range fornece acesso a regiões específicas de células dentro da planilha Excel. Ao contrário de macros VBA legadas, esta abordagem é totalmente segura para tipos e integrada ao ecossistema .NET.

!{--010011000100100101000010010100100100000101010010010110010101111101000111010001010101010100010111110101001101010100010000010101001001010100010001010100010001011111010101110100100 101010100010010000101111101010000010100100111101000100010101010100001101010100010111110101010001010010010010010010010100000101001100010111110100001001001100010011110100001101001011--}

Qual é a Abordagem Tradicional do Interoperabilidade com o Microsoft Office?

O Interoperabilidade com o Microsoft Office depende da automação COM para conectar-se com uma instância da aplicação Excel. Para configurar isso no Visual Studio, navegue até o menu Projeto, selecione "Adicionar Referência" e procure a Biblioteca de Objetos do Microsoft Excel na guia COM. Uma instalação local do Excel deve existir em cada máquina que execute o código.

Imports Microsoft.Office.Interop.Excel

Module InteropExcelArray
    Sub Main()
        Dim excelApp As New Application()
        Dim workbooks As Workbooks = excelApp.Workbooks
        Dim workbook As Workbook = Nãothing
        Dim sheet As Worksheet = Nãothing

        Try
            ' Suppress screen updates during processing
            excelApp.ScreenUpdating = False

            ' Open the workbook by full file path
            workbook = workbooks.Open("C:\Data\SalesData.xlsx")

            ' Reference the first worksheet
            sheet = CType(workbook.Sheets(1), Worksheet)

            ' Define a range and pull values into an object array
            Dim dataRange As Range = sheet.Range("A1", "D5")
            Dim values(,) As Object = CType(dataRange.Value, Object(,))

            ' COM arrays are 1-based, so enumerate from index 1
            Dim rows As Integer = values.GetUpperBound(0)
            Dim columns As Integer = values.GetUpperBound(1)

            For i As Integer = 1 To rows
                Dim line As String = ""
                For j As Integer = 1 To columns
                    line &= values(i, j).ToString() & vbTab
                Next
                Console.WriteLine(line)
            Next

        Catch ex As Exception
            Console.WriteLine("Error: " & ex.Message)

        Finally
            ' Release COM objects to prevent orphaned Excel processes
            If sheet IsNãot Nãothing Then
                System.Runtime.InteropServices.Marshal.ReleaseComObject(sheet)
            End If
            If workbook IsNãot Nãothing Then
                workbook.Close(False)
                System.Runtime.InteropServices.Marshal.ReleaseComObject(workbook)
            End If
            excelApp.Quit()
            System.Runtime.InteropServices.Marshal.ReleaseComObject(excelApp)
        End Try
    End Sub
End Module
Imports Microsoft.Office.Interop.Excel

Module InteropExcelArray
    Sub Main()
        Dim excelApp As New Application()
        Dim workbooks As Workbooks = excelApp.Workbooks
        Dim workbook As Workbook = Nãothing
        Dim sheet As Worksheet = Nãothing

        Try
            ' Suppress screen updates during processing
            excelApp.ScreenUpdating = False

            ' Open the workbook by full file path
            workbook = workbooks.Open("C:\Data\SalesData.xlsx")

            ' Reference the first worksheet
            sheet = CType(workbook.Sheets(1), Worksheet)

            ' Define a range and pull values into an object array
            Dim dataRange As Range = sheet.Range("A1", "D5")
            Dim values(,) As Object = CType(dataRange.Value, Object(,))

            ' COM arrays are 1-based, so enumerate from index 1
            Dim rows As Integer = values.GetUpperBound(0)
            Dim columns As Integer = values.GetUpperBound(1)

            For i As Integer = 1 To rows
                Dim line As String = ""
                For j As Integer = 1 To columns
                    line &= values(i, j).ToString() & vbTab
                Next
                Console.WriteLine(line)
            Next

        Catch ex As Exception
            Console.WriteLine("Error: " & ex.Message)

        Finally
            ' Release COM objects to prevent orphaned Excel processes
            If sheet IsNãot Nãothing Then
                System.Runtime.InteropServices.Marshal.ReleaseComObject(sheet)
            End If
            If workbook IsNãot Nãothing Then
                workbook.Close(False)
                System.Runtime.InteropServices.Marshal.ReleaseComObject(workbook)
            End If
            excelApp.Quit()
            System.Runtime.InteropServices.Marshal.ReleaseComObject(excelApp)
        End Try
    End Sub
End Module
$vbLabelText   $csharpLabel

Por Que o Gerenciamento de Objetos COM É Importante?

A abordagem Interop requer atenção cuidadosa ao gerenciamento do ciclo de vida dos objetos COM. Cada objeto retornado pela aplicação Excel -- livros, planilhas, intervalos e células -- mantém um ponteiro COM com contagem de referência. Falha ao chamar Marshal.ReleaseComObject em cada um desses objetos deixa um processo EXCEL.EXE rodando silenciosamente em segundo plano.

Em servidores, processos órfãos se acumulam ao longo do tempo e eventualmente esgotam a memória disponível ou os manipuladores de arquivos. O padrão Try...Finally acima é a abordagem segura mínima, mas muitos códigos de bases empresariais adicionam uma utilidade de limpeza COM dedicada para lidar com gráficos de objetos aninhados.

A convenção de indexação de arrays Interop também difere de arrays padrão VB.NET: arrays baseados em COM começam no índice 1, não 0. Isso significa que qualquer loop de linha ou coluna deve levar em conta a diferença de um a menos, que é uma fonte comum de erros de tempo de execução e bugs de truncamento de dados.

Qual Solução Oferece Melhor Experiência para o Desenvolvedor?

Ao avaliar essas abordagens para uso em produção, vários fatores favorecem o IronXL como a solução preferida:

Simplicidade de Implantação: IronXL é instalado via um único pacote NuGet, enquanto Interop requer configurações complexas de ambiente. Isso é importante quando seu programa precisa processar um arquivo XLSX em um servidor de build ou função em nuvem onde não há sessão de usuário.

Manutenibilidade do Código: Ler uma tabela de dados através do IronXL mantém o código curto e legível. Contagens de linhas e colunas estão disponíveis como propriedades de primeira classe. Com Interop, você calcula limites superiores em arrays COM indexados a partir de 1 e atribui valores Object vinculados tardiamente manualmente.

Flexibilidade de Formato: Além dos formatos padrão de planilhas Excel como XLSX, IronXL suporta nativamente a análise CSV, o que é útil quando dados de teste chegam em múltiplos formatos. A biblioteca também pode criar novos arquivos de planilha e gravar valores de volta nas células com igual simplicidade. Veja o guia de formatos IronXL para uma lista completa.

Tratamento de Erros: Padrões de exceção padrão do .NET se aplicam ao IronXL, tornando a recuperação de erros direta. Exceções baseadas em COM requerem lógica de tratamento adicional e podem deixar instâncias do Excel rodando se não forem gerenciadas adequadamente.

Suporte a Várias Plataformas: IronXL roda em Linux e macOS via .NET 6 e versões posteriores. Interop é apenas para Windows porque depende do subsistema COM Win32.

Compromissos de Desempenho e Manutenção para Leitura de Arrays em VB.NET
Critério IronXL Interoperabilidade Microsoft
Linhas de código para leitura básica de array ~20 ~40+
Limpeza manual de COM necessária Não Sim
Funciona sem Excel instalado Sim Não
Roda em contêineres Docker / pipelines de CI Sim Não
Convenção de indexação de array Baseado em 0 (padrão .NET) Baseado em 1 (padrão COM)

Como Trabalhar com Intervalos Dinâmicos de Excel em VB.NET?

Planilhas de produção raramente têm um número fixo de linhas. IronXL fornece a propriedade UsedRange em cada planilha, que retorna o retângulo delimitador de todas as células não vazias. Você pode usar isso em vez de uma string de intervalo codificada.

Imports IronXL

Module DynamicRangeExample
    Sub Main()
        Dim workbook As WorkBook = WorkBook.Load("DynamicData.xlsx")
        Dim sheet As WorkSheet = workbook.DefaultWorkSheet

        ' Get the bounding range of all populated cells
        Dim usedRange As IronXl.Range = sheet.UsedRange

        Dim rowCount As Integer = usedRange.Rows.Count
        Dim colCount As Integer = usedRange.Columns.Count
        Dim dynamicArray(rowCount - 1, colCount - 1) As String

        Dim rowIndex As Integer = 0
        For Each row As RangeRow In usedRange.Rows
            Dim colIndex As Integer = 0
            For Each cell As Cell In row
                dynamicArray(rowIndex, colIndex) = cell.StringValue
                colIndex += 1
            Next
            rowIndex += 1
        Next

        Console.WriteLine($"Loaded {rowCount} rows x {colCount} columns from UsedRange.")
    End Sub
End Module
Imports IronXL

Module DynamicRangeExample
    Sub Main()
        Dim workbook As WorkBook = WorkBook.Load("DynamicData.xlsx")
        Dim sheet As WorkSheet = workbook.DefaultWorkSheet

        ' Get the bounding range of all populated cells
        Dim usedRange As IronXl.Range = sheet.UsedRange

        Dim rowCount As Integer = usedRange.Rows.Count
        Dim colCount As Integer = usedRange.Columns.Count
        Dim dynamicArray(rowCount - 1, colCount - 1) As String

        Dim rowIndex As Integer = 0
        For Each row As RangeRow In usedRange.Rows
            Dim colIndex As Integer = 0
            For Each cell As Cell In row
                dynamicArray(rowIndex, colIndex) = cell.StringValue
                colIndex += 1
            Next
            rowIndex += 1
        Next

        Console.WriteLine($"Loaded {rowCount} rows x {colCount} columns from UsedRange.")
    End Sub
End Module
$vbLabelText   $csharpLabel

Como Filtrar e Validar Dados de Array Após Carregamento?

Após popular o array, passos comuns de pós-processamento incluem:

  • Pular linhas de cabeçalho: Inicie o loop de exibição no índice 1 em vez de 0 para omitir cabeçalhos de coluna.
  • Trim espaços em branco: Chame .Trim() em cell.StringValue para remover espaços à esquerda e à direita copiados da planilha.
  • Tratar células nulas: IronXL retorna uma string vazia para células em branco, então verificações de nulos são desnecessárias na maioria dos casos.
  • Validar intervalos numéricos: Após carregar os números, aplique uma verificação de intervalo antes de armazenar para capturar células que contêm valores substitutos como -1 ou 9999.

Para conjuntos de dados maiores, considere usar List(Of T) ou uma classe fortemente tipada em vez de um array bidimensional bruto. Carregar dados em objetos tipados torna o código subsequente mais fácil de ler e testar. A referência ao modelo de objetos IronXL documenta todas as propriedades de células disponíveis e métodos de planilha.

Como Exportar um Array VB.NET de Volta para o Excel?

IronXL suporta a gravação de dados de array de volta em uma planilha com a mesma API usada para leitura. Isso é útil para cenários onde você transforma os dados na memória e precisa salvar o resultado como um novo arquivo Excel.

Imports IronXL

Module WriteArrayToExcel
    Sub Main()
        ' Create a new workbook and worksheet
        Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
        Dim sheet As WorkSheet = workbook.CreateWorkSheet("Results")

        Dim outputArray(,) As String = {
            {"Region", "Q1", "Q2", "Q3"},
            {"Nãorth", "12500", "14200", "15800"},
            {"South", "9800", "10500", "11300"},
            {"East", "8200", "9100", "9900"}
        }

        ' Write the array contents to the worksheet cell by cell
        For i As Integer = 0 To outputArray.GetUpperBound(0)
            For j As Integer = 0 To outputArray.GetUpperBound(1)
                Dim cellAddress As String = IronXl.ExcelAddress.ToAddress(i, j)
                sheet(cellAddress).Value = outputArray(i, j)
            Next
        Next

        workbook.SaveAs("Output.xlsx")
        Console.WriteLine("Workbook saved as Output.xlsx")
    End Sub
End Module
Imports IronXL

Module WriteArrayToExcel
    Sub Main()
        ' Create a new workbook and worksheet
        Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
        Dim sheet As WorkSheet = workbook.CreateWorkSheet("Results")

        Dim outputArray(,) As String = {
            {"Region", "Q1", "Q2", "Q3"},
            {"Nãorth", "12500", "14200", "15800"},
            {"South", "9800", "10500", "11300"},
            {"East", "8200", "9100", "9900"}
        }

        ' Write the array contents to the worksheet cell by cell
        For i As Integer = 0 To outputArray.GetUpperBound(0)
            For j As Integer = 0 To outputArray.GetUpperBound(1)
                Dim cellAddress As String = IronXl.ExcelAddress.ToAddress(i, j)
                sheet(cellAddress).Value = outputArray(i, j)
            Next
        Next

        workbook.SaveAs("Output.xlsx")
        Console.WriteLine("Workbook saved as Output.xlsx")
    End Sub
End Module
$vbLabelText   $csharpLabel

O auxiliar ExcelAddress.ToAddress(row, column) converte coordenadas inteiras baseadas em zero para strings de notação A1. Isso mantém o loop de escrita limpo e evita calcular manualmente os endereços das células. Revise o tutorial de escrita IronXL para mais padrões, incluindo injeção de fórmulas e aplicação de estilos.

Como Ler Múltiplas Planilhas em Arrays Separados?

Alguns livros armazenam dados em várias folhas -- por exemplo, uma folha por mês ou por região. IronXL expõe todas as planilhas através de workbook.WorkSheets, que você pode iterar para carregar cada planilha em seu próprio array.

Imports IronXL

Module MultiSheetArrayLoader
    Sub Main()
        Dim workbook As WorkBook = WorkBook.Load("AnnualReport.xlsx")

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

            Dim dataRange As IronXl.Range = sheet.UsedRange
            Dim rowCount As Integer = dataRange.Rows.Count
            Dim colCount As Integer = dataRange.Columns.Count
            Dim sheetArray(rowCount - 1, colCount - 1) As String

            Dim rowIndex As Integer = 0
            For Each row As RangeRow In dataRange.Rows
                Dim colIndex As Integer = 0
                For Each cell As Cell In row
                    sheetArray(rowIndex, colIndex) = cell.StringValue
                    colIndex += 1
                Next
                rowIndex += 1
            Next

            Console.WriteLine($"  Loaded {rowCount} rows x {colCount} columns.")
        Next
    End Sub
End Module
Imports IronXL

Module MultiSheetArrayLoader
    Sub Main()
        Dim workbook As WorkBook = WorkBook.Load("AnnualReport.xlsx")

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

            Dim dataRange As IronXl.Range = sheet.UsedRange
            Dim rowCount As Integer = dataRange.Rows.Count
            Dim colCount As Integer = dataRange.Columns.Count
            Dim sheetArray(rowCount - 1, colCount - 1) As String

            Dim rowIndex As Integer = 0
            For Each row As RangeRow In dataRange.Rows
                Dim colIndex As Integer = 0
                For Each cell As Cell In row
                    sheetArray(rowIndex, colIndex) = cell.StringValue
                    colIndex += 1
                Next
                rowIndex += 1
            Next

            Console.WriteLine($"  Loaded {rowCount} rows x {colCount} columns.")
        Next
    End Sub
End Module
$vbLabelText   $csharpLabel

Compreendendo a Navegação de Planilhas

A coleção workbook.WorkSheets é indexada a partir de zero e suporta tanto For Each quanto acesso indexado. Use sheet.Name para identificar planilhas programaticamente e ramificar a lógica com base nos nomes de planilhas conhecidos. O guia de planilhas IronXL cobre seleção de intervalos, intervalos nomeados e detecção de intervalos dinâmicos em detalhe.

Para pastas de trabalho com dezenas de planilhas, filtre por nome antes de carregar para evitar processar planilhas irrelevantes e desperdiçar memória.

O que os desenvolvedores devem saber sobre o formato Interop Array?

A abordagem Interop retorna dados de células como um array Object(,) usando indexação baseada em 1 do COM. O primeiro elemento na primeira linha está em values(1, 1), não values(0, 0). Esta é uma fonte frequente de erros de um a menos.

Uma preocupação adicional é o tratamento de nulos: Interop retorna Nãothing para células vazias. Chamar .ToString() em uma referência nula lança um NullReferenceException em tempo de execução. Você deve adicionar uma proteção contra nulos em cada acesso de célula:

If values(i, j) IsNãot Nãothing Then
    line &= values(i, j).ToString() & vbTab
End If
If values(i, j) IsNãot Nãothing Then
    line &= values(i, j).ToString() & vbTab
End If
$vbLabelText   $csharpLabel

IronXL elimina este problema retornando uma string vazia para células em branco, o que significa que o código do loop funciona sem proteções adicionais.

Para informações autorizadas sobre o Modelo de Objeto do Excel usado pelo Interop, consulte a referência VBA do Microsoft Excel e a documentação Interop do Office no MSDN.

Quais são os seus próximos passos?

Ler dados do Excel em arrays é uma das tarefas mais comuns de planilhas no .NET, e o IronXL torna a implementação direta. Para dar o próximo passo:

VB .NET Ler Arquivo Excel Em Array: Comparação IronXL vs Interoperabilidade Microsoft: Imagem 2 - saída IronXL

Tanto o IronXL quanto o Interoperabilidade com o Microsoft Office podem ler dados do Excel em arrays, mas o IronXL oferece uma experiência de desenvolvedor superior através de sua arquitetura independente do Office, API mais limpa e opções flexíveis de implantação. A biblioteca remove pontos problemáticos comuns, como gerenciamento de objetos COM e dependências do sistema, enquanto fornece acesso a recursos avançados para automação de planilhas.

Explore todas as capacidades do IronXL com projetos de exemplo, recursos e documentação no hub de documentação do IronXL. Para aplicações empresariais, as opções de licenciamento do IronXL oferecem termos flexíveis para se adequar a qualquer escopo de projeto.

Perguntas frequentes

Qual a melhor maneira de ler arquivos do Excel e armazená-los em matrizes usando VB.NET?

A leitura de arquivos Excel em arrays no VB.NET pode ser feita de forma eficaz usando o IronXL ou o Microsoft Office Interop. O IronXL oferece uma abordagem simplificada e eficiente, eliminando a necessidade de instalação do Microsoft Excel e reduzindo a complexidade do código.

Como o IronXL se compara ao Microsoft Office Interop na leitura de arquivos do Excel?

O IronXL oferece um método mais ágil e eficiente para ler arquivos Excel e convertê-los em matrizes, em comparação com o Microsoft Office Interop. Ele não exige que o Excel esteja instalado no servidor e lida com a manipulação de arquivos Excel com menos sobrecarga.

Posso manipular dados do Excel sem instalar o Microsoft Excel?

Sim, o IronXL permite manipular dados do Excel sem a necessidade de instalar o Microsoft Excel. Isso o torna uma ótima opção para ambientes de servidor onde a instalação do Excel não é viável.

Por que devo considerar o uso do IronXL para operações do Excel em VB.NET?

O IronXL simplifica as operações com o Excel ao fornecer uma API intuitiva que lida com diversos formatos de arquivo do Excel. Isso garante um desempenho mais rápido e uma implantação mais fácil, especialmente em ambientes onde o Microsoft Excel não pode ser instalado.

O IronXL é adequado para lidar com grandes conjuntos de dados do Excel em VB.NET?

Sim, o IronXL é otimizado para desempenho e pode lidar com eficiência com grandes conjuntos de dados do Excel, proporcionando extração e manipulação de dados rápidas.

Quais são os exemplos de código disponíveis para ler arquivos do Excel e armazená-los em matrizes usando VB.NET?

O guia fornece exemplos de código funcionais para IronXL e Microsoft Office Interop, demonstrando como ler arquivos do Excel em matrizes de forma eficiente em VB.NET.

O IronXL suporta diferentes formatos de arquivo do Excel?

O IronXL suporta uma ampla variedade de formatos de arquivo do Excel, incluindo XLSX, XLS, CSV e muitos outros, tornando-o versátil para diversas necessidades de processamento de dados.

Quais são as vantagens de usar o IronXL em vez do Microsoft Office Interop?

IronXL é mais fácil de usar, não requer a instalação do Excel e oferece melhor desempenho. Ele simplifica o código e reduz possíveis erros associados às interações COM no Microsoft Office Interop.

Como o IronXL lida com matrizes bidimensionais de forma diferente do Microsoft Interop?

O IronXL oferece métodos diretos para converter dados do Excel em matrizes bidimensionais, garantindo uma abordagem mais eficiente e direta em comparação com a configuração mais complexa exigida pelo Microsoft Interop.

Quais são as melhores práticas recomendadas para ler arquivos do Excel e convertê-los em matrizes?

As melhores práticas incluem escolher a ferramenta certa para o seu ambiente, como o IronXL, pela sua facilidade de uso e desempenho, e garantir uma estrutura de código eficiente para gerenciar a memória e o poder de processamento de forma eficaz.

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