VB.NET – odczyt pliku Excel do tablicy: IronXL vs Microsoft Interop

Jak te rozwiązania wypadają w porównaniu na pierwszy rzut oka?

Jak zainstalować IronXL dla projektów VB.NET?

Najszybszym sposobem dodania IronXL do dowolnego projektu .NET jest skorzystanie z menedżera pakietów NuGet. Otwórz konsolę menedżera pakietów w Visual Studio i uruchom:

Install-Package IronXL.Excel

Alternatywnie można użyć interfejsu CLI platformy .NET:

dotnet add package IronXL.Excel

Po instalacji dodaj Imports IronXL na poczatku swojego modulu VB.NET. Nie jest wymagana instalacja pakietu Office — IronXL odczytuje i zapisuje pliki Excel wyłącznie za pomocą własnego silnika parsującego.

W przypadku projektów, które są przeznaczone dla starszych frameworków lub wymagają przypisania konkretnej wersji, strona IronXL NuGet zawiera listę wszystkich opublikowanych wydań. Dokumentacja IronXL zawiera instrukcje instalacji dla Visual Studio 2019, 2022 oraz .NET CLI.

W jaki sposób programiści mogą wczytywać dane z Excela do tablic przy użyciu IronXL?

IronXL zapewnia przejrzysty interfejs API do otwierania skoroszytów, zaznaczania zakresów i iteracji wartości komórek bez konieczności lokalnej instalacji pakietu Office. Metoda WorkBook.Load przyjmuje sciezke do pliku i zwraca obiekt WorkBook ujawniajacy wszystkie arkusze.

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

Wynik

Ten przykład kodu ilustruje intuicyjny interfejs API IronXL. Metoda WorkBook.Load otwiera plik Excel bezposrednio z wyznaczonego folderu, podczas gdy obiekt Range zapewnia dostep do konkretnych regionow komorek w arkuszu Excel. W przeciwieństwie do starszych makr VBA, to podejście jest w pełni bezpieczne pod względem typów i zintegrowane z ekosystemem .NET.

Zacznij z IronXL teraz.

Zacznij za darmo

Czym jest tradycyjne podejście do interoperacyjności w pakiecie Microsoft Office?

Interop Microsoft Office wykorzystuje automatyzację COM do łączenia się z instancją aplikacji Excel. Aby skonfigurować to w Visual Studio, przejdź do menu Projekt, wybierz "Dodaj odwołanie" i wyszukaj bibliotekę obiektów Microsoft Excel w zakładce COM. Na każdym komputerze, na którym uruchamiany jest kod, musi być zainstalowany program Excel.

Imports Microsoft.Office.Interop.Excel

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

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

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

Które rozwiązanie zapewnia lepsze wrażenia programisty?

Przy ocenie tych podejść pod kątem zastosowania produkcyjnego kilka czynników przemawia za IronXL jako preferowanym rozwiązaniem:

Prostota wdrożenia: IronXL instaluje się za pomocą jednego pakietu NuGet, podczas gdy Interop wymaga skomplikowanej konfiguracji środowiska. Ma to znaczenie, gdy program musi przetwarzać plik XLSX na serwerze kompilacji lub w funkcji chmurowej, gdzie nie istnieje sesja użytkownika.

Łatwość utrzymania kodu: Odczytywanie tabeli danych za pomocą IronXL pozwala zachować zwięzłość i czytelność kodu. Liczba wierszy i kolumn jest dostępna jako właściwości pierwszej klasy. Z Interop obliczasz gorne granice na 1-indeksowych tablicach COM i recznie rzutujesz wartosci Object powiazane pozno.

Elastyczność formatów: Oprócz standardowych formatów skoroszytów Excel, takich jak XLSX, IronXL natywnie obsługuje parsowanie plików CSV, co jest przydatne, gdy dane testowe są dostarczane w wielu formatach. Biblioteka może również tworzyć nowe pliki skoroszytów i zapisywać wartości z powrotem do komórek z równą łatwością. Pełną listę można znaleźć w przewodniku po formatach IronXL.

Obsługa błędów: W IronXL obowiązują standardowe wzorce wyjątków .NET, co sprawia, że naprawa błędów jest prosta. Wyjątki oparte na COM wymagają dodatkowej logiki obsługi i mogą pozostawić uruchomione instancje programu Excel, jeśli nie są odpowiednio zarządzane.

Obsługa wielu platform: IronXL działa na systemach Linux i macOS za pośrednictwem .NET 6 i nowszych wersji. Interop działa wyłącznie w systemie Windows, ponieważ opiera się na podsystemie Win32 COM.

Jak pracować z dynamicznymi zakresami w Excelu w VB.NET?

