.NET: Excel-Datei in ein Array einlesen: IronXL vs. Microsoft Interop

Wie schneiden diese Lösungen im direkten Vergleich ab?

Wie installiert man IronXL für VB .NET -Projekte?

Der schnellste Weg, IronXL zu einem beliebigen .NET Projekt hinzuzufügen, ist über den NuGet Paketmanager. Öffnen Sie die Paketmanager-Konsole in Visual Studio und führen Sie den Befehl aus:

Install-Package IronXL.Excel

Alternativ können Sie die .NET -Befehlszeilenschnittstelle verwenden:

dotnet add package IronXL.Excel

Nach der Installation fügen Sie Imports IronXL am Anfang Ihres VB.NET-Moduls hinzu. Es ist keine Office-Installation erforderlich – IronXL liest und schreibt Excel-Dateien ausschließlich über seine eigene Parsing-Engine.

Für Projekte, die auf ältere Frameworks abzielen oder eine bestimmte Versionsfestlegung erfordern, listet die IronXL NuGet Seite alle veröffentlichten Versionen auf. Die IronXL Dokumentation enthält Installationsanleitungen für Visual Studio 2019, 2022 und die .NET CLI.

Wie können Entwickler Excel-Daten mithilfe von IronXL in Arrays einlesen?

IronXL bietet eine übersichtliche API zum Öffnen von Arbeitsmappen, Auswählen von Bereichen und Durchlaufen von Zellwerten, ohne dass eine lokale Office-Installation erforderlich ist. Die WorkBook.Load-Methode akzeptiert einen Dateipfad und gibt ein WorkBook-Objekt zurück, das alle Arbeitsblätter bereitstellt.

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

Ausgabe

Dieses Codebeispiel demonstriert die intuitive API von IronXL. Die WorkBook.Load-Methode öffnet die Excel-Datei direkt aus Ihrem angegebenen Ordner, während das Range-Objekt Zugriff auf bestimmte Zellbereiche innerhalb der Excel-Tabelle bietet. Im Gegensatz zu herkömmlichen VBA-Makros ist dieser Ansatz vollständig typsicher und in das .NET Ökosystem integriert.

Starten Sie jetzt mit IronXL.

Jetzt kostenlos starten

Was ist der traditionelle Microsoft Office Interop-Ansatz?

Microsoft Office Interop nutzt COM-Automatisierung, um eine Verbindung zu einer Excel-Anwendungsinstanz herzustellen. Um dies in Visual Studio einzurichten, navigieren Sie zum Menü "Projekt", wählen Sie "Verweis hinzufügen" und suchen Sie auf der Registerkarte "COM" nach der Microsoft Excel-Objektbibliothek. Auf jedem Rechner, auf dem der Code ausgeführt wird, muss eine lokale Excel-Installation vorhanden sein.

Imports Microsoft.Office.Interop.Excel

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

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

        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 IsNeint Neinthing Then
                System.Runtime.InteropServices.Marshal.ReleaseComObject(sheet)
            End If
            If workbook IsNeint Neinthing 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

Welche Lösung bietet die bessere Entwicklererfahrung?

Bei der Bewertung dieser Ansätze für den Produktionseinsatz sprechen mehrere Faktoren für IronXL als bevorzugte Lösung:

Einfache Bereitstellung: IronXL wird über ein einziges NuGet Paket installiert, während Interop komplexe Umgebungskonfigurationen erfordert. Dies ist relevant, wenn Ihr Programm eine XLSX-Datei auf einem Build-Server oder einer Cloud-Funktion verarbeiten muss, auf der keine Benutzersitzung existiert.

Code-Wartbarkeit: Das Einlesen einer Datentabelle mit IronXL hält den Code kurz und lesbar. Zeilen- und Spaltenanzahlen sind als erstklassige Eigenschaften verfügbar. Mit Interop berechnen Sie obere Grenzen auf 1-indizierten COM-Arrays und werfen manuell spät gebundene Object-Werte.

Formatflexibilität : Neben den Standard-Excel-Arbeitsmappenformaten wie XLSX unterstützt IronXL nativ die CSV-Analyse, was nützlich ist, wenn Testdaten in verschiedenen Formaten vorliegen. Die Bibliothek kann außerdem mit der gleichen Einfachheit neue Arbeitsmappendateien erstellen und Werte wieder in Zellen zurückschreiben. Eine vollständige Liste finden Sie im IronXL -Formatleitfaden .

Fehlerbehandlung : Für IronXL gelten die Standard-Ausnahmemuster von .NET , wodurch die Fehlerbehebung unkompliziert ist. COM-basierte Ausnahmen erfordern zusätzliche Behandlungslogik und können dazu führen, dass Excel-Instanzen weiterlaufen, wenn sie nicht ordnungsgemäß behandelt werden.

Plattformübergreifende Unterstützung : IronXL läuft unter Linux und macOS über .NET 6 und höher. Interop ist nur unter Windows möglich, da es vom Win32 COM-Subsystem abhängt.

