La lecture et le traitement des fichiers OpenDocument Spreadsheet (ODS) et Excel en C# sont simples lorsque vous utilisez la bibliothèque appropriée. Avec IronXL, vous chargez n'importe quel fichier XLS, XLSX, ODS ou CSV dans un objet WorkBook en utilisant un seul appel de méthode - aucune installation de Microsoft Excel requise, pas d'enregistrement COM, et pas de maux de tête d'Interop. Ce guide vous accompagne à chaque étape : installation du package, chargement des fichiers, extraction des valeurs des cellules saisies, utilisation des feuilles de calcul nommées, gestion des cellules fusionnées et déploiement sur des environnements Linux ou conteneurisés.

Comment installer IronXL dans un projet .NET ?

Installation du gestionnaire de packages NuGet

Ajoutez IronXL à votre projet via le gestionnaire de packages NuGet . Ouvrez la console du Package Manager dans Visual Studio et exécutez :

Install-Package IronXL.Excel

IronXL cible .NET 8, .NET 9, .NET 10, .NET Framework 4.6.2+ et .NET Standard 2.0, donc il convient aussi bien aux bases de code modernes qu'aux anciennes. Une fois le package installé, ajoutez la directive using IronXL; en haut de tout fichier qui travaille avec des feuilles de calcul, et vous êtes prêt à charger votre premier classeur.

Pour Azure Functions, les conteneurs Docker ou les API hébergées sous Linux, aucune configuration d'exécution supplémentaire n'est requise. La bibliothèque intègre en interne tout ce dont elle a besoin et ne fait pas appel aux composants d'automatisation d'Excel.

Comment charger un fichier OpenOffice ou Excel en C# ?

IronXL traite les fichiers ODS, XLS, XLSX et CSV de manière identique via la méthode WorkBook.Load. Vous indiquez un chemin de fichier absolu ou relatif, et la bibliothèque détecte le format à partir de l'en-tête du fichier, et pas seulement de son extension. Cela signifie qu'un fichier renommé de .ods à .xlsx est toujours lu correctement.

using IronXL;

// Load an OpenDocument Spreadsheet (.ods) produced by LibreOffice Calc or OpenOffice
WorkBook workbook = WorkBook.Load("quarterly_report.ods");

// Access the first worksheet by index
WorkSheet sheet = workbook.WorkSheets[0];

// Read a cell value
string companyName = sheet["A1"].StringValue;
int recordCount   = sheet["B1"].IntValue;

Console.WriteLine($"Company : {companyName}");
Console.WriteLine($"Records : {recordCount}");

using IronXL;

// Load an OpenDocument Spreadsheet (.ods) produced by LibreOffice Calc or OpenOffice
WorkBook workbook = WorkBook.Load("quarterly_report.ods");

// Access the first worksheet by index
WorkSheet sheet = workbook.WorkSheets[0];

// Read a cell value
string companyName = sheet["A1"].StringValue;
int recordCount   = sheet["B1"].IntValue;

Console.WriteLine($"Company : {companyName}");
Console.WriteLine($"Records : {recordCount}");

Imports IronXL

' Load an OpenDocument Spreadsheet (.ods) produced by LibreOffice Calc or OpenOffice
Dim workbook As WorkBook = WorkBook.Load("quarterly_report.ods")

' Access the first worksheet by index
Dim sheet As WorkSheet = workbook.WorkSheets(0)

' Read a cell value
Dim companyName As String = sheet("A1").StringValue
Dim recordCount As Integer = sheet("B1").IntValue

Console.WriteLine($"Company : {companyName}")
Console.WriteLine($"Records : {recordCount}")

Imports IronXL

' Load an OpenDocument Spreadsheet (.ods) produced by LibreOffice Calc or OpenOffice
Dim workbook As WorkBook = WorkBook.Load("quarterly_report.ods")

' Access the first worksheet by index
Dim sheet As WorkSheet = workbook.WorkSheets(0)

' Read a cell value
Dim companyName As String = sheet("A1").StringValue
Dim recordCount As Integer = sheet("B1").IntValue

