Icône de message
Passer au contenu du pied de page
  1. Iron Software
  2. Blog IronXL
  3. Comparer à d'autres composants
  4. VB.NET Lire un tableau Excel
COMPARER à D'AUTRES COMPOSANTS

VB .NET Lecture d'un fichier Excel dans un tableau : comparaison entre IronXL et Microsoft Interop

Jordi Bardia
Jordi Bardia
Mis à jour:

Pour lire des données Excel dans des tableaux en VB .NET, il faut charger un classeur, sélectionner une feuille de calcul, parcourir les lignes et les colonnes, et stocker la valeur de chaque cellule dans un tableau bidimensionnel. Avec IronXL, vous pouvez réaliser cela en quelques lignes sans installer Microsoft Office. Installez le package NuGet , appelez la fonction, obtenez un objet, puis parcourez sa collection pour remplir votre tableau.

Démarrez votre essai gratuit pour découvrir comment IronXL simplifie l'automatisation Excel dans vos projets Visual Studio.

Comment ces solutions se comparent-elles en un coup d'œil ?

IronXL vs Interopérabilité de Microsoft Office : comparaison des fonctionnalités pour les opérations sur les tableaux VB .NET
Caractéristique IronXL Interopérabilité de Microsoft Office
Installation requise au bureau Non Oui
installation NuGet Oui -- un seul paquet Nonn -- référence COM
Support de l'environnement serveur/CI Oui Limitée
gestion du cycle de vie des objets COM Nonn requis Requis
Formats pris en charge XLSX, XLS, CSV, TSV, JSON XLSX, XLS (Excel uniquement)
API à typage statique Oui Partiel -- COM à destination tardive
Prise en charge de Linux/macOS Oui (.NET 6+) Non
style de gestion des exceptions Exceptions .NET standard Exceptions COM + nettoyage manuel

Comment installer IronXL pour les projets VB .NET ?

La méthode la plus rapide pour ajouter IronXL à un projet .NET est d'utiliser le gestionnaire de packages NuGet . Ouvrez la console du Package Manager dans Visual Studio et exécutez :

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

Vous pouvez également utiliser l'interface de ligne de commande .NET :

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

Après l'installation, ajoutez Imports IronXL en haut de votre module VB .NET . Aucune installation d'Office n'est nécessaire : IronXL lit et écrit les fichiers Excel entièrement grâce à son propre moteur d'analyse.

Pour les projets ciblant des frameworks plus anciens ou nécessitant une version spécifique, la page NuGet IronXL répertorie toutes les versions publiées. La documentation IronXL fournit des guides d'installation pour Visual Studio 2019, 2022 et l'interface de ligne de commande .NET .

Comment les développeurs peuvent-ils lire des données Excel dans des tableaux à l'aide IronXL?

IronXL fournit une API simple pour ouvrir des classeurs, sélectionner des plages et parcourir les valeurs des cellules sans nécessiter d'installation locale d'Office. La méthode WorkBook.Load accepte un chemin de fichier et renvoie un objet WorkBook qui expose toutes les feuilles de calcul.

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

Comprendre les objets WorkBook et Worksheet

WorkBook.Load prend en charge les fichiers XLSX, XLS, CSV et TSV. Une fois chargée, workbook.DefaultWorkSheet renvoie la première feuille. Vous pouvez également accéder aux feuilles par nom avec workbook.GetWorkSheet("Sheet1") ou par index avec workbook.WorkSheets(0).

L'appel GetRange("A1:D5") renvoie un IronXl.Range qui expose les collections Rows et Columns. Chaque RangeRow itère sur les objets Cell, et cell.StringValue renvoie la chaîne d'affichage quel que soit le type de cellule sous-jacent.

Comment gérez-vous les valeurs saisies dans les cellules ?

Les cellules IronXL exposent des propriétés typées à côté de StringValue :

  • cell.IntValue -- analyse la cellule comme un entier
  • cell.DoubleValue -- analyse la cellule comme un double
  • cell.DateTimeValue -- analyse les cellules au format de date
  • cell.IsFormula -- indique si la cellule contient une formule

Pour les données financières, déclarez le tableau comme Double et assignez directement cell.DoubleValue. Cela évite les conversions de chaînes de caractères en nombres lors du traitement ultérieur.

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

Sortie

Lecture d'un fichier Excel dans un tableau avec .NET : Comparaison IronXL vs Microsoft Interop : Image 1 - IronXL vs Office Excel pour la lecture d'un fichier Excel dans un tableau avec .NET

