Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. Iron Software
  2. IronXL Blog
  3. Mit anderen Komponenten vergleichen
  4. VB.NET liest Excel-Array
MIT ANDEREN KOMPONENTEN VERGLEICHEN

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

Jordi Bardia
Jordi Bardia
Aktualisiert:

Das Einlesen von Excel-Daten in Arrays in VB .NET erfordert das Laden einer Arbeitsmappe, das Auswählen eines Arbeitsblatts, das Durchlaufen von Zeilen und Spalten und das Speichern jedes Zellwerts in einem zweidimensionalen Array. Mit IronXL gelingt Ihnen das in wenigen Zeilen Code, ohne Microsoft Office installieren zu müssen. Installieren Sie das NuGet Paket, rufen Sie WorkBook.Load auf, erhalten Sie eine Range-Sammlung und durchlaufen Sie anschließend deren Rows-Sammlung, um Ihr Array zu füllen.

Starten Sie Ihre kostenlose Testversion und entdecken Sie, wie IronXL die Excel-Automatisierung in Ihren Visual Studio-Projekten vereinfacht.

Wie schneiden diese Lösungen im direkten Vergleich ab?

IronXL vs. Microsoft Office Interop – Funktionsvergleich for .NET -Array-Operationen
Merkmal IronXL Microsoft Office Interop
Büroeinrichtung erforderlich Nein Ja
NuGet-Installation Ja – eine Packung Nein – COM-Referenz
Server-/CI-Umgebungsunterstützung Ja Begrenzt
COM-Objektlebenszyklusverwaltung Nicht erforderlich Erforderlich
Unterstützte Formate XLSX, XLS, CSV, TSV, JSON XLSX, XLS (nur Excel)
Typsichere API Ja Teilweise -- spät gebundenes COM
Linux-/macOS-Unterstützung Ja (.NET 6+) Nein
Ausnahmebehandlungsstil Standard- .NET -Ausnahmen COM-Ausnahmen + manuelle Bereinigung

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
Install-Package IronXl.Excel
SHELL

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

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

Nach der Installation fügen Sie Imports IronXL am Anfang Ihres VB .NET Moduls ein. 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 Methode WorkBook.Load akzeptiert einen Dateipfad und gibt ein WorkBook-Objekt zurück, das alle Arbeitsblätter anzeigt.

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

Die Arbeitsmappen- und Arbeitsblattobjekte verstehen

WorkBook.Load unterstützt XLSX-, XLS-, CSV- und TSV-Dateien. Nach dem Laden gibt workbook.DefaultWorkSheet das erste Tabellenblatt zurück. Sie können auch über den Namen mit workbook.GetWorkSheet("Sheet1") oder über den Index mit workbook.WorkSheets(0) auf die Blätter zugreifen.

Der Aufruf GetRange("A1:D5") gibt einen IronXl.Range zurück, der die Sammlungen Rows und Columns zugänglich macht. Jedes RangeRow iteriert über Cell Objekte, und cell.StringValue gibt die Anzeigezeichenfolge unabhängig vom zugrunde liegenden Zelltyp zurück.

Wie geht man mit eingegebenen Zellenwerten um?

IronXL Zellen legen typisierte Eigenschaften neben StringValue offen:

  • cell.IntValue -- interpretiert die Zelle als Ganzzahl
  • cell.DoubleValue -- interpretiert die Zelle als Double
  • cell.DateTimeValue -- analysiert datumsformatierte Zellen
  • cell.IsFormula -- zeigt an, ob die Zelle eine Formel enthält

Für Finanzdaten deklarieren Sie das Array als Double und weisen Sie cell.DoubleValue direkt zu. Dadurch werden Umwandlungen von Zeichenketten in Zahlen bei der nachfolgenden Verarbeitung vermieden.

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

Ausgabe

VB .NET Excel-Datei in ein Array einlesen: IronXL vs. Microsoft Interop Vergleich: Bild 1 - IronXL vs. Office Excel zum Einlesen einer Excel-Datei in ein Array mit VB .NET

Dieses Codebeispiel demonstriert die intuitive API von IronXL. Die Methode WorkBook.Load öffnet die Excel-Datei direkt aus dem von Ihnen angegebenen Ordner, während das Objekt Range 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.
green arrow pointer

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
$vbLabelText   $csharpLabel

Warum ist die COM-Objektverwaltung wichtig?

Der Interop-Ansatz erfordert eine sorgfältige Berücksichtigung des Lebenszyklusmanagements von COM-Objekten. Jedes von der Excel-Anwendung zurückgegebene Objekt – Arbeitsmappen, Arbeitsblätter, Bereiche und Zellen – enthält einen referenzgezählten COM-Zeiger. Wenn der Aufruf von Marshal.ReleaseComObject für jedes dieser Objekte fehlschlägt, läuft ein EXCEL.EXE-Prozess stillschweigend im Hintergrund weiter.