Wie arbeitet man mit dynamischen Excel-Bereichen in VB .NET?

Produktionstabellen haben selten eine feste Anzahl von Zeilen. IronXL bietet die UsedRange-Eigenschaft auf jedem Arbeitsblatt, die das Begrenzungsrechteck aller nicht leeren Zellen zurückgibt. Sie können dies anstelle einer fest codierten Bereichszeichenfolge verwenden.

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

Wie exportiert man ein VB .NET Array zurück nach Excel?

IronXL unterstützt das Zurückschreiben von Array-Daten in ein Arbeitsblatt mit derselben API, die zum Lesen verwendet wird. Dies ist nützlich für Szenarien, in denen Sie die Daten im Speicher transformieren und das Ergebnis als neue Excel-Datei speichern müssen.

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"},
            {"Neinrth", "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"},
            {"Neinrth", "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"},
            {"Neinrth", "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

Der ExcelAddress.ToAddress(row, column)-Helfer konvertiert nullbasierte Ganzzahlkoordinaten in A1-Neintation-Strings. Dadurch bleibt die Schreibschleife übersichtlich und die manuelle Berechnung von Zelladressen wird vermieden. Im IronXL -Schreibtutorial finden Sie weitere Muster, darunter Formeleinfügung und Stilanwendung.

Wie liest man mehrere Arbeitsblätter in separate Arrays ein?

Manche Arbeitsmappen speichern Daten über mehrere Tabellenblätter verteilt – zum Beispiel ein Tabellenblatt pro Monat oder pro Region. IronXL stellt alle Blätter über workbook.WorkSheets zur Verfügung, die Sie iterieren können, um jedes Blatt in sein eigenes Array zu laden.

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

Was sollten Entwickler über das Interop-Array-Format wissen?

Der Interop-Ansatz gibt Zellen-Daten als ein Object(,)-Array zurück, welches die 1-basierte Indizierung von COM verwendet. Das erste Element in der ersten Zeile ist bei values(1, 1), nicht bei values(0, 0). Dies ist eine häufige Ursache für Off-by-One-Fehler.

Ein weiteres Anliegen ist die Behandlung von null: Interop gibt Neinthing für leere Zellen zurück. Der Aufruf von .ToString() auf einem null-Verweis löst eine NullReferenceException zur Laufzeit aus. Sie müssen eine null-Sicherung um jeden Zellzugriff hinzufügen:

If values(i, j) IsNeint Neinthing Then
    line &= values(i, j).ToString() & vbTab
End If

If values(i, j) IsNeint Neinthing 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 beseitigt dieses Problem, indem es für leere Zellen eine leere Zeichenkette zurückgibt, was bedeutet, dass der Schleifencode ohne zusätzliche Schutzmechanismen funktioniert.

Für verlässliche Informationen zum von Interop verwendeten Excel-Objektmodell konsultieren Sie bitte die Microsoft Excel VBA-Referenz und die MSDN Office Interop-Dokumentation .

Was sind Ihre nächsten Schritte?

Das Einlesen von Excel-Daten in Arrays ist eine der häufigsten Aufgaben in .NET -Tabellenkalkulationen, und IronXL macht die Implementierung unkompliziert. Um den nächsten Schritt zu gehen:

• IronXL herunterladen: Installation über NuGet (Install-Package IronXL.Excel) und folgen Sie der Einstiegshilfe.
• Formatunterstützung erkunden : IronXL liest und schreibt XLSX, XLS, CSV, TSV und JSON. Weitere Informationen finden Sie auf der Seite "Unterstützte Formate" .
• Probieren Sie die erweiterten Funktionen aus : Sortieren Sie Bereiche, wenden Sie Formeln an, legen Sie Zellstile fest und erstellen Sie Diagramme – alles ohne installiertes Excel. Die vollständige Funktionsübersicht von IronXL finden Sie hier.
• Codebeispiele durchsuchen : Die IronXL Codebeispielbibliothek bietet Code-Snippets zum Kopieren und Einfügen für Dutzende gängiger Tabellenkalkulationsaufgaben.
• Lizenzprüfung : Für Produktionsumgebungen bietet IronXL Lizenzstufen für Entwickler, Teams und OEMs an.

Sowohl IronXL als auch Microsoft Office Interop können Excel-Daten in Arrays einlesen, aber IronXL bietet dank seiner Office-unabhängigen Architektur, der übersichtlicheren API und der flexiblen Bereitstellungsoptionen ein überlegenes Entwicklererlebnis. Die Bibliothek beseitigt häufig auftretende Probleme wie die Verwaltung von COM-Objekten und Systemabhängigkeiten und bietet gleichzeitig Zugriff auf erweiterte Funktionen zur Tabellenkalkulationsautomatisierung.

Entdecken Sie alle Funktionen von IronXL anhand von Beispielprojekten, Ressourcen und Dokumentationen im IronXL Dokumentationsportal . Für Enterprise bietet IronXL flexible Lizenzierungsoptionen , die sich an jeden Projektumfang anpassen lassen.