Console.WriteLine($"Company : {companyName}")
Console.WriteLine($"Records : {recordCount}")

La même commande fonctionne pour les fichiers XLSX et XLS ; il suffit de modifier le chemin d'accès. WorkBook.Load retourne le même objet fortement typé indépendamment du format source, donc le reste de votre code reste identique, que le fichier provienne de Microsoft Excel, LibreOffice ou toute autre application conforme à ODF.

Comment lire chaque ligne et chaque cellule d'une feuille de calcul ?

Itération sur la collection Rows

Itérer sur toutes les lignes et cellules est la tâche de traitement Excel la plus courante - que vous validiez des données d'importation, transformiez des enregistrements ou alimentiez un pipeline de rapport. IronXL expose une collection Rows sur chaque WorkSheet :

using IronXL;

WorkBook workbook  = WorkBook.Load("customers.xlsx");
WorkSheet worksheet = workbook.WorkSheets[0];

Console.WriteLine($"Total rows    : {worksheet.RowCount}");
Console.WriteLine($"Total columns : {worksheet.ColumnCount}");
Console.WriteLine();

foreach (var row in worksheet.Rows)
{
    foreach (var cell in row)
    {
        if (!cell.IsEmpty)
            Console.Write($"{cell.StringValue,-20}");
    }
    Console.WriteLine();
}

using IronXL;

WorkBook workbook  = WorkBook.Load("customers.xlsx");
WorkSheet worksheet = workbook.WorkSheets[0];

Console.WriteLine($"Total rows    : {worksheet.RowCount}");
Console.WriteLine($"Total columns : {worksheet.ColumnCount}");
Console.WriteLine();

foreach (var row in worksheet.Rows)
{
    foreach (var cell in row)
    {
        if (!cell.IsEmpty)
            Console.Write($"{cell.StringValue,-20}");
    }
    Console.WriteLine();
}

Imports IronXL

Dim workbook As WorkBook = WorkBook.Load("customers.xlsx")
Dim worksheet As WorkSheet = workbook.WorkSheets(0)

Console.WriteLine($"Total rows    : {worksheet.RowCount}")
Console.WriteLine($"Total columns : {worksheet.ColumnCount}")
Console.WriteLine()

For Each row In worksheet.Rows
    For Each cell In row
        If Not cell.IsEmpty Then
            Console.Write($"{cell.StringValue,-20}")
        End If
    Next
    Console.WriteLine()
Next

Imports IronXL

Dim workbook As WorkBook = WorkBook.Load("customers.xlsx")
Dim worksheet As WorkSheet = workbook.WorkSheets(0)

Console.WriteLine($"Total rows    : {worksheet.RowCount}")
Console.WriteLine($"Total columns : {worksheet.ColumnCount}")
Console.WriteLine()

For Each row In worksheet.Rows
    For Each cell In row
        If Not cell.IsEmpty Then
            Console.Write($"{cell.StringValue,-20}")
        End If
    Next
    Console.WriteLine()
Next

Les propriétés RowCount et ColumnCount ne retournent que la plage remplie - les lignes et colonnes vides en fin de tableau ne sont pas incluses. Vérifier cell.IsEmpty avant de lire empêche un traitement inutile sur les feuilles clairsemées.

Pour les gros fichiers, envisagez d'utiliser un accès basé sur les plages (worksheet["A1:D500"]) au lieu d'une itération sur toute la feuille. Cela limite le nombre de cellules chargées en mémoire et accélère le traitement lorsque vous n'avez besoin que d'un sous-ensemble des données.

Comment extraire les valeurs saisies dans les cellules ?

Accesseurs de propriété dactylographiés

Dans une feuille de calcul réelle, les cellules contiennent des chaînes de caractères, des entiers, des nombres décimaux, des booléens et des dates. IronXL expose des propriétés typées dédiées, vous n'aurez donc jamais à analyser manuellement des chaînes de caractères brutes :

using IronXL;