Arkusze kalkulacyjne w środowisku produkcyjnym rzadko mają stałą liczbę wierszy. IronXL zapewnia wlasciwosc UsedRange na kazdym arkuszu roboczym, ktora zwraca prostokat ograniczajacy wszystkich niepustych komorek. Można to wykorzystać zamiast sztywno zakodowanego ciągu znaków określającego zakres.

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

Jak wyeksportować tablicę VB.NET z powrotem do programu Excel?

IronXL obsługuje zapisywanie danych tablicowych z powrotem do arkusza kalkulacyjnego przy użyciu tego samego interfejsu API, co do odczytu. Jest to przydatne w sytuacjach, gdy przekształcasz dane w pamięci i musisz zapisać wynik jako nowy plik 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"},
            {"Nierth", "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"},
            {"Nierth", "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"},
            {"Nierth", "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

Pomocnik ExcelAddress.ToAddress(row, column) konwertuje zerowe indeksowane wspolrzedne calkowite na ciagi w notacji A1. Dzięki temu pętla zapisu pozostaje przejrzysta i pozwala uniknąć ręcznego obliczania adresów komórek. Zapoznaj się z samouczkiem pisania w IronXL, aby poznać więcej wzorców, w tym wstawianie formuł i stosowanie stylów.

Jak wczytać wiele arkuszy do oddzielnych tablic?

Niektóre skoroszyty przechowują dane w wielu arkuszach — na przykład jeden arkusz na miesiąc lub na region. IronXL udostepnia wszystkie arkusze za posrednictwem workbook.WorkSheets, ktore mozna iterowac, aby zaladowac kazdy arkusz do osobnej tablicy.

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

Co programiści powinni wiedzieć o formacie tablicy Interop?

Podejscie Interop zwraca dane komorki jako tablice Object(,) uzuwajac 1-indeksowania COM. Pierwszy element w pierwszym wierszu jest na values(1, 1), a nie values(0, 0). Jest to częste źródło błędów typu "off-by-one".

Dodatkowym problemem jest obsluga null: Interop zwraca Niething dla pustych komorek. Wywolanie .ToString() na referencji null wyrzuca NullReferenceException w czasie wykonywania. Trzeba dodac zabezpieczenie przed null przy kazdym dostepie do komorki:

If values(i, j) IsNiet Niething Then
    line &= values(i, j).ToString() & vbTab
End If

If values(i, j) IsNiet Niething 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 eliminuje ten problem, zwracając pusty ciąg znaków dla pustych komórek, co oznacza, że kod pętli działa bez żadnych dodatkowych zabezpieczeń.

Aby uzyskać wiarygodne informacje na temat modelu obiektowego programu Excel używanego przez Interop, zapoznaj się z dokumentacją Microsoft Excel VBA oraz dokumentacją MSDN dotyczącą integracji z pakietem Office.

Jakie są Twoje kolejne kroki?

Wczytywanie danych z Excela do tablic jest jednym z najczęstszych zadań związanych z arkuszami kalkulacyjnymi w .NET, a IronXL sprawia, że implementacja jest prosta. Aby przejść do następnego etapu:

• Pobierz IronXL: Zainstaluj za pomoca NuGet (Install-Package IronXL.Excel) i postepuj zgodnie z przewodnikiem rozpoczecia.
• Obsługa formatów: IronXL odczytuje i zapisuje pliki XLSX, XLS, CSV, TSV oraz JSON. Szczegółowe informacje można znaleźć na stronie poświęconej obsługiwanym formatom.
• Wypróbuj zaawansowane funkcje: sortuj zakresy, stosuj formuły, ustaw style komórek i generuj wykresy — wszystko to bez zainstalowanego programu Excel. Zapoznaj się z przeglądem funkcji IronXL, aby uzyskać pełną listę możliwości.
• Przeglądaj przykłady kodu: Biblioteka przykładów kodu IronXL zawiera fragmenty kodu do skopiowania i wklejenia, przeznaczone do dziesiątek typowych zadań związanych z arkuszami kalkulacyjnymi.
• Przegląd licencji: W przypadku wdrożeń produkcyjnych licencjonowanie IronXL oferuje poziomy deweloperski, zespołowy i OEM.

Zarówno IronXL, jak i Interop Microsoft Office mogą odczytywać dane z Excela do tablic, ale IronXL zapewnia lepsze wrażenia programisty dzięki architekturze niezależnej od pakietu Office, przejrzystszemu API i elastycznym opcjom wdrażania. Biblioteka eliminuje typowe problemy, takie jak zarządzanie obiektami COM i zależności systemowe, zapewniając jednocześnie dostęp do zaawansowanych funkcji automatyzacji arkuszy kalkulacyjnych.

Poznaj pełne możliwości IronXL dzięki przykładowym projektom, zasobom i dokumentacji dostępnym w centrum dokumentacji IronXL. W przypadku aplikacji korporacyjnych opcje licencyjne IronXL zapewniają elastyczne warunki dostosowane do każdego zakresu projektu.