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

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

¿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

Alternativamente, utilice la CLI de .NET :

dotnet add package IronXL.Excel

dotnet add package IronXL.Excel

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

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

IRON VB CONVERTER ERROR developers@ironsoftware.com

Resultado

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.

Comience gratis

¿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

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

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

¿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

IRON VB CONVERTER ERROR developers@ironsoftware.com

¿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

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

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

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

¿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

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

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.

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.