Ícono de mensaje
Saltar al pie de página
  1. Iron Software
  2. Blog de IronXL
  3. Comparar con Otros Componentes
  4. Vb Net Leer matriz de Excel
COMPARAR CON OTROS COMPONENTES

VB .NET: Leer un archivo de Excel en una matriz: IronXL vs. Microsoft Interop

Jordi Bardia
Jordi Bardia
Actualizado:

Para leer datos de Excel en matrices en VB .NET es necesario cargar un libro, seleccionar una hoja de cálculo, iterar filas y columnas y almacenar cada valor de celda en una matriz bidimensional. Con IronXL, puedes lograr esto en pocas líneas sin instalar Microsoft Office. Instala el paquete NuGet , llama a WorkBook.Load, obtén un Range y, luego, repite su colección Rows para rellenar la matriz.

Comience su prueba gratuita para explorar cómo IronXL simplifica la automatización de Excel en sus proyectos de Visual Studio.

¿Cómo se comparan estas soluciones a simple vista?

IronXL vs Interop de Microsoft Office: Comparación de características para operaciones de matriz en VB .NET
Función IronXL Interop de Microsoft Office
Se requiere instalación de oficina No Sí
instalación de NuGet Sí, un paquete No -- Referencia COM
Compatibilidad con entornos de servidor/CI Sí Limitado
Gestión del ciclo de vida de los objetos COM No requerido Requerido
Formatos compatibles XLSX, XLS, CSV, TSV, JSON XLSX, XLS (solo Excel)
API de tipo seguro Sí Parcial - COM de enlace tardío
Compatibilidad con Linux y macOS Sí (.NET 6+) No
Estilo de manejo de excepciones Excepciones estándar de .NET Excepciones COM + limpieza manual

¿Cómo instalar IronXL para proyectos VB .NET ?

La forma más rápida de agregar IronXL a cualquier proyecto .NET es a través del Administrador de paquetes NuGet . Abra la consola del gestor de paquetes en Visual Studio y ejecute:

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

Alternativamente, utilice la CLI de .NET :

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

Después de la instalación, agregue Imports IronXL en la parte superior de su módulo VB .NET . No se necesita instalar Office: IronXL lee y escribe archivos Excel completamente a través de su propio motor de análisis.

Para proyectos que apuntan a marcos más antiguos o requieren una fijación de versión específica, la página NuGet de IronXL enumera todas las versiones publicadas. La documentación de IronXL proporciona guías de instalación para Visual Studio 2019, 2022 y la CLI de .NET .

¿Cómo pueden los desarrolladores leer datos de Excel en matrices utilizando IronXL?

IronXL proporciona una API limpia para abrir libros de trabajo, seleccionar rangos e iterar valores de celdas sin necesidad de una instalación local de Office. El método WorkBook.Load acepta una ruta de archivo y devuelve un objeto WorkBook que expone todas las hojas de trabajo.

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

Comprensión de los objetos WorkBook y WorkSheet

WorkBook.Load admite archivos XLSX, XLS, CSV y TSV. Una vez cargado, workbook.DefaultWorkSheet devuelve la primera hoja. También puede acceder a las hojas por nombre con workbook.GetWorkSheet("Sheet1") o por índice con workbook.WorkSheets(0).

La llamada GetRange("A1:D5") devuelve un IronXl.Range que expone las colecciones Rows y Columns. Cada RangeRow itera objetos Cell y cell.StringValue devuelve la cadena de visualización independientemente del tipo de celda subyacente.

¿Cómo manejar los valores de celdas tipificados?

Las células IronXL exponen propiedades tipificadas junto con StringValue:

  • cell.IntValue -- analiza la celda como un entero
  • cell.DoubleValue -- analiza la celda como doble
  • cell.DateTimeValue -- analiza celdas con formato de fecha
  • cell.IsFormula -- indica si la celda contiene una fórmula

Para datos financieros, declare la matriz como Double y asigne cell.DoubleValue directamente. Esto evita conversiones de cadenas a números durante el procesamiento posterior.

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

Resultado

VB .NET Leer archivo de Excel en una matriz: Comparación de interoperabilidad de IronXL frente a Microsoft: Imagen 1: IronXL frente a Office Excel para realizar la lectura de un archivo de Excel en una matriz de VB .NET

Este ejemplo de código demuestra la API intuitiva de IronXL. El método WorkBook.Load abre el archivo Excel directamente desde la carpeta designada, mientras que el objeto Range proporciona acceso a regiones de celdas específicas dentro de la hoja de cálculo de Excel. A diferencia de las macros VBA heredadas, este enfoque es totalmente seguro y está integrado en el ecosistema .NET.