Auf Servern sammeln sich mit der Zeit verwaiste Prozesse an und erschöpfen schließlich den verfügbaren Speicher oder die Dateihandles. Das oben genannte Muster Try...Finally stellt den minimalen sicheren Ansatz dar, aber viele Unternehmenscodebasen fügen ein spezielles COM-Bereinigungsprogramm hinzu, um verschachtelte Objektgraphen zu verarbeiten.

Die Interop-Array-Indexierungskonvention unterscheidet sich ebenfalls von Standard- .NET -Arrays: COM-basierte Arrays beginnen bei Index 1, nicht bei 0. Dies bedeutet, dass jede Zeilen- oder Spaltenschleife den Unterschied von eins berücksichtigen muss, was eine häufige Ursache für Laufzeitfehler und Datenabschneidefehler ist.

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 Schranken für 1-indizierte COM-Arrays und wandeln späte Schrankenwerte manuell um.

Formatflexibilität : Neben den Standard-Excel-Arbeitsmappenformaten wie XLSX unterstützt IronXL nativ die CSV-Analyse, was nützlich ist, wenn Testdaten in mehreren 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.

Leistungs- und Wartungsaspekte beim Lesen von Arrays in .NET
Kriterium IronXL Microsoft Interop
Codezeilen für das einfache Lesen von Arrays ~20 ~40+
Manuelle COM-Bereinigung erforderlich Nein Ja
Funktioniert auch ohne installiertes Excel. Ja Nein
Läuft in Docker-/CI-Pipelines Ja Nein
Konvention zur Array-Indexierung 0-basiert (.NET Standard) 1-basiert (COM-Standard)

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

Produktionstabellen haben selten eine feste Anzahl von Zeilen. IronXL stellt auf jedem Arbeitsblatt die Eigenschaft UsedRange bereit, die das umschließende Rechteck 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
$vbLabelText   $csharpLabel

Wie filtert und validiert man Array-Daten nach dem Laden?

Nach dem Befüllen des Arrays umfassen gängige Nachbearbeitungsschritte Folgendes:

  • Überschriftenzeilen überspringen : Die Anzeigeschleife soll bei Index 1 anstatt bei Index 0 beginnen, um Spaltenüberschriften auszulassen.
  • Leerzeichen entfernen : Rufen Sie .Trim() auf cell.StringValue auf, um führende und nachfolgende Leerzeichen aus der Tabelle zu entfernen.
  • Umgang mit Null-Zellen : IronXL gibt für leere Zellen eine leere Zeichenkette zurück, daher sind Nullprüfungen in den meisten Fällen unnötig.
  • Numerische Bereiche prüfen : Nach dem Laden von Gleitkommazahlen sollte vor dem Speichern eine Bereichsprüfung durchgeführt werden, um Zellen zu erkennen, die Platzhalterwerte wie -1 oder 9999 enthalten.

Bei größeren Datensätzen sollten Sie die Verwendung von List(Of T) oder einer stark typisierten Klasse anstelle eines einfachen zweidimensionalen Arrays in Betracht ziehen. Das Laden von Daten in typisierte Objekte erleichtert das Lesen und Testen des nachfolgenden Codes. Die IronXL Objektmodellreferenz dokumentiert alle verfügbaren Zelleneigenschaften und Arbeitsblattmethoden.

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
$vbLabelText   $csharpLabel

Der ExcelAddress.ToAddress(row, column)-Helper wandelt nullbasierte ganzzahlige Koordinaten in A1-Neintation-Zeichenketten um. 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 Tabellenblätter über workbook.WorkSheets zur Verfügung, die Sie durchlaufen können, um jedes Tabellenblatt in ein 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
$vbLabelText   $csharpLabel

Navigation im Arbeitsblatt verstehen

Die Sammlung workbook.WorkSheets ist nullbasiert und unterstützt sowohl For Each als auch indizierten Zugriff. Verwenden Sie sheet.Name, um Blätter programmatisch zu identifizieren und die Verzweigungslogik auf Basis bekannter Blattnamen zu steuern. Der IronXL Arbeitsblattleitfaden behandelt die Bereicheauswahl, benannte Bereiche und die dynamische Bereichserkennung im Detail.

Bei Arbeitsmappen mit Dutzenden von Tabellenblättern sollten Sie vor dem Laden nach Namen filtern, um die Verarbeitung irrelevanter Tabellenblätter und damit die Verschwendung von Speicherplatz zu vermeiden.

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

Der Interop-Ansatz gibt Zelldaten als Object(,)-Array unter Verwendung der 1-basierten Indizierung von COM zurück. Das erste Element in der ersten Zeile befindet sich bei values(1, 1), nicht bei values(0, 0). Dies ist eine häufige Ursache für Off-by-One-Fehler.