Cet exemple de code illustre l'API intuitive d'IronXL. La méthode WorkBook.Load ouvre le fichier Excel directement depuis votre dossier désigné, tandis que l'objet Range permet d'accéder à des régions de cellules spécifiques dans la feuille de calcul Excel. Contrairement aux macros VBA traditionnelles, cette approche est entièrement sécurisée en termes de types et intégrée à l'écosystème .NET .

Commencez avec IronXL maintenant.
green arrow pointer

Quelle est l'approche traditionnelle d'interopérabilité de Microsoft Office ?

Interopérabilité de Microsoft Office s'appuie sur l'automatisation COM pour se connecter à une instance d'application Excel. Pour configurer cela dans Visual Studio, accédez au menu Projet, sélectionnez " Ajouter une référence " et recherchez la bibliothèque d'objets Microsoft Excel sous l'onglet COM. Une installation locale d'Excel doit exister sur chaque machine exécutant le code.

Imports Microsoft.Office.Interop.Excel

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

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

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

Pourquoi la gestion des objets COM est-elle importante ?

L'approche Interop exige une attention particulière à la gestion du cycle de vie des objets COM. Chaque objet renvoyé par l'application Excel (classeurs, feuilles de calcul, plages et cellules) contient un pointeur COM à comptage de références. Ne pas appeler Marshal.ReleaseComObject sur chacun de ces objets laisse un processus EXCEL.EXE s'exécuter silencieusement en arrière-plan.

Sur les serveurs, les processus orphelins s'accumulent au fil du temps et finissent par épuiser la mémoire disponible ou les descripteurs de fichiers. Le modèle Try...Finally ci-dessus est l'approche minimale sûre, mais de nombreuses bases de code d'entreprise ajoutent un utilitaire de nettoyage COM dédié pour gérer les graphes d'objets imbriqués.

La convention d'indexation des tableaux Interop diffère également de celle des tableaux VB .NET standard : les tableaux basés sur COM commencent à l'index 1 et non à l'index 0. Cela signifie que toute boucle sur les lignes ou les colonnes doit tenir compte de ce décalage d'une unité, ce qui est une source fréquente d'erreurs d'exécution et de bogues de troncature de données.

Quelle solution offre la meilleure expérience de développement ?

Lors de l'évaluation de ces approches pour une utilisation en production, plusieurs facteurs plaident en faveur IronXL comme solution privilégiée :

Simplicité du déploiement : IronXL s'installe via un seul package NuGet , tandis qu'Interop nécessite des configurations d'environnement complexes. Cela a son importance lorsque votre programme doit traiter un fichier XLSX sur un serveur de compilation ou une fonction cloud où aucune session utilisateur n'existe.

Maintenabilité du code : La lecture d'un tableau de données via IronXL permet de conserver un code court et lisible. Le nombre de lignes et de colonnes est disponible en tant que propriété de premier ordre. Avec Interop, vous calculez les limites supérieures des tableaux COM indexés à 1 et convertissez manuellement les valeurs de limite tardive Object.

Flexibilité des formats : Outre les formats de classeurs Excel standard comme XLSX, IronXL prend en charge nativement l'analyse CSV, ce qui est utile lorsque les données de test arrivent dans plusieurs formats. La bibliothèque peut également créer de nouveaux fichiers de classeur et réécrire les valeurs dans les cellules avec la même simplicité. Consultez le guide des formats IronXL pour obtenir la liste complète.

Gestion des erreurs : Les modèles d'exceptions .NET standard s'appliquent à IronXL, ce qui simplifie la récupération des erreurs. Les exceptions basées sur COM nécessitent une logique de gestion supplémentaire et peuvent laisser des instances Excel en cours d'exécution si elles ne sont pas correctement gérées.

Compatibilité multiplateforme : IronXL fonctionne sous Linux et macOS via .NET 6 et versions ultérieures. L'interopérabilité est exclusive à Windows car elle dépend du sous-système COM Win32.

Compromis entre performances et maintenance pour la lecture de tableaux en VB .NET
Critère IronXL Microsoft Interop
Lignes de code pour la lecture de tableau de base ~20 ~40+
Nettoyage manuel du serveur COM requis Non Oui
Fonctionne sans Excel installé Oui Non
S'exécute dans les pipelines Docker/CI Oui Non
Convention d'indexation des tableaux Base 0 (.NET Standard) Base 1 (norme COM)

Comment travailler avec des plages Excel dynamiques en VB .NET?

Les feuilles de calcul de production comportent rarement un nombre fixe de lignes. IronXL fournit la propriété UsedRange sur chaque feuille de calcul, qui renvoie le rectangle englobant toutes les cellules non vides. Vous pouvez utiliser ceci à la place d'une chaîne de plage codée en dur.

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

Comment filtrer et valider les données d'un tableau après leur chargement ?