Empiece con IronXL ahora.
green arrow pointer

¿Cuál es el enfoque tradicional de interoperabilidad de Microsoft Office?

Interop de Microsoft Office se basa en la automatización COM para conectarse con una instancia de aplicación Excel. Para configurar esto en Visual Studio, vaya al menú Proyecto, seleccione "Agregar referencia" y busque la Biblioteca de objetos de Microsoft Excel en la pestaña COM. Debe existir una instalación local de Excel en cada máquina que ejecute el 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 = Nothing
        Dim sheet As Worksheet = Nothing

        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 IsNot Nothing Then
                System.Runtime.InteropServices.Marshal.ReleaseComObject(sheet)
            End If
            If workbook IsNot Nothing 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 = Nothing
        Dim sheet As Worksheet = Nothing

        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 IsNot Nothing Then
                System.Runtime.InteropServices.Marshal.ReleaseComObject(sheet)
            End If
            If workbook IsNot Nothing 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 qué es importante la gestión de objetos COM?

El enfoque de interoperabilidad requiere una atención cuidadosa a la gestión del ciclo de vida de los objetos COM. Cada objeto devuelto por la aplicación Excel (libros, hojas de cálculo, rangos y celdas) contiene un puntero COM contado por referencia. Si no se llama a Marshal.ReleaseComObject en cada uno de estos objetos, queda un proceso EXCEL.EXE ejecutándose silenciosamente en segundo plano.

En los servidores, los procesos huérfanos se acumulan con el tiempo y eventualmente agotan la memoria o los controladores de archivos disponibles. El patrón Try...Finally mencionado anteriormente es el enfoque mínimo seguro, pero muchas bases de código empresariales agregan una utilidad de limpieza COM dedicada para manejar gráficos de objetos anidados.

La convención de indexación de matrices de interoperabilidad también difiere de las matrices VB .NET estándar: las matrices basadas en COM comienzan en el índice 1, no 0. Esto significa que cualquier bucle de fila o columna debe tener en cuenta la diferencia de un valor, que es una fuente común de errores de tiempo de ejecución y errores de truncamiento de datos.

¿Qué solución ofrece una mejor experiencia para los desarrolladores?

Al evaluar estos enfoques para su uso en producción, varios factores favorecen a IronXL como la solución preferida:

Simplicidad de implementación: IronXL se instala a través de un único paquete NuGet , mientras que Interop requiere configuraciones de entorno complejas. Esto es importante cuando su programa necesita procesar un archivo XLSX en un servidor de compilación o una función en la nube donde no existe ninguna sesión de usuario.

Mantenibilidad del código: leer una tabla de datos a través de IronXL mantiene el código breve y legible. Los recuentos de filas y columnas están disponibles como propiedades de primera clase. Con Interop, usted calcula límites superiores en matrices COM indexadas en 1 y convierte valores Object de límite tardío manualmente.

Flexibilidad de formato : más allá de los formatos de libros de Excel estándar como XLSX, IronXL admite de forma nativa el análisis de CSV, lo que resulta útil cuando los datos de prueba llegan en múltiples formatos. La biblioteca también puede crear nuevos archivos de libros de trabajo y escribir valores en las celdas con la misma simplicidad. Consulte la guía de formato IronXL para obtener una lista completa.

Manejo de errores : los patrones de excepción estándar de .NET se aplican a IronXL, lo que hace que la recuperación de errores sea sencilla. Las excepciones basadas en COM requieren una lógica de manejo adicional y pueden dejar las instancias de Excel en ejecución si no se administran adecuadamente.

Compatibilidad multiplataforma : IronXL se ejecuta en Linux y macOS a través de .NET 6 y versiones posteriores. La interoperabilidad es exclusiva de Windows porque depende del subsistema COM Win32.

Compensaciones de rendimiento y mantenimiento para la lectura de matrices en VB .NET
Criterio IronXL Microsoft Interop
Líneas de código para la lectura básica de una matriz ~20 ~40+
Se requiere limpieza manual de COM No Sí
Funciona sin Excel instalado Sí No
Se ejecuta en pipelines de Docker/CI Sí No
Convención de indexación de matrices Basado en 0 (.NET Standard) Basado en 1 (estándar COM)

¿Cómo trabajar con rangos dinámicos de Excel en VB .NET?

Las hojas de cálculo de producción rara vez tienen un número fijo de filas. IronXL proporciona la propiedad UsedRange en cada hoja de cálculo, que devuelve el rectángulo delimitador de todas las celdas no vacías. Puede utilizar esto en lugar de una cadena de rango 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

¿Cómo filtrar y validar datos de una matriz después de cargarlos?

