Ouvrir et manipuler des fichiers Excel en C# est une tâche que presque tous les développeurs .NET rencontrent tôt ou tard. Qu'il s'agisse d'automatiser des rapports hebdomadaires, de traiter des importations de données ou de créer des outils générant des feuilles de calcul à la volée, la bibliothèque choisie peut avoir un impact considérable sur la vitesse, la fiabilité et la flexibilité de déploiement.
Ce tutoriel explique comment ouvrir des fichiers Excel en C# à l'aide IronXL , une bibliothèque Excel légère qui lit, modifie et écrit des classeurs sans nécessiter l'installation de Microsoft Office. Vous verrez à quel point il est simple de charger des données, d'accéder aux feuilles de calcul et de travailler avec les cellules par programmation, le tout au sein de votre application C#.
Bien que Microsoft.Office.Interop.Excel ait été l'approche traditionnelle pour l'automatisation d'Excel, elle présente des limitations importantes qui font IronXL un meilleur choix pour les applications modernes. Microsoft déconseille elle-même l'utilisation d'Office Interop sur les serveurs , invoquant des problèmes d'instabilité, d'évolutivité et des scénarios de déploiement non pris en charge.
| Caractéristique | IronXL | Microsoft.Office.Interop.Excel |
|---|---|---|
| Installation d'Excel requise | Non | Oui |
| Prise en charge multiplateforme | Windows, Linux, macOS | Windows uniquement |
| Déploiement du serveur | Entièrement pris en charge | Nonn recommandé par Microsoft |
| Gestion de la mémoire | Automatique | Nettoyage manuel du serveur COM requis |
| Complexité des API | Simple et intuitif | Interfaces COM complexes |
| Prise en charge des formats de fichiers | XLS, XLSX, CSV, TSV, JSON | Limité aux formats Excel |
| Sécurité des fils | Pris en charge | Monothread uniquement |
IronXL élimine la dépendance à Microsoft Excel, ce qui le rend idéal pour les environnements serveur, les conteneurs Docker et les plateformes cloud comme Azure . La bibliothèque fournit une API claire et moderne qui élimine la nécessité de gérer les objets COM ou la gestion manuelle de la mémoire. Au-delà de l'ouverture des fichiers, IronXL gère tout, de l'évaluation des formules à la génération de graphiques en passant par la mise en forme des cellules .
La prise en main d' IronXL est simple : il peut être ajouté à votre projet en quelques minutes via le gestionnaire de packages NuGet . Ouvrez la console du Package Manager dans Visual Studio et exécutez :
Les deux commandes installent le même paquet. Utilisez la première dans la console du gestionnaire de packages Visual Studio et la seconde avec l'interface de ligne de commande .NET . Après l'installation, vous pouvez vérifier que la référence du package apparaît dans votre fichier de projet sous <PackageReference Include="IronXL.Excel" />.
IronXL prend en charge l'ensemble des versions modernes de .NET , notamment .NET 10, .NET 8, .NET 6, .NET Framework 4.6.2 et versions ultérieures, ainsi que .NET Standard 2.0. Cette large compatibilité vous permet d'utiliser IronXL aussi bien dans les nouveaux projets ciblant .NET 10 que dans les applications existantes exécutées sur le .NET Framework traditionnel.
La bibliothèque est disponible sous la forme d'un package NuGet unique qui sélectionne automatiquement le binaire approprié pour votre framework cible. Aucune dépendance supplémentaire, aucune installation spécifique à la plateforme et aucune licence Excel requise. Consultez le guide de compatibilité IronXL pour obtenir la liste complète des environnements d'exécution et des plateformes pris en charge.
L'ouverture de fichiers Excel existants avec IronXL nécessite seulement quelques lignes de code. La bibliothèque prend en charge la lecture des fichiers XLS et XLSX , ainsi que des formats CSV et TSV, via une API unifiée. L'exemple suivant illustre le flux de travail essentiel :
// Load an existing Excel file
WorkBook workbook = WorkBook.Load("sales-data.xlsx");
// Access the first worksheet by index
WorkSheet sheet = workbook.WorkSheets[0];
// Or access a worksheet by name
WorkSheet namedSheet = workbook.GetWorkSheet("January Sales");
// Read a specific cell value
string cellValue = sheet["A1"].StringValue;
Console.WriteLine($"Cell A1 contains: {cellValue}");
// Read a numeric value
decimal revenue = sheet["B2"].DecimalValue;
Console.WriteLine($"Revenue: {revenue:C}");
// Check cell data type before reading
var cell = sheet["C3"];
Console.WriteLine($"Type: {cell.Type}, Value: {cell.Value}");' Load an existing Excel file
Dim workbook As WorkBook = WorkBook.Load("sales-data.xlsx")
' Access the first worksheet by index
Dim sheet As WorkSheet = workbook.WorkSheets(0)
' Or access a worksheet by name
Dim namedSheet As WorkSheet = workbook.GetWorkSheet("January Sales")
' Read a specific cell value
Dim cellValue As String = sheet("A1").StringValue
Console.WriteLine($"Cell A1 contains: {cellValue}")
' Read a numeric value
Dim revenue As Decimal = sheet("B2").DecimalValue
Console.WriteLine($"Revenue: {revenue:C}")
' Check cell data type before reading
Dim cell = sheet("C3")
Console.WriteLine($"Type: {cell.Type}, Value: {cell.Value}")La méthode WorkBook.Load() détecte automatiquement le format de fichier -- XLS, XLSX, CSV ou TSV -- et gère l'analyse sans configuration supplémentaire. Vous accédez aux feuilles de calcul soit par index en utilisant workbook.WorkSheets[0] ou par nom en utilisant GetWorkSheet(). Les valeurs individuelles des cellules sont lisibles via la notation entre crochets (sheet["A1"]), rendant le code concis et expressif. Pour la liste complète des types de fichiers pris en charge, consultez la documentation de l'Open XML SDK sur SpreadsheetML et la page du package NuGet IronXL.
Pour un accès typé, IronXL expose des propriétés telles que .StringValue, .DecimalValue, .IntValue, .BoolValue, et .DateTimeValue directement sur les cellules. Cela élimine la nécessité de deviner le type, fréquente avec les API génériques orientées objet. Pour des scénarios plus complexes, consultez le guide sur l'utilisation des plages Excel et la documentation sur les formats de données des cellules .
Dans les applications web et les fonctions cloud, vous recevez souvent les données de fichiers sous forme de flux ou de tableau d'octets plutôt que sous forme de chemin de fichier. IronXL gère les deux cas :
// Load from a byte array (e.g., from a database or HTTP response)
byte[] fileBytes = File.ReadAllBytes("sales-data.xlsx");
WorkBook workbookFromBytes = WorkBook.Load(fileBytes);
// Load from a MemoryStream
using var memStream = new MemoryStream(fileBytes);
WorkBook workbookFromStream = WorkBook.Load(memStream);
// Access data the same way regardless of source
WorkSheet sheet = workbookFromStream.DefaultWorkSheet;
Console.WriteLine(sheet["A1"].StringValue);Imports System
Imports System.IO
' Load from a byte array (e.g., from a database or HTTP response)
Dim fileBytes As Byte() = File.ReadAllBytes("sales-data.xlsx")
Dim workbookFromBytes As WorkBook = WorkBook.Load(fileBytes)
' Load from a MemoryStream
Using memStream As New MemoryStream(fileBytes)
Dim workbookFromStream As WorkBook = WorkBook.Load(memStream)
' Access data the same way regardless of source
Dim sheet As WorkSheet = workbookFromStream.DefaultWorkSheet
Console.WriteLine(sheet("A1").StringValue)
End UsingLe chargement basé sur le flux est particulièrement utile dans les contrôleurs ASP.NET Core où vous recevez un téléchargement IFormFile. Il suffit d'appeler formFile.OpenReadStream() et de passer le résultat à WorkBook.Load(). Pour des exemples complets d'intégration ASP.NET Core , consultez le tutoriel ASP.NET Core Excel .
Créer de nouveaux fichiers Excel est tout aussi simple grâce aux fonctionnalités de création de feuilles de calcul d'IronXL. L'exemple suivant permet de générer un rapport trimestriel formaté :
// Create a new workbook in XLSX format
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
// Add metadata
workbook.Metadata.Author = "Sales Department";
workbook.Metadata.Title = "Q1 Revenue Report";
// Create a named worksheet
WorkSheet sheet = workbook.CreateWorkSheet("Q1 Report");
// Add header row
sheet["A1"].Value = "Product";
sheet["B1"].Value = "Units Sold";
sheet["C1"].Value = "Revenue";
// Add data rows
sheet["A2"].Value = "Software Licenses";
sheet["B2"].Value = 120;
sheet["C2"].Value = 45000;
sheet["A3"].Value = "Support Contracts";
sheet["B3"].Value = 55;
sheet["C3"].Value = 27500;
// Add a SUM formula
sheet["C4"].Formula = "=SUM(C2:C3)";
// Apply number formatting
sheet["C2:C4"].FormatString = "$#,##0.00";
// Save the workbook to disk
workbook.SaveAs("quarterly-report.xlsx");
Console.WriteLine("Workbook saved successfully.");' Create a new workbook in XLSX format
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
' Add metadata
workbook.Metadata.Author = "Sales Department"
workbook.Metadata.Title = "Q1 Revenue Report"
' Create a named worksheet
Dim sheet As WorkSheet = workbook.CreateWorkSheet("Q1 Report")
' Add header row
sheet("A1").Value = "Product"
sheet("B1").Value = "Units Sold"
sheet("C1").Value = "Revenue"
' Add data rows
sheet("A2").Value = "Software Licenses"
sheet("B2").Value = 120
sheet("C2").Value = 45000
sheet("A3").Value = "Support Contracts"
sheet("B3").Value = 55
sheet("C3").Value = 27500
' Add a SUM formula
sheet("C4").Formula = "=SUM(C2:C3)"
' Apply number formatting
sheet("C2:C4").FormatString = "$#,##0.00"
' Save the workbook to disk
workbook.SaveAs("quarterly-report.xlsx")
Console.WriteLine("Workbook saved successfully.")La méthode WorkBook.Create() initialise un nouveau classeur dans le format spécifié. Vous pouvez ajouter plusieurs feuilles de calcul en utilisant CreateWorkSheet(), remplir les cellules avec divers types de données, y compris des chaînes, des nombres, des booléens et des dates, et appliquer des formules Excel directement via la propriété Formula. La bibliothèque gère automatiquement la conversion des types de données et les exigences de mise en forme spécifiques à Excel.
Pour styliser les en-têtes et ajouter des bordures, utilisez l' API de style de cellule . Pour la génération de rapports à partir de modèles, consultez le guide d'exportation à partir de modèles Excel existants .
IronXL gère efficacement l'extraction et le traitement en masse des données grâce à des opérations basées sur les plages et la conversion de DataTable :
// Load a workbook and select the default sheet
WorkBook workbook = WorkBook.Load("inventory.xlsx");
WorkSheet sheet = workbook.DefaultWorkSheet;
// Read a rectangular range of cells
var range = sheet["A1:D10"];
foreach (var cell in range)
{
Console.WriteLine($"{cell.AddressString}: {cell.Text}");
}
// Convert the worksheet to a DataTable for database integration
System.Data.DataTable dataTable = sheet.ToDataTable(useFirstRowAsColumnHeaders: true);
Console.WriteLine($"Rows: {dataTable.Rows.Count}, Columns: {dataTable.Columns.Count}");
// Use aggregate functions directly on a range
decimal total = sheet["C2:C10"].Sum();
decimal average = sheet["C2:C10"].Avg();
decimal maxValue = sheet["C2:C10"].Max();
Console.WriteLine($"Total: {total:C}");
Console.WriteLine($"Average: {average:C}");
Console.WriteLine($"Max: {maxValue:C}");
// Filter and find rows using LINQ on the DataTable
var highValue = dataTable.AsEnumerable()
.Where(row => row.Field<decimal>("Revenue") > 10000)
.ToList();
Console.WriteLine($"High-value rows: {highValue.Count}");Imports System
Imports System.Data
Imports System.Linq
' Load a workbook and select the default sheet
Dim workbook As WorkBook = WorkBook.Load("inventory.xlsx")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
' Read a rectangular range of cells
Dim range = sheet("A1:D10")
For Each cell In range
Console.WriteLine($"{cell.AddressString}: {cell.Text}")
Next
' Convert the worksheet to a DataTable for database integration
Dim dataTable As DataTable = sheet.ToDataTable(useFirstRowAsColumnHeaders:=True)
Console.WriteLine($"Rows: {dataTable.Rows.Count}, Columns: {dataTable.Columns.Count}")
' Use aggregate functions directly on a range
Dim total As Decimal = sheet("C2:C10").Sum()
Dim average As Decimal = sheet("C2:C10").Avg()
Dim maxValue As Decimal = sheet("C2:C10").Max()
Console.WriteLine($"Total: {total:C}")
Console.WriteLine($"Average: {average:C}")
Console.WriteLine($"Max: {maxValue:C}")
' Filter and find rows using LINQ on the DataTable
Dim highValue = dataTable.AsEnumerable() _
.Where(Function(row) row.Field(Of Decimal)("Revenue") > 10000) _
.ToList()
Console.WriteLine($"High-value rows: {highValue.Count}")La syntaxe de sélection de plage (sheet["A1:D10"]) offre une manière élégante de travailler avec plusieurs cellules à la fois. La méthode ToDataTable() convertit les données de la feuille de calcul en un System.Data.DataTable, qui s'intègre directement avec Entity Framework, les contrôles de liaison de données et les opérations de copie massive SQL. IronXL prend également en charge les fonctions d'agrégation -- Sum(), Avg(), Max(), et Min() -- directement sur les plages, éliminant le besoin d'écrire du code d'itération manuelle.
Pour traiter efficacement de très grands ensembles de données, consultez la documentation complète de l'API IronXL pour les modèles de traitement en flux continu et par blocs.
Au-delà de l'accès par plage, IronXL vous permet de rechercher des cellules par valeur, d'appliquer une logique conditionnelle et d'itérer sur les lignes et les colonnes par programmation :
WorkBook workbook = WorkBook.Load("products.xlsx");
WorkSheet sheet = workbook.DefaultWorkSheet;
// Get total row and column counts
int rowCount = sheet.RowCount;
int colCount = sheet.ColumnCount;
Console.WriteLine($"Sheet dimensions: {rowCount} rows x {colCount} columns");
// Iterate over all rows and columns
for (int row = 1; row <= rowCount; row++)
{
for (int col = 1; col <= colCount; col++)
{
var cell = sheet.GetCellAt(row, col);
if (cell != null && !string.IsNullOrEmpty(cell.Text))
{
Console.WriteLine($"[{row},{col}] = {cell.Text}");
}
}
}
// Find the first cell containing specific text
var searchResult = sheet["A1:Z100"]
.FirstOrDefault(c => c.StringValue.Contains("discontinued", StringComparison.OrdinalIgnoreCase));
if (searchResult != null)
{
Console.WriteLine($"Found 'discontinued' at: {searchResult.AddressString}");
}Imports System
Imports System.Linq
Dim workbook As WorkBook = WorkBook.Load("products.xlsx")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
' Get total row and column counts
Dim rowCount As Integer = sheet.RowCount
Dim colCount As Integer = sheet.ColumnCount
Console.WriteLine($"Sheet dimensions: {rowCount} rows x {colCount} columns")
' Iterate over all rows and columns
For row As Integer = 1 To rowCount
For col As Integer = 1 To colCount
Dim cell = sheet.GetCellAt(row, col)
If cell IsNot Nothing AndAlso Not String.IsNullOrEmpty(cell.Text) Then
Console.WriteLine($"[{row},{col}] = {cell.Text}")
End If
Next
Next
' Find the first cell containing specific text
Dim searchResult = sheet("A1:Z100") _
.FirstOrDefault(Function(c) c.StringValue.Contains("discontinued", StringComparison.OrdinalIgnoreCase))
If searchResult IsNot Nothing Then
Console.WriteLine($"Found 'discontinued' at: {searchResult.AddressString}")
End IfCe schéma est courant dans les flux de travail de validation des données où il est nécessaire d'analyser un fichier téléchargé à la recherche de valeurs spécifiques avant de poursuivre son traitement. Pour les cas d'utilisation de filtrage avancés, consultez la documentation sur la sélection de plages dans Excel .
L'un des avantages les plus pratiques de l'utilisation IronXL est sa capacité à fonctionner sans que Microsoft Office soit installé sur le système. Cela crée une flexibilité de déploiement que les solutions basées sur l'interopérabilité ne peuvent tout simplement pas égaler :
IronXL fonctionne sur Azure App Service , AWS Lambda et Google Cloud Run sans aucune configuration particulière. Comme il ne dépend d'aucune application Office, vous évitez à la fois les coûts de licence et la complexité liés à l'inclusion d'Office dans une image conteneur. Un Dockerfile minimal pour une application .NET 10 utilisant IronXL ne nécessite que l'image d'exécution .NET standard.
Le déploiement basé sur Docker est tout aussi simple. Le guide Docker IronXL couvre les configurations de conteneurs Debian, Alpine et Windows. Dans tous les cas, IronXL s'installe via NuGet et fonctionne sans paquets système supplémentaires.
Les environnements serveur sont souvent dépourvus d'interface graphique et ne peuvent pas exécuter d'applications qui dépendent d'une session de bureau Windows. IronXL fonctionne entièrement en mode sans interface graphique, ce qui le rend adapté à :
Pour ASP.NET Core en particulier, consultez le tutoriel d'exportation Excel ASP.NET Core , qui traite du flux de fichiers, des en-têtes de réponse et des modèles de suppression appropriés.
IronXL cible .NET Standard 2.0 et s'exécute nativement sous Linux et macOS, permettant des flux de travail de développement multiplateformes. Les développeurs sous macOS peuvent écrire et tester localement du code de génération Excel en ayant l'assurance que le même fichier binaire fonctionnera de manière identique sur un serveur de production Linux. Aucune API spécifique à la plateforme ni aucun bloc de compilation conditionnelle ne sont requis.
Pour plus de détails sur les environnements pris en charge, consultez la présentation de la prise en main d'IronXL.
Lire et écrire les cellules ne représente que la base. L'automatisation concrète d'Excel implique généralement la mise en forme, les formules, la gestion des feuilles de calcul et la conversion de format.
IronXL expose une API de style complète couvrant les polices, les couleurs, les bordures, l'alignement et les formats numériques :
WorkBook workbook = WorkBook.Load("report.xlsx");
WorkSheet sheet = workbook.DefaultWorkSheet;
// Apply bold, font size, and background color to header row
var headerRange = sheet["A1:F1"];
headerRange.Style.Font.Bold = true;
headerRange.Style.Font.Height = 12;
headerRange.Style.SetBackgroundColor("#4472C4");
headerRange.Style.Font.Color = "#FFFFFF";
headerRange.Style.HorizontalAlignment = IronXL.Styles.HorizontalAlignment.Center;
// Format a currency column
sheet["D2:D100"].FormatString = "$#,##0.00";
// Apply a date format
sheet["E2:E100"].FormatString = "yyyy-MM-dd";
// Add borders to a data range
var dataRange = sheet["A1:F20"];
dataRange.Style.Border.Bottom.Type = IronXL.Styles.BorderType.Thin;
dataRange.Style.Border.Right.Type = IronXL.Styles.BorderType.Thin;
workbook.SaveAs("formatted-report.xlsx");Imports IronXL
Dim workbook As WorkBook = WorkBook.Load("report.xlsx")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
' Apply bold, font size, and background color to header row
Dim headerRange = sheet("A1:F1")
headerRange.Style.Font.Bold = True
headerRange.Style.Font.Height = 12
headerRange.Style.SetBackgroundColor("#4472C4")
headerRange.Style.Font.Color = "#FFFFFF"
headerRange.Style.HorizontalAlignment = IronXL.Styles.HorizontalAlignment.Center
' Format a currency column
sheet("D2:D100").FormatString = "$#,##0.00"
' Apply a date format
sheet("E2:E100").FormatString = "yyyy-MM-dd"
' Add borders to a data range
Dim dataRange = sheet("A1:F20")
dataRange.Style.Border.Bottom.Type = IronXL.Styles.BorderType.Thin
dataRange.Style.Border.Right.Type = IronXL.Styles.BorderType.Thin
workbook.SaveAs("formatted-report.xlsx")Pour une présentation complète des options de style, consultez la section sur la mise en forme des cellules, des bordures et des polices .
IronXL gère directement la conversion de format, vous permettant de charger un fichier CSV et de l'enregistrer au format XLSX, ou d'exporter un fichier XLSX au format CSV pour un traitement ultérieur :
// Load a CSV file and save as XLSX
WorkBook csvBook = WorkBook.Load("data-import.csv");
csvBook.SaveAs("data-import.xlsx");
// Load an XLSX file and export as CSV
WorkBook xlsxBook = WorkBook.Load("report.xlsx");
xlsxBook.DefaultWorkSheet.SaveAsCsv("report.csv");' Load a CSV file and save as XLSX
Dim csvBook As WorkBook = WorkBook.Load("data-import.csv")
csvBook.SaveAs("data-import.xlsx")
' Load an XLSX file and export as CSV
Dim xlsxBook As WorkBook = WorkBook.Load("report.xlsx")
xlsxBook.DefaultWorkSheet.SaveAsCsv("report.csv")Pour plus de détails sur la gestion des fichiers CSV, y compris la configuration des délimiteurs et les options d'encodage, consultez le tutoriel sur le lecteur CSV C# et le guide de conversion CSV vers XLSX .
IronXL est disponible en téléchargement avec une licence de développement gratuite qui vous permet de tester l'ensemble des fonctionnalités avant de procéder à un achat. Aucune restriction de fonctionnalités n'est appliquée pendant la période d'essai : vous évaluez la même bibliothèque que celle utilisée en production.
Pour commencer :
Installez le package via NuGet:
Consultez la page de licence IronXL pour obtenir une clé d'essai gratuite.
Appliquez la clé dans le code avant tout appel à IronXL :
IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";Imports IronXL
IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"Des licences sont disponibles pour les développeurs individuels, les équipes et les organisations. La page produit IronXL fournit tous les détails concernant les prix et les options de déploiement, y compris les droits de distribution sans redevance. Pour une vue d'ensemble plus complète de tous les produits Iron Software et de leur intégration, consultez la Suite de produits Iron Software .
Curtis Chau détient un baccalauréat en informatique (Université de Carleton) et se spécialise dans le développement front-end avec expertise en Node.js, TypeScript, JavaScript et React. Passionné par la création d'interfaces utilisateur intuitives et esthétiquement plaisantes, Curtis aime travailler avec des frameworks modernes et créer des manuels bien structurés et visuellement attrayants.
IronXL fait partie de IRONSUITE
10 API .NET pour vos documents
L'API Excel dont vous avez besoin, sans tracas Interop Office.