Une fois le tableau rempli, les étapes de post-traitement courantes comprennent :

  • Ignorer les lignes d'en-tête : démarrer la boucle d'affichage à l'index 1 au lieu de 0 pour omettre les en-têtes de colonnes.
  • Supprimer les espaces blancs : Appelez .Trim() sur cell.StringValue pour supprimer les espaces de début et de fin copiés de la feuille de calcul.
  • Gestion des cellules nulles : IronXL renvoie une chaîne vide pour les cellules vides, les vérifications de valeurs nulles sont donc inutiles dans la plupart des cas.
  • Valider les plages numériques : Après le chargement des nombres à virgule flottante double précision, effectuez une vérification de plage avant l'enregistrement afin de détecter les cellules contenant des valeurs d'espace réservé telles que -1 ou 9999.

Pour les ensembles de données plus volumineux, envisagez d'utiliser List(Of T) ou une classe fortement typée au lieu d'un tableau bidimensionnel brut. Le chargement des données dans des objets typés facilite la lecture et le test du code en aval. La documentation de référence du modèle objet IronXL répertorie toutes les propriétés de cellule et les méthodes de feuille de calcul disponibles.

Comment exporter un tableau VB .NET vers Excel ?

IronXL permet d'écrire des données de tableau dans une feuille de calcul avec la même API que celle utilisée pour la lecture. Ceci est utile dans les cas où vous transformez les données en mémoire et devez enregistrer le résultat dans un nouveau fichier 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"},
            {"Nonrth", "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"},
            {"Nonrth", "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

L'assistant ExcelAddress.ToAddress(row, column) convertit les coordonnées entières à base zéro en chaînes de notation A1. Cela permet de garder la boucle d'écriture propre et d'éviter le calcul manuel des adresses de cellules. Consultez le tutoriel d'écriture IronXL pour découvrir d'autres modèles, notamment l'injection de formules et l'application de styles.

Comment lire plusieurs feuilles de calcul et les séparer en tableaux distincts ?

Certains classeurs stockent les données sur plusieurs feuilles – par exemple, une feuille par mois ou par région. IronXL expose toutes les feuilles via workbook.WorkSheets, que vous pouvez parcourir pour charger chaque feuille dans son propre tableau.

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 dans la feuille de compréhension

La collection workbook.WorkSheets est indexée à zéro et prend en charge à la fois For Each et l'accès indexé. Utilisez sheet.Name pour identifier les feuilles de manière programmatique et la logique de branchement en fonction des noms de feuilles connus. Le guide de feuilles de travail IronXL couvre en détail la sélection de plages, les plages nommées et la détection de plages dynamiques.

Pour les classeurs contenant des dizaines de feuilles, filtrez-les par nom avant le chargement afin d'éviter de traiter des feuilles non pertinentes et de gaspiller de la mémoire.

Que doivent savoir les développeurs sur le format de tableau d'interopérabilité ?

L'approche Interop renvoie les données de cellule sous forme de tableau Object(,) en utilisant l'indexation à partir de 1 de COM. Le premier élément de la première ligne se trouve à values(1, 1), et non à values(0, 0). C'est une source fréquente d'erreurs de décalage d'une unité.

Une autre préoccupation concerne la gestion des valeurs nulles : Interop renvoie Nonthing pour les cellules vides. L'appel à .ToString() sur une référence nulle lève une exception NullReferenceException à l'exécution. Vous devez ajouter une protection contre les valeurs nulles autour de chaque accès à une cellule :

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

IronXL élimine ce problème en renvoyant une chaîne vide pour les cellules vides, ce qui signifie que le code de la boucle fonctionne sans aucune protection supplémentaire.

Pour obtenir des informations faisant autorité sur le modèle objet Excel utilisé par Interop, reportez-vous à la documentation de référence Microsoft Excel VBA et à la documentation MSDN Office Interop .

Quelles sont vos prochaines étapes ?

La lecture de données Excel dans des tableaux est l'une des tâches les plus courantes en matière de tableurs .NET , et IronXL simplifie grandement son implémentation. Pour passer à l'étape suivante :

  • Téléchargez IronXL : Installez-le via NuGet (Install-Package IronXl.Excel) et suivez le guide de démarrage .
  • Explorez les formats pris en charge : IronXL lit et écrit les formats XLSX, XLS, CSV, TSV et JSON. Consultez la page des formats pris en charge pour plus de détails.
  • Essayez les fonctionnalités avancées : triez les plages de cellules, appliquez des formules, définissez les styles de cellules et générez des graphiques, le tout sans avoir Excel installé. Consultez la présentation des fonctionnalités IronXL pour obtenir la liste complète des capacités.
  • Parcourez les exemples de code : La bibliothèque d'exemples de code IronXL fournit des extraits à copier-coller pour des dizaines de tâches courantes de tableur.
  • Examiner les licences : Pour les déploiements en production, les licences IronXL proposent des niveaux développeur, équipe et OEM.

VB .NET Lecture d'un fichier Excel dans un tableau : Comparaison IronXL vs Microsoft Interop : Image 2 - Sortie IronXL

IronXL et Interopérabilité de Microsoft Office peuvent tous deux lire des données Excel dans des tableaux, mais IronXL offre une expérience de développement supérieure grâce à son architecture indépendante d'Office, son API plus claire et ses options de déploiement flexibles. La bibliothèque élimine les problèmes courants tels que la gestion des objets COM et les dépendances système, tout en offrant un accès à des fonctionnalités avancées pour l'automatisation des feuilles de calcul.

Explorez toutes les fonctionnalités d' IronXL grâce à des exemples de projets, des ressources et de la documentation disponibles sur le centre de documentation IronXL . Pour les applications d'entreprise, les options de licence IronXL offrent des conditions flexibles adaptées à toutes les envergures de projet.

Questions Fréquemment Posées

Quelle est la meilleure façon de lire des fichiers Excel dans des tableaux en utilisant VB .NET?

La lecture de fichiers Excel dans des tableaux en .NET peut être réalisée efficacement grâce à IronXL ou à l'interopérabilité Microsoft Office. IronXL offre une approche simplifiée et performante, éliminant le besoin d'installer Microsoft Excel et réduisant la complexité du code.

Comment IronXL se compare-t-il à Microsoft Office Interop pour la lecture des fichiers Excel ?

IronXL propose une méthode plus simple et plus rapide que Microsoft Office Interop pour importer des fichiers Excel dans des tableaux. Elle ne nécessite pas l'installation d'Excel sur le serveur et gère la manipulation des fichiers Excel avec une charge système réduite.

Est-il possible de manipuler des données Excel sans installer Microsoft Excel ?

Oui, IronXL permet de manipuler des données Excel sans avoir besoin d'installer Microsoft Excel. C'est donc une excellente solution pour les environnements serveur où l'installation d'Excel est impossible.

Pourquoi devrais-je envisager d'utiliser IronXL pour les opérations Excel en VB .NET?

IronXL simplifie les opérations Excel grâce à une API intuitive qui prend en charge différents formats de fichiers Excel. Il garantit des performances accrues et un déploiement facilité, notamment dans les environnements où Microsoft Excel ne peut être installé.

IronXL est-il adapté à la gestion de grands ensembles de données Excel en VB .NET?

Oui, IronXL est optimisé pour la performance et peut gérer efficacement de grands ensembles de données Excel, assurant une extraction et une manipulation rapides des données.

Quels sont les exemples de code disponibles pour lire des fichiers Excel dans des tableaux en utilisant VB .NET?

Ce guide fournit des exemples de code fonctionnels pour IronXL et Microsoft Office Interop, démontrant comment lire efficacement des fichiers Excel dans des tableaux en VB .NET.

IronXL prend-il en charge différents formats de fichiers Excel?

IronXL prend en charge un large éventail de formats de fichiers Excel, notamment XLSX, XLS, CSV et bien d'autres, ce qui le rend polyvalent pour répondre à divers besoins de traitement des données.

Quels sont les avantages d'utiliser IronXL plutôt que Microsoft Office Interop ?

IronXL est plus facile à utiliser, ne nécessite pas l'installation d'Excel et offre de meilleures performances. Il simplifie le code et réduit les risques d'erreurs liées aux interactions COM dans Microsoft Office Interop.

En quoi IronXL gère-t-il les tableaux bidimensionnels différemment de Microsoft Interop ?

IronXL propose des méthodes directes pour convertir les données Excel en tableaux bidimensionnels, garantissant une approche plus efficace et plus simple que la configuration plus complexe requise par Microsoft Interop.

Quelles sont les meilleures pratiques recommandées pour lire des fichiers Excel et les convertir en tableaux ?

Les bonnes pratiques consistent notamment à choisir l'outil adapté à votre environnement, tel IronXL pour sa facilité d'utilisation et ses performances, et à garantir une structure de code efficace pour gérer efficacement la mémoire et la puissance de traitement.

Jordi Bardia
Jordi Bardia
  Discutez maintenant avec l'équipe d'ingénierie
Ingénieur logiciel
Jordi est le plus compétent en Python, C# et C++, et lorsqu'il ne met pas à profit ses compétences chez Iron Software, il programme des jeux. Partageant les responsabilités des tests de produit, du développement de produit et de la recherche, Jordi apporte une immense valeur à l'amé...
Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Essai gratuit

Iron Support Team

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