WorkBook workbook = WorkBook.Load("inventory.xlsx");
WorkSheet sheet   = workbook.GetWorkSheet("Products");

// Typed accessors handle conversion automatically
string  productName = sheet["A2"].StringValue;
int     quantity    = sheet["B2"].IntValue;
decimal unitPrice   = sheet["C2"].DecimalValue;
bool    inStock     = sheet["D2"].BoolValue;
DateTime? lastAudit = sheet["E2"].DateTimeValue;

Console.WriteLine($"Product  : {productName}");
Console.WriteLine($"Qty      : {quantity}");
Console.WriteLine($"Price    : {unitPrice:C}");
Console.WriteLine($"In Stock : {inStock}");
Console.WriteLine($"Audited  : {lastAudit?.ToString("d") ?? "Never"}");

using IronXL;

WorkBook workbook = WorkBook.Load("inventory.xlsx");
WorkSheet sheet   = workbook.GetWorkSheet("Products");

// Typed accessors handle conversion automatically
string  productName = sheet["A2"].StringValue;
int     quantity    = sheet["B2"].IntValue;
decimal unitPrice   = sheet["C2"].DecimalValue;
bool    inStock     = sheet["D2"].BoolValue;
DateTime? lastAudit = sheet["E2"].DateTimeValue;

Console.WriteLine($"Product  : {productName}");
Console.WriteLine($"Qty      : {quantity}");
Console.WriteLine($"Price    : {unitPrice:C}");
Console.WriteLine($"In Stock : {inStock}");
Console.WriteLine($"Audited  : {lastAudit?.ToString("d") ?? "Never"}");

Imports IronXL

Dim workbook As WorkBook = WorkBook.Load("inventory.xlsx")
Dim sheet As WorkSheet = workbook.GetWorkSheet("Products")

' Typed accessors handle conversion automatically
Dim productName As String = sheet("A2").StringValue
Dim quantity As Integer = sheet("B2").IntValue
Dim unitPrice As Decimal = sheet("C2").DecimalValue
Dim inStock As Boolean = sheet("D2").BoolValue
Dim lastAudit As DateTime? = sheet("E2").DateTimeValue

Console.WriteLine($"Product  : {productName}")
Console.WriteLine($"Qty      : {quantity}")
Console.WriteLine($"Price    : {unitPrice:C}")
Console.WriteLine($"In Stock : {inStock}")
Console.WriteLine($"Audited  : {If(lastAudit?.ToString("d"), "Never")}")

Imports IronXL

Dim workbook As WorkBook = WorkBook.Load("inventory.xlsx")
Dim sheet As WorkSheet = workbook.GetWorkSheet("Products")

' Typed accessors handle conversion automatically
Dim productName As String = sheet("A2").StringValue
Dim quantity As Integer = sheet("B2").IntValue
Dim unitPrice As Decimal = sheet("C2").DecimalValue
Dim inStock As Boolean = sheet("D2").BoolValue
Dim lastAudit As DateTime? = sheet("E2").DateTimeValue

Console.WriteLine($"Product  : {productName}")
Console.WriteLine($"Qty      : {quantity}")
Console.WriteLine($"Price    : {unitPrice:C}")
Console.WriteLine($"In Stock : {inStock}")
Console.WriteLine($"Audited  : {If(lastAudit?.ToString("d"), "Never")}")

Lorsqu'une cellule contient une formule, IronXL l'évalue et renvoie le résultat calculé via les mêmes propriétés typées. Vous n'avez pas besoin d'appeler une méthode d'évaluation distincte. Pour les cellules susceptibles d'être vides ou de contenir un type incompatible, la bibliothèque renvoie la valeur par défaut de ce type plutôt que de lever une exception, ce qui simplifie la logique de validation des entrées.

Comment travailler avec plusieurs feuilles de calcul nommées ?

Accès par nom, index ou itération

Les feuilles de calcul Enterprise contiennent souvent plusieurs feuilles nommées : une par mois, une par région ou une par gamme de produits. IronXL vous offre plusieurs façons d'y accéder :