Después de completar la matriz, los pasos comunes de posprocesamiento incluyen:

  • Omitir filas de encabezado : inicia el bucle de visualización en el índice 1 en lugar de 0 para omitir los encabezados de columna.
  • Recortar espacios en blanco : llame a .Trim() en cell.StringValue para eliminar los espacios iniciales y finales copiados de la hoja de cálculo.
  • Manejar celdas nulas : IronXL devuelve una cadena vacía para las celdas en blanco, por lo que las comprobaciones de celdas nulas son innecesarias en la mayoría de los casos.
  • Validar rangos numéricos : después de cargar valores dobles, aplique una verificación de rango antes de almacenar para detectar celdas que contengan valores de marcador de posición como -1 o 9999.

Para conjuntos de datos más grandes, considere usar List(Of T) o una clase fuertemente tipada en lugar de una matriz bidimensional sin formato. Cargar datos en objetos tipificados facilita la lectura y la prueba del código posterior. La referencia del modelo de objetos IronXL documenta todas las propiedades de celda y los métodos de hoja de cálculo disponibles.

¿Cómo exportar una matriz VB .NET a Excel?

IronXL admite la escritura de datos de una matriz en una hoja de cálculo con la misma API utilizada para la lectura. Esto es útil para escenarios en los que transforma los datos en la memoria y necesita guardar el resultado como un nuevo archivo de 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"},
            {"North", "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"},
            {"North", "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

El asistente ExcelAddress.ToAddress(row, column) convierte coordenadas enteras basadas en cero en cadenas de notación A1. Esto mantiene limpio el bucle de escritura y evita calcular manualmente las direcciones de celda. Revise el tutorial de escritura de IronXL para obtener más patrones, incluida la inyección de fórmulas y la aplicación de estilos.

¿Cómo leer varias hojas de cálculo en matrices independientes?

Algunos libros de trabajo almacenan datos en varias hojas: por ejemplo, una hoja por mes o por región. IronXL expone todas las hojas a través de workbook.WorkSheets, que puede iterar para cargar cada hoja en su propia matriz.

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

Comprender la navegación en hojas

La colección workbook.WorkSheets tiene índice cero y admite tanto el acceso For Each como el acceso indexado. Utilice sheet.Name para identificar hojas mediante programación y bifurcar la lógica en función de los nombres de hojas conocidos. La guía de la hoja de trabajo IronXL cubre la selección de rango, los rangos nombrados y la detección de rango dinámico en detalle.

Para libros de trabajo con docenas de hojas, filtre por nombre antes de cargar para evitar procesar hojas irrelevantes y desperdiciar memoria.

¿Qué deben saber los desarrolladores sobre el formato de matriz de interoperabilidad?

El enfoque Interop devuelve datos de celda como una matriz Object(,) utilizando la indexación basada en 1 de COM. El primer elemento de la primera fila está en values(1, 1), no en values(0, 0). Esta es una fuente frecuente de errores de un dígito.

Una preocupación adicional es el manejo de valores nulos: Interop devuelve Nothing para celdas vacías. Llamar a .ToString() en una referencia nula genera un NullReferenceException en tiempo de ejecución. Debe agregar una protección nula en cada acceso a la celda:

If values(i, j) IsNot Nothing Then
    line &= values(i, j).ToString() & vbTab
End If
If values(i, j) IsNot Nothing Then
    line &= values(i, j).ToString() & vbTab
End If
$vbLabelText   $csharpLabel

IronXL elimina este problema al devolver una cadena vacía para las celdas en blanco, lo que significa que el código de bucle funciona sin ninguna protección adicional.

Para obtener información autorizada sobre el modelo de objetos de Excel utilizado por Interop, consulte la referencia de VBA de Microsoft Excel y la documentación de interoperabilidad de MSDN Office .

¿Cuales son tus próximos pasos?

Leer datos de Excel en matrices es una de las tareas más comunes de las hojas de cálculo .NET , y IronXL hace que la implementación sea sencilla. Para dar el siguiente paso:

  • Descargue IronXL : instálelo mediante NuGet (Install-Package IronXl.Excel) y siga la guía de inicio .
  • Explore el soporte de formatos : IronXL lee y escribe XLSX, XLS, CSV, TSV y JSON. Consulte la página de formatos admitidos para obtener más detalles.
  • Pruebe funciones avanzadas : ordene rangos, aplique fórmulas, establezca estilos de celda y genere gráficos, todo sin tener Excel instalado. Revise la descripción general de las características de IronXL para obtener la lista completa de capacidades.
  • Explorar ejemplos de código : la biblioteca de ejemplos de código IronXL proporciona fragmentos de copiar y pegar para docenas de tareas comunes de hojas de cálculo.
  • Revisar licencias : para implementaciones de producción, las licencias de IronXL ofrecen niveles de desarrollador, equipo y OEM.

VB .NET Leer archivo de Excel en una matriz: Comparación de interoperabilidad de IronXL vs Microsoft: Imagen 2 - Salida de IronXL

Tanto IronXL como Interop de Microsoft Office pueden leer datos de Excel en matrices, pero IronXL ofrece una experiencia de desarrollo superior a través de su arquitectura independiente de Office, una API más limpia y opciones de implementación flexibles. La biblioteca elimina problemas comunes como la gestión de objetos COM y las dependencias del sistema al tiempo que proporciona acceso a funciones avanzadas para la automatización de hojas de cálculo.

Explore todas las capacidades de IronXL con proyectos de muestra, recursos y documentación en el centro de documentación de IronXL . Para aplicaciones empresariales, las opciones de licencia de IronXL ofrecen términos flexibles que se adaptan a cualquier alcance de proyecto.

Preguntas Frecuentes

¿Cuál es la mejor manera de leer archivos de Excel en matrices usando VB.NET?

La lectura de archivos de Excel en matrices en VB.NET se puede realizar eficazmente con IronXL o Microsoft Office Interop. IronXL ofrece un enfoque simplificado y eficiente, eliminando la necesidad de instalar Microsoft Excel y reduciendo la complejidad del código.

¿Cómo se compara IronXL con Microsoft Office Interop para leer archivos Excel?

IronXL ofrece un método más ágil y rápido para leer archivos de Excel en matrices en comparación con Microsoft Office Interop. No requiere la instalación de Excel en el servidor y gestiona la manipulación de archivos de Excel con menos sobrecarga.

¿Puedo manipular datos de Excel sin instalar Microsoft Excel?

Sí, usar IronXL permite manipular datos de Excel sin necesidad de tener instalado Microsoft Excel. Esto lo convierte en una excelente opción para entornos de servidor donde no es posible instalar Excel.

¿Por qué debería considerar el uso de IronXL para operaciones de Excel en VB.NET?

IronXL simplifica las operaciones de Excel al proporcionar una API intuitiva que gestiona diversos formatos de archivo. Garantiza un rendimiento más rápido y una implementación más sencilla, especialmente en entornos donde no se puede instalar Microsoft Excel.

¿IronXL es adecuado para manejar grandes conjuntos de datos de Excel en VB.NET?

Sí, IronXL está optimizado para el rendimiento y puede manejar de manera eficiente grandes conjuntos de datos de Excel, proporcionando una rápida extracción y manipulación de datos.

¿Cuáles son los ejemplos de código disponibles para leer archivos de Excel en matrices usando VB.NET?

La guía proporciona ejemplos de código funcionales tanto para IronXL como para Microsoft Office Interop y demuestra cómo leer archivos de Excel en matrices de manera eficaz en VB.NET.

¿IronXL soporta diferentes formatos de archivo Excel?

IronXL admite una amplia gama de formatos de archivos de Excel, incluidos XLSX, XLS, CSV y más, lo que lo hace versátil para diversas necesidades de procesamiento de datos.

¿Cuáles son los beneficios de utilizar IronXL en lugar de Microsoft Office Interop?

IronXL es más fácil de usar, no requiere la instalación de Excel y ofrece un mejor rendimiento. Simplifica el código y reduce los posibles errores asociados con las interacciones COM en la interoperabilidad de Microsoft Office.

¿En qué sentido IronXL gestiona las matrices bidimensionales de forma diferente a Microsoft Interop?

IronXL proporciona métodos directos para convertir datos de Excel en matrices bidimensionales, lo que garantiza un enfoque más eficiente y sencillo en comparación con la configuración más compleja requerida con Microsoft Interop.

¿Cuáles son las mejores prácticas recomendadas para leer archivos de Excel en matrices?

Las mejores prácticas incluyen elegir la herramienta adecuada para su entorno, como IronXL por su facilidad de uso y rendimiento, y garantizar una estructura de código eficiente para administrar la memoria y la potencia de procesamiento de manera eficaz.

Jordi Bardia
Jordi Bardia
  Chatea con el equipo de ingeniería ahora
Ingeniero de Software
Jordi es más competente en Python, C# y C++. Cuando no está aprovechando sus habilidades en Iron Software, está programando juegos. Compartiendo responsabilidades para pruebas de productos, desarrollo de productos e investigación, Jordi agrega un valor inmenso a la mejora continua del producto. La experiencia variada lo mantiene ...
Leer más

Artículos Relacionados

Prueba de 30 días → Producto completo. Sin límites. Sin tarjeta. Prueba gratis

Iron Support Team

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