Ein weiteres Problem ist die Behandlung von Nullwerten: Interop gibt für leere Zellen Neinthing zurück. Der Aufruf von .ToString() auf einer Nullreferenz löst zur Laufzeit einen NullReferenceException-Fehler aus. Sie müssen jeden Zellenzugriff mit einer Nullreferenz schützen.

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
$vbLabelText   $csharpLabel

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:

  • Laden Sie IronXL herunter : Installieren Sie es über NuGet (Install-Package IronXl.Excel) und folgen Sie der Kurzanleitung .
  • 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.

VB .NET Excel-Datei in ein Array einlesen: IronXL vs. Microsoft Interop Vergleich: Bild 2 - IronXL -Ausgabe

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 Unternehmensanwendungen bietet IronXL flexible Lizenzierungsoptionen , die sich an jeden Projektumfang anpassen lassen.

Häufig gestellte Fragen

Wie lassen sich Excel-Dateien am besten mit .NET in Arrays einlesen?

Das Einlesen von Excel-Dateien in Arrays in .NET lässt sich effizient mit IronXL oder Microsoft Office Interop realisieren. IronXL bietet einen vereinfachten und effizienten Ansatz, der die Installation von Microsoft Excel überflüssig macht und die Komplexität des Codes reduziert.

Wie schneidet IronXL im Vergleich zu Microsoft Office Interop beim Lesen von Excel-Dateien ab?

IronXL bietet im Vergleich zu Microsoft Office Interop eine effizientere und schnellere Methode zum Einlesen von Excel-Dateien in Arrays. Es erfordert keine Installation von Excel auf dem Server und ermöglicht die Bearbeitung von Excel-Dateien mit geringerem Aufwand.

Kann ich Excel-Daten bearbeiten, ohne Microsoft Excel zu installieren?

Ja, mit IronXL können Sie Excel-Daten bearbeiten, ohne dass Microsoft Excel installiert sein muss. Das macht es zu einer hervorragenden Option für Serverumgebungen, in denen die Installation von Excel nicht möglich ist.

Warum sollte ich IronXL für Excel-Operationen in VB .NET verwenden?

IronXL vereinfacht die Arbeit mit Excel durch eine intuitive API, die verschiedene Excel-Dateiformate unterstützt. Dies gewährleistet eine höhere Leistung und einfachere Bereitstellung, insbesondere in Umgebungen, in denen Microsoft Excel nicht installiert werden kann.

Ist IronXL für die Verarbeitung großer Excel-Datensätze in VB .NET geeignet?

Ja, IronXL ist auf Leistung optimiert und kann große Excel-Datensätze effizient verarbeiten, wodurch eine schnelle Datenextraktion und -manipulation ermöglicht wird.

Welche Codebeispiele gibt es für das Einlesen von Excel-Dateien in Arrays mit VB .NET?

Der Leitfaden enthält funktionierende Codebeispiele sowohl für IronXL als auch für Microsoft Office Interop und zeigt, wie man Excel-Dateien in VB .NET effektiv in Arrays einliest.

Unterstützt IronXL verschiedene Excel-Dateiformate?

IronXL unterstützt eine breite Palette von Excel-Dateiformaten, darunter XLSX, XLS, CSV und mehr, wodurch es vielseitig für verschiedene Datenverarbeitungsanforderungen einsetzbar ist.

Welche Vorteile bietet die Verwendung von IronXL gegenüber Microsoft Office Interop?

IronXL ist benutzerfreundlicher, benötigt kein installiertes Excel und bietet eine bessere Performance. Es vereinfacht den Code und reduziert potenzielle Fehler im Zusammenhang mit COM-Interaktionen in Microsoft Office Interop.

Wie geht IronXL im Vergleich zu Microsoft Interop mit zweidimensionalen Arrays um?

IronXL bietet direkte Methoden zur Konvertierung von Excel-Daten in zweidimensionale Arrays und gewährleistet so einen effizienteren und unkomplizierteren Ansatz im Vergleich zu der komplexeren Einrichtung, die bei Microsoft Interop erforderlich ist.

Welche Best Practices werden für das Einlesen von Excel-Dateien in Arrays empfohlen?

Zu den bewährten Vorgehensweisen gehört die Auswahl des richtigen Tools für Ihre Umgebung, wie beispielsweise IronXL aufgrund seiner Benutzerfreundlichkeit und Leistungsfähigkeit, sowie die Sicherstellung einer effizienten Codestruktur zur effektiven Verwaltung von Speicher und Rechenleistung.

Jordi Bardia
Jordi Bardia
  Jetzt mit dem Ingenieurteam chatten
Software Ingenieur
Jordi ist am besten in Python, C# und C++ versiert. Wenn er nicht bei Iron Software seine Fähigkeiten einsetzt, programmiert er Spiele. Mit Verantwortung für Produkttests, Produktentwicklung und -forschung trägt Jordi mit immensem Wert zur kontinuierlichen Produktverbesserung bei. Die abwechslungsreiche Erfahrung hält ihn gefordert und engagiert, ...
Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen

Iron Support Team

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