using IronXL;

WorkBook workbook = WorkBook.Load("annual_sales.xlsx");

// Option 1: access by name (throws if the sheet does not exist)
WorkSheet januarySheet = workbook.GetWorkSheet("January");

// Option 2: iterate all sheets in the workbook
foreach (WorkSheet ws in workbook.WorkSheets)
{
    Console.WriteLine($"Sheet: {ws.Name}  |  Rows: {ws.RowCount}");

    // Read the header row from each sheet
    string header = ws["A1"].StringValue;
    Console.WriteLine($"  Header: {header}");
}

// Option 3: access by zero-based index
WorkSheet lastSheet = workbook.WorkSheets[workbook.WorkSheets.Count - 1];
Console.WriteLine($"Last sheet: {lastSheet.Name}");

using IronXL;

WorkBook workbook = WorkBook.Load("annual_sales.xlsx");

// Option 1: access by name (throws if the sheet does not exist)
WorkSheet januarySheet = workbook.GetWorkSheet("January");

// Option 2: iterate all sheets in the workbook
foreach (WorkSheet ws in workbook.WorkSheets)
{
    Console.WriteLine($"Sheet: {ws.Name}  |  Rows: {ws.RowCount}");

    // Read the header row from each sheet
    string header = ws["A1"].StringValue;
    Console.WriteLine($"  Header: {header}");
}

// Option 3: access by zero-based index
WorkSheet lastSheet = workbook.WorkSheets[workbook.WorkSheets.Count - 1];
Console.WriteLine($"Last sheet: {lastSheet.Name}");

Imports IronXL

Dim workbook As WorkBook = WorkBook.Load("annual_sales.xlsx")

' Option 1: access by name (throws if the sheet does not exist)
Dim januarySheet As WorkSheet = workbook.GetWorkSheet("January")

' Option 2: iterate all sheets in the workbook
For Each ws As WorkSheet In workbook.WorkSheets
    Console.WriteLine($"Sheet: {ws.Name}  |  Rows: {ws.RowCount}")

    ' Read the header row from each sheet
    Dim header As String = ws("A1").StringValue
    Console.WriteLine($"  Header: {header}")
Next

' Option 3: access by zero-based index
Dim lastSheet As WorkSheet = workbook.WorkSheets(workbook.WorkSheets.Count - 1)
Console.WriteLine($"Last sheet: {lastSheet.Name}")

Imports IronXL

Dim workbook As WorkBook = WorkBook.Load("annual_sales.xlsx")

' Option 1: access by name (throws if the sheet does not exist)
Dim januarySheet As WorkSheet = workbook.GetWorkSheet("January")

' Option 2: iterate all sheets in the workbook
For Each ws As WorkSheet In workbook.WorkSheets
    Console.WriteLine($"Sheet: {ws.Name}  |  Rows: {ws.RowCount}")

    ' Read the header row from each sheet
    Dim header As String = ws("A1").StringValue
    Console.WriteLine($"  Header: {header}")
Next

' Option 3: access by zero-based index
Dim lastSheet As WorkSheet = workbook.WorkSheets(workbook.WorkSheets.Count - 1)
Console.WriteLine($"Last sheet: {lastSheet.Name}")

Lorsque le nom de la feuille est connu au moment de la conception, GetWorkSheet est l'option la plus claire. Pour un traitement dynamique - lorsque les noms de feuilles proviennent des entrées utilisateur ou de la configuration - itérer la collection WorkSheets évite les hypothèses codées en dur et gère les classeurs avec un nombre variable de feuilles.

Comment gérez-vous les cellules fusionnées et les régions formatées ?

Les rapports et les tableaux de bord utilisent fréquemment des cellules fusionnées pour les en-têtes, les étiquettes groupées et les lignes de synthèse. IronXL lit la valeur de la cellule en haut à gauche d'une région fusionnée, exactement comme Excel l'affiche :

using IronXL;

WorkBook workbook = WorkBook.Load("report_with_merges.xlsx");
WorkSheet sheet   = workbook.DefaultWorkSheet;

// The merged region A1:D1 stores its value in cell A1
string reportTitle = sheet["A1"].StringValue;
Console.WriteLine($"Report title : {reportTitle}");

// Read cell formatting metadata
var titleCell = sheet["A1"];
Console.WriteLine($"Bold         : {titleCell.Style.Font.Bold}");
Console.WriteLine($"Font size    : {titleCell.Style.Font.Height}");

// Scan an entire column for non-empty section headers
foreach (var cell in sheet["A1:A100"])
{
    if (!cell.IsEmpty && cell.Style.Font.Bold)
        Console.WriteLine($"Section header at {cell.AddressString}: {cell.StringValue}");
}

using IronXL;

WorkBook workbook = WorkBook.Load("report_with_merges.xlsx");
WorkSheet sheet   = workbook.DefaultWorkSheet;

// The merged region A1:D1 stores its value in cell A1
string reportTitle = sheet["A1"].StringValue;
Console.WriteLine($"Report title : {reportTitle}");

// Read cell formatting metadata
var titleCell = sheet["A1"];
Console.WriteLine($"Bold         : {titleCell.Style.Font.Bold}");
Console.WriteLine($"Font size    : {titleCell.Style.Font.Height}");

// Scan an entire column for non-empty section headers
foreach (var cell in sheet["A1:A100"])
{
    if (!cell.IsEmpty && cell.Style.Font.Bold)
        Console.WriteLine($"Section header at {cell.AddressString}: {cell.StringValue}");
}

Imports IronXL

Dim workbook As WorkBook = WorkBook.Load("report_with_merges.xlsx")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet

' The merged region A1:D1 stores its value in cell A1
Dim reportTitle As String = sheet("A1").StringValue
Console.WriteLine($"Report title : {reportTitle}")

' Read cell formatting metadata
Dim titleCell = sheet("A1")
Console.WriteLine($"Bold         : {titleCell.Style.Font.Bold}")
Console.WriteLine($"Font size    : {titleCell.Style.Font.Height}")

' Scan an entire column for non-empty section headers
For Each cell In sheet("A1:A100")
    If Not cell.IsEmpty AndAlso cell.Style.Font.Bold Then
        Console.WriteLine($"Section header at {cell.AddressString}: {cell.StringValue}")
    End If
Next

Imports IronXL

Dim workbook As WorkBook = WorkBook.Load("report_with_merges.xlsx")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet

' The merged region A1:D1 stores its value in cell A1
Dim reportTitle As String = sheet("A1").StringValue
Console.WriteLine($"Report title : {reportTitle}")

' Read cell formatting metadata
Dim titleCell = sheet("A1")
Console.WriteLine($"Bold         : {titleCell.Style.Font.Bold}")
Console.WriteLine($"Font size    : {titleCell.Style.Font.Height}")

' Scan an entire column for non-empty section headers
For Each cell In sheet("A1:A100")
    If Not cell.IsEmpty AndAlso cell.Style.Font.Bold Then
        Console.WriteLine($"Section header at {cell.AddressString}: {cell.StringValue}")
    End If
Next

L'arborescence de propriétés Style reflète la structure de la spécification OOXML SpreadsheetML, donc les noms de propriétés semblent familiers si vous avez travaillé avec le SDK Open XML. Cependant, IronXL encapsule toute cette complexité dans une API claire qui ne nécessite aucune manipulation XML de votre part.

Comment importer des fichiers CSV avec la même API ?

Les fichiers CSV produits par des exportations de bases de données, des systèmes CRM et des applications héritées peuvent être lus via le même appel WorkBook.Load. IronXL déduit le délimiteur du contenu du fichier :

using IronXL;

// Load a comma-separated values file -- same method, same API
WorkBook csvWorkbook  = WorkBook.Load("export.csv");
WorkSheet csvSheet    = csvWorkbook.DefaultWorkSheet;

Console.WriteLine($"CSV rows loaded: {csvSheet.RowCount}");

// Process rows exactly like any other worksheet
foreach (var row in csvSheet.Rows)
{
    string id   = row[0].StringValue;
    string name = row[1].StringValue;
    Console.WriteLine($"{id,-10} {name}");
}

using IronXL;

// Load a comma-separated values file -- same method, same API
WorkBook csvWorkbook  = WorkBook.Load("export.csv");
WorkSheet csvSheet    = csvWorkbook.DefaultWorkSheet;

Console.WriteLine($"CSV rows loaded: {csvSheet.RowCount}");

// Process rows exactly like any other worksheet
foreach (var row in csvSheet.Rows)
{
    string id   = row[0].StringValue;
    string name = row[1].StringValue;
    Console.WriteLine($"{id,-10} {name}");
}

Imports IronXL

' Load a comma-separated values file -- same method, same API
Dim csvWorkbook As WorkBook = WorkBook.Load("export.csv")
Dim csvSheet As WorkSheet = csvWorkbook.DefaultWorkSheet

Console.WriteLine($"CSV rows loaded: {csvSheet.RowCount}")

' Process rows exactly like any other worksheet
For Each row In csvSheet.Rows
    Dim id As String = row(0).StringValue
    Dim name As String = row(1).StringValue
    Console.WriteLine($"{id,-10} {name}")
Next

Imports IronXL

' Load a comma-separated values file -- same method, same API
Dim csvWorkbook As WorkBook = WorkBook.Load("export.csv")
Dim csvSheet As WorkSheet = csvWorkbook.DefaultWorkSheet

Console.WriteLine($"CSV rows loaded: {csvSheet.RowCount}")

' Process rows exactly like any other worksheet
For Each row In csvSheet.Rows
    Dim id As String = row(0).StringValue
    Dim name As String = row(1).StringValue
    Console.WriteLine($"{id,-10} {name}")
Next

Après le chargement, vous pouvez enregistrer les données au format XLSX en utilisant csvWorkbook.SaveAs("output.xlsx"). Il s'agit d'un schéma courant pour les pipelines de conversion CSV vers Excel : recevoir un fichier CSV, l'enrichir avec des colonnes calculées ou une mise en forme, puis renvoyer un rapport XLSX formaté à l'utilisateur.

Pour les fichiers séparés par des tabulations ou des délimiteurs personnalisés, utilisez WorkBook.LoadCSV("file.tsv", fileFormat: ExcelFileFormat.TSV) pour spécifier le format explicitement.

Comment IronXL se compare-t-il à Microsoft.Office.Interop.Excel ?

Interopérabilité, kit de développement logiciel Open XML et IronXL côte à côte

L'alternative la plus courante à IronXL pour l'automatisation Excel dans .NET est Microsoft.Office.Interop.Excel . Comprendre les compromis vous aide à choisir l'outil adapté à votre projet.

Microsoft Interop encapsule le modèle objet COM d'Excel. Cela signifie qu'Excel doit être installé sur chaque machine exécutant votre code, y compris les serveurs web, les agents de compilation et les machines virtuelles cloud. La gestion du cycle de vie d'un objet COM est manuelle : vous devez libérer explicitement chaque objet Range, Worksheet et Workbook, sinon les processus Excel s'accumulent en arrière-plan et consomment de la mémoire jusqu'au redémarrage du serveur. La question des licences est également préoccupante : le CLUF d'Office interdit l'automatisation côté serveur dans de nombreux cas de figure.

IronXL s'affranchit de toutes ces contraintes. Il s'agit d'une bibliothèque purement gérée, sans aucune dépendance à COM. L'objet WorkBook est une classe standard .NET ; Le ramasse-miettes se charge du nettoyage. Vous pouvez exécuter le même code sur un ordinateur portable de développeur, un service d'application Azure, un conteneur Docker ou un Raspberry Pi sous Linux.

Le kit de développement logiciel Open XML de Microsoft est une autre solution. Il permet d'accéder directement au format de fichier OOXML sans nécessiter Excel, mais il fonctionne à un niveau très bas : vous manipulez directement les éléments XML. La lecture de la valeur d'une seule cellule nécessite de parcourir des tables de chaînes partagées, des références de cellules et des index de style. IronXL encapsule tout cela dans l'appel à ligne unique sheet["A1"].StringValue montré tout au long de ce guide.

Comment déployer le traitement Excel sur Linux et Docker ?

C'est lors des déploiements sur serveur que l'indépendance d'IronXL vis-à-vis d'Excel prend toute sa valeur. Le même code que vous écrivez sous Windows s'exécute sans modification sous Ubuntu, Alpine Linux ou macOS. Pour les déploiements conteneurisés, votre Dockerfile ne nécessite aucune configuration particulière :

# Standard .NET runtime image -- no Office packages needed
FROM mcr.microsoft.com/dotnet/runtime:10.0
WORKDIR /app
COPY --from=build /app/publish .
ENTRYPOINT ["dotnet", "ExcelProcessor.dll"]

# Standard .NET runtime image -- no Office packages needed
FROM mcr.microsoft.com/dotnet/runtime:10.0
WORKDIR /app
COPY --from=build /app/publish .
ENTRYPOINT ["dotnet", "ExcelProcessor.dll"]

Pour Azure Functions et AWS Lambda, IronXL fonctionne dans l'environnement d'exécution géré sans aucune configuration supplémentaire. La surcharge liée au démarrage à froid est minimale car il n'y a pas d'étape d'initialisation COM.

La sécurité des threads est intégrée : plusieurs threads peuvent ouvrir différentes instances WorkBook simultanément sans coordination. Si vous devez traiter des milliers de fichiers en parallèle - par exemple, dans un travail en arrière-plan qui ingère des feuilles de calcul téléchargées par les utilisateurs - vous pouvez utiliser Parallel.ForEach ou Task.WhenAll sur un pool d'instances WorkBook sans risque de corruption.

L'utilisation de la mémoire reste prévisible car IronXL ne charge en mémoire que la feuille de calcul demandée, et non l'intégralité du classeur lors de l'initialisation. Pour les fichiers très volumineux, cette distinction est importante : un classeur contenant dix feuilles de 50 Mo ne nécessite pas 500 Mo de RAM pour lire une seule feuille. La documentation des performances d'IronXL couvre des stratégies supplémentaires pour gérer les scénarios de traitement de fichiers à haut volume.

Quelles sont vos prochaines étapes ?

La méthode la plus rapide pour valider IronXL dans votre projet consiste à installer le package NuGet et à exécuter les exemples de ce guide sur un fichier réel de votre environnement. Une licence d'essai gratuite débloque toutes les fonctionnalités sans aucune modification de code requise lorsque vous êtes prêt pour la production.

Explorez les fonctionnalités connexes IronXL qui complètent la lecture de fichiers :

• Écrire et créer des fichiers Excel en C# -- Construire des rapports et des exports de données par programme
• Formater les cellules, lignes et colonnes -- Appliquer des couleurs, polices et bordures dans le code
• Travailler avec les formules Excel en C# -- Lire et écrire des cellules de formule
• Convertir Excel en PDF en .NET -- Générer des rapports PDF à partir de données de feuilles de calcul
• Documentation de l'API IronXL : référence complète pour toutes les classes et méthodes
• Licences et tarifs IronXL : options pour les développeurs individuels et les équipes Enterprise
• Page NuGet d'IronXL -- instructions d'installation pour tous les types de projets
• Tutoriels IronXL -- Guides pas à pas pour les cas d'utilisation courants
• Comparer IronXL à EPPlus -- Comparaison côte à côte des fonctionnalités et des licences
• Page d'accueil du produit IronXL : présentation des fonctionnalités et ressources pour bien démarrer

Pour toute question relative aux licences, à la compatibilité multiplateforme ou aux exigences spécifiques en matière de format de fichier, l' équipe d'assistance IronXL est disponible par chat en direct et par e-mail.

Première étape :

Commencer gratuitement