Travailler avec des fichiers Microsoft Excel est une exigence quotidienne pour de nombreux développeurs .NET. Qu'il s'agisse d'importer des données clients, de traiter des rapports financiers ou de migrer des données de feuilles de calcul vers des bases de données, les développeurs ont besoin d'un moyen fiable de lire les fichiers Excel sans dépendances complexes ni nécessité d'installer Excel. Les approches traditionnelles, telles que l'automatisation COM via Microsoft.Office.Interop, nécessitent une installation complète d'Office, introduisent des restrictions de plateforme et créent des dépendances de déploiement fragiles. IronXL offre une solution simple et multiplateforme, éliminant tous ces problèmes et permettant d'effectuer des opérations Excel directement à partir de code .NET managé.
Se lancer dans l'importation d'Excel en C# ne prend que quelques minutes avec IronXL. La bibliothèque Excel prend en charge les formats XLS (anciens formats) et XLSX (formats modernes), ainsi que les formats CSV , TSV et autres formats de feuilles de calcul. Contrairement aux solutions qui reposent sur Microsoft.Office.Interop.Excel, IronXL fonctionne de manière indépendante sur n'importe quelle plateforme .NET ou .NET Core.
Installez IronXL via le gestionnaire de packages NuGet ou l'interface de ligne de commande .NET . Vous pouvez également utiliser la boîte de dialogue Gérer les packages NuGet dans Visual Studio et rechercher "IronXL" :
Pour plus de détails sur l'installation, y compris les notes de compatibilité de version et de dépendance, reportez-vous au guide d'installation NuGet IronXL . Aucune dépendance d'exécution supplémentaire ni composant Office n'est requis : le package est autonome. Une fois le logiciel installé, l'importation des données Excel est simple :
using IronXL;
// Load any Excel file
WorkBook workBook = WorkBook.Load("ProductData.xlsx");
// Access the first worksheet
WorkSheet sheet = workBook.WorkSheets[0];
// Read a cell value
string value = sheet["B1"].StringValue;
Console.WriteLine(value);Imports IronXL
' Load any Excel file
Dim workBook As WorkBook = WorkBook.Load("ProductData.xlsx")
' Access the first worksheet
Dim sheet As WorkSheet = workBook.WorkSheets(0)
' Read a cell value
Dim value As String = sheet("B1").StringValue
Console.WriteLine(value)Ce code démontre le flux de travail principal : chargement d'un classeur, accès à une feuille de calcul et lecture des valeurs des cellules. La méthode WorkBook.Load() détecte automatiquement le format de fichier - qu'il s'agisse de XLS, XLSX ou CSV. La syntaxe d'indexeur intuitive sheet["B1"] permet d'accéder aux cellules aussi naturellement que le travail avec des tableaux. Pour une liste complète des membres et surcharges disponibles, consultez la documentation de l'API IronXL .
Les applications réelles ont besoin de plus que de valeurs unicellulaires. IronXL excelle dans l'importation d'ensembles de données entiers et leur conversion en objets C# utilisables. Lorsque vous devez importer des données Excel structurées , la bibliothèque propose plusieurs approches qui correspondent directement à vos modèles de domaine.
L'exemple ci-dessous lit les lignes d'une feuille et mappe chaque ligne à un objet typé Product :
using IronXL;
// Load the Excel file
WorkBook workBook = WorkBook.Load("ProductData.xlsx");
WorkSheet sheet = workBook.DefaultWorkSheet;
// Map rows to typed objects
var products = new List<Product>();
foreach (var row in sheet.Rows)
{
var product = new Product
{
Id = row.Columns[0].IntValue,
Name = row.Columns[1].StringValue,
Price = row.Columns[2].DecimalValue,
IsAvailable = row.Columns[3].BoolValue
};
products.Add(product);
}
foreach (var product in products)
{
Console.WriteLine(
$"Id: {product.Id}, Name: {product.Name}, " +
$"Price: {product.Price}, Available: {product.IsAvailable}"
);
}Imports IronXL
' Load the Excel file
Dim workBook As WorkBook = WorkBook.Load("ProductData.xlsx")
Dim sheet As WorkSheet = workBook.DefaultWorkSheet
' Map rows to typed objects
Dim products As New List(Of Product)()
For Each row In sheet.Rows
Dim product As New Product With {
.Id = row.Columns(0).IntValue,
.Name = row.Columns(1).StringValue,
.Price = row.Columns(2).DecimalValue,
.IsAvailable = row.Columns(3).BoolValue
}
products.Add(product)
Next
For Each product In products
Console.WriteLine(
$"Id: {product.Id}, Name: {product.Name}, " &
$"Price: {product.Price}, Available: {product.IsAvailable}"
)
NextLes propriétés typées - IntValue, StringValue, DecimalValue, et BoolValue - gèrent automatiquement la conversion de type. Cette approche élimine l'analyse manuelle et réduit les erreurs lors du traitement de colonnes de types de données mixtes. De nombreux développeurs sur Stack Overflow apprécient cette méthode sécurisée d'importation de données Excel.
Pour les calculs agrégés et les requêtes filtrées, IronXL prend en charge les opérations sur les plages avec une compatibilité LINQ intégrée :
using IronXL;
WorkBook workBook = WorkBook.Load("ProductData.xlsx");
WorkSheet sheet = workBook.DefaultWorkSheet;
// Read a named cell range
Range dataRange = sheet["A1:D5"];
// Calculate aggregates directly on a range
decimal sum = sheet["C1:C5"].Sum();
Console.WriteLine($"Sum of C1:C5: {sum}");
decimal max = sheet["C1:C5"].Max(c => c.DecimalValue);
Console.WriteLine($"Max of C1:C5: {max}");
// Filter using LINQ
var highValueOrders = dataRange
.Where(cell => cell.DecimalValue > 100)
.Select(cell => cell.Value)
.ToList();
Console.WriteLine("Orders above 100:");
foreach (var order in highValueOrders)
{
Console.WriteLine(order);
}Imports IronXL
Dim workBook As WorkBook = WorkBook.Load("ProductData.xlsx")
Dim sheet As WorkSheet = workBook.DefaultWorkSheet
' Read a named cell range
Dim dataRange As Range = sheet("A1:D5")
' Calculate aggregates directly on a range
Dim sum As Decimal = sheet("C1:C5").Sum()
Console.WriteLine($"Sum of C1:C5: {sum}")
Dim max As Decimal = sheet("C1:C5").Max(Function(c) c.DecimalValue)
Console.WriteLine($"Max of C1:C5: {max}")
' Filter using LINQ
Dim highValueOrders = dataRange _
.Where(Function(cell) cell.DecimalValue > 100) _
.Select(Function(cell) cell.Value) _
.ToList()
Console.WriteLine("Orders above 100:")
For Each order In highValueOrders
Console.WriteLine(order)
NextLa classe Range offre un accès de type collection à plusieurs cellules simultanément. La compatibilité LINQ signifie que vous pouvez filtrer, transformer et agréger les données Excel en utilisant des modèles C# familiers sans avoir à convertir d'abord en collections intermédiaires. Les méthodes d'agrégation intégrées telles que Sum() et Max() opèrent directement sur les plages de cellules. Pour plus de détails sur la lecture des données d'un classeur, consultez le guide IronXL sur la lecture des fichiers Excel .
La conversion de DataTable est essentielle pour les opérations de base de données et les scénarios de liaison de données. IronXL fournit des méthodes intégrées qui gèrent la conversion d' Excel en DataSet ou DataTable . Cette fonctionnalité est particulièrement utile lorsque vous devez importer des feuilles de calcul Excel dans SQL Server ou d'autres bases de données relationnelles. Parce que l'objet résultant est un System.Data.DataTable standard, il fonctionne avec n'importe quel chemin de code compatible ADO.NET sans nécessiter de modifications à votre couche d'accès aux données.
using IronXL;
using System.Data;
using System.Data.SqlClient;
// Load Excel file
WorkBook workBook = WorkBook.Load("inventory.xlsx");
// Select the first worksheet
WorkSheet sheet = workBook.WorkSheets.First();
// Convert to DataTable -- first row becomes column headers
DataTable dataTable = sheet.ToDataTable(true);
// Use SqlBulkCopy to insert directly into SQL Server
string connectionString = "Data Source=.;Initial Catalog=InventoryDB;Integrated Security=True;";
using (SqlBulkCopy bulkCopy = new SqlBulkCopy(connectionString))
{
bulkCopy.DestinationTableName = "Inventory";
bulkCopy.WriteToServer(dataTable);
}Imports IronXL
Imports System.Data
Imports System.Data.SqlClient
' Load Excel file
Dim workBook As WorkBook = WorkBook.Load("inventory.xlsx")
' Select the first worksheet
Dim sheet As WorkSheet = workBook.WorkSheets.First()
' Convert to DataTable -- first row becomes column headers
Dim dataTable As DataTable = sheet.ToDataTable(True)
' Use SqlBulkCopy to insert directly into SQL Server
Dim connectionString As String = "Data Source=.;Initial Catalog=InventoryDB;Integrated Security=True;"
Using bulkCopy As New SqlBulkCopy(connectionString)
bulkCopy.DestinationTableName = "Inventory"
bulkCopy.WriteToServer(dataTable)
End UsingLa méthode ToDataTable() accepte un paramètre booléen qui indique si la première ligne contient des en-têtes. Lorsqu'elle est définie sur true, IronXL utilise automatiquement les valeurs de la première ligne comme noms de colonnes. Le DataTable ainsi obtenu s'intègre à .NET, Entity Framework et aux contrôles de liaison de données sans aucune configuration supplémentaire.
Pour un contrôle plus précis du processus de conversion, vous pouvez créer la DataTable manuellement :
using IronXL;
using System.Data;
WorkBook workBook = WorkBook.Load("inventory.xlsx");
WorkSheet sheet = workBook.WorkSheets.First();
// Build DataTable manually for custom column types or validation
DataTable customTable = new DataTable();
for (int col = 0; col < sheet.ColumnCount; col++)
{
customTable.Columns.Add($"Column{col + 1}", typeof(string));
}
foreach (var row in sheet.Rows)
{
var dataRow = customTable.NewRow();
for (int col = 0; col < sheet.ColumnCount; col++)
{
dataRow[col] = row.Columns[col].Value ?? DBNull.Value;
}
customTable.Rows.Add(dataRow);
}
// Print headers
foreach (DataColumn column in customTable.Columns)
{
Console.Write($"{column.ColumnName}\t");
}
Console.WriteLine();
// Print data rows
foreach (DataRow row in customTable.Rows)
{
foreach (var item in row.ItemArray)
{
Console.Write($"{item}\t");
}
Console.WriteLine();
}Imports IronXL
Imports System.Data
Dim workBook As WorkBook = WorkBook.Load("inventory.xlsx")
Dim sheet As WorkSheet = workBook.WorkSheets.First()
' Build DataTable manually for custom column types or validation
Dim customTable As New DataTable()
For col As Integer = 0 To sheet.ColumnCount - 1
customTable.Columns.Add($"Column{col + 1}", GetType(String))
Next
For Each row In sheet.Rows
Dim dataRow = customTable.NewRow()
For col As Integer = 0 To sheet.ColumnCount - 1
dataRow(col) = If(row.Columns(col).Value, DBNull.Value)
Next
customTable.Rows.Add(dataRow)
Next
' Print headers
For Each column As DataColumn In customTable.Columns
Console.Write($"{column.ColumnName}" & vbTab)
Next
Console.WriteLine()
' Print data rows
For Each row As DataRow In customTable.Rows
For Each item In row.ItemArray
Console.Write($"{item}" & vbTab)
Next
Console.WriteLine()
NextCette approche vous offre une flexibilité totale lors de l'importation. Les valeurs nulles sont traitées avec soin en les convertissant en DBNull.Value, ce qui assure la compatibilité avec les contraintes de colonne de la base de données. Pour plus d'informations sur la réécriture des données dans des fichiers, consultez le guide IronXL sur l'écriture de fichiers Excel .
IronXL va au-delà de la simple lecture grâce à des fonctionnalités adaptées à des scénarios complexes du monde réel. La bibliothèque préserve les formules Excel, permettant ainsi d'évaluer les calculs de manière dynamique. Pour les développeurs travaillant avec des classeurs Excel complexes , cela permet de maintenir l'intégrité des données tout au long du processus d'importation.
using IronXL;
WorkBook workBook = WorkBook.Load("FinancialReport.xlsx");
WorkSheet sheet = workBook.GetWorkSheet("Reports");
// Read the evaluated result of a formula cell
decimal calculatedTotal = sheet["E10"].DecimalValue;
Console.WriteLine($"Total: {calculatedTotal}");
// Read the formula string itself
string formula = sheet["E10"].Formula;
Console.WriteLine($"Formula: {formula}"); // e.g. "=SUM(E2:E9)"Imports IronXL
Dim workBook As WorkBook = WorkBook.Load("FinancialReport.xlsx")
Dim sheet As WorkSheet = workBook.GetWorkSheet("Reports")
' Read the evaluated result of a formula cell
Dim calculatedTotal As Decimal = sheet("E10").DecimalValue
Console.WriteLine($"Total: {calculatedTotal}")
' Read the formula string itself
Dim formula As String = sheet("E10").Formula
Console.WriteLine($"Formula: {formula}") ' e.g. "=SUM(E2:E9)"La prise en charge des formules permet d'importer des fichiers Excel contenant des calculs complexes sans avoir à recréer la logique métier dans le code. La bibliothèque évalue automatiquement les formules, renvoyant les valeurs calculées tout en préservant la chaîne de caractères de la formule originale. Cela s'avère inestimable lors de l'importation de modèles financiers ou de modèles de rapports contenant des formules imbriquées.
La compatibilité multiplateforme garantit un comportement cohérent dans les environnements Windows, Linux, macOS et les conteneurs. Cela rend IronXL parfaitement adapté aux déploiements cloud et aux microservices où l'installation d'Office n'est pas possible. La documentation de la .NET Foundation souligne comment les applications .NET modernes bénéficient de l'indépendance de la plateforme.
L'intégration d'Entity Framework crée des pipelines directs entre Excel et la base de données. Le modèle suivant fonctionne parfaitement avec les instructions de niveau supérieur de .NET 10 :
using IronXL;
WorkBook workBook = WorkBook.Load("ProductData.xlsx");
WorkSheet sheet = workBook.DefaultWorkSheet;
// Skip the header row, map remaining rows to entity objects
var products = sheet.Rows
.Skip(1)
.Select(row => new Product
{
Name = row.Columns[0].StringValue,
Price = row.Columns[1].DecimalValue
})
.ToList();
using var context = new AppDbContext();
await context.Products.AddRangeAsync(products);
await context.SaveChangesAsync();
Console.WriteLine($"Imported {products.Count} products.");Imports IronXL
Dim workBook As WorkBook = WorkBook.Load("ProductData.xlsx")
Dim sheet As WorkSheet = workBook.DefaultWorkSheet
' Skip the header row, map remaining rows to entity objects
Dim products = sheet.Rows _
.Skip(1) _
.Select(Function(row) New Product With {
.Name = row.Columns(0).StringValue,
.Price = row.Columns(1).DecimalValue
}) _
.ToList()
Using context As New AppDbContext()
Await context.Products.AddRangeAsync(products)
Await context.SaveChangesAsync()
End Using
Console.WriteLine($"Imported {products.Count} products.")Ce modèle permet une migration directe d'Excel vers une base de données avec un minimum de code, ce qui le rend parfaitement adapté aux processus ETL, aux migrations de données ponctuelles et aux tâches d'importation planifiées. Comme la projection LINQ s'exécute en mémoire avant l'enregistrement du contexte, vous pouvez appliquer une logique de validation ou de transformation simultanément. Pour créer des fichiers Excel à partir de données C#, consultez le guide IronXL sur la création de fichiers Excel .
IronXL prend en charge un large éventail de formats de feuilles de calcul sans nécessiter de bibliothèques supplémentaires ni d'installation d'Office. Le tableau suivant récapitule les formats pris en charge et leurs cas d'utilisation :
| Format | Extension du champ d'application | Remarques |
|---|---|---|
| Classeur Excel | .xlsx | Format par défaut pour Excel 2007 et versions ultérieures |
| Classeur Excel hérité | .xls | Compatible avec les anciennes versions d'Excel |
| Valeurs séparées par des virgules | .csv | Données tabulaires en texte brut, largement prises en charge |
| Valeurs séparées par des tabulations | .tsv | Convient aux données contenant des virgules. |
| Classeur binaire Excel | .xlsb | Format binaire compact pour les fichiers volumineux |
Pour exporter à nouveau les données dans ces formats, consultez le guide d'exportation Excel IronXL .
Lors de l'importation de fichiers Excel, la préservation ou l'inspection de la mise en forme des cellules est souvent aussi importante que la lecture des valeurs brutes. IronXL expose les propriétés de police, de couleur, d'alignement et de bordure pour chaque cellule, ce qui vous permet d'appliquer des règles de validation ou de reproduire des styles par programmation. Ceci est particulièrement utile pour les rapports où la mise en forme visuelle a une signification sémantique, par exemple, des cellules colorées indiquant les niveaux de risque ou des lignes en gras indiquant les totaux.
Par exemple, vous pourriez vouloir vérifier si les cellules contiennent du texte en gras — un signal courant indiquant qu'une ligne est une ligne de résumé ou de total — avant de décider de l'inclure dans votre ensemble de données importé :
using IronXL;
WorkBook workBook = WorkBook.Load("StyledReport.xlsx");
WorkSheet sheet = workBook.DefaultWorkSheet;
foreach (var row in sheet.Rows)
{
var firstCell = row.Columns[0];
// Skip rows where the first cell is bold (typically header or total rows)
if (firstCell.Style.Font.Bold)
{
continue;
}
Console.WriteLine($"Data row: {firstCell.StringValue}");
}Imports IronXL
Dim workBook As WorkBook = WorkBook.Load("StyledReport.xlsx")
Dim sheet As WorkSheet = workBook.DefaultWorkSheet
For Each row In sheet.Rows
Dim firstCell = row.Columns(0)
' Skip rows where the first cell is bold (typically header or total rows)
If firstCell.Style.Font.Bold Then
Continue For
End If
Console.WriteLine($"Data row: {firstCell.StringValue}")
NextPour une référence complète sur la mise en forme des cellules et des plages, y compris les chaînes de format numérique et l'accès à la couleur d'arrière-plan, consultez le guide de mise en forme des cellules IronXL . Vous pouvez également appliquer des opérations de fusion aux fichiers de sortie après traitement – consultez le guide de fusion des cellules IronXL .
IronXL propose des options de licence flexibles adaptées à l'envergure de votre projet. Une licence d'essai gratuite est disponible pour évaluation, vous donnant accès à toutes les fonctionnalités sans restriction de temps pendant le développement. La version d'essai ajoute un filigrane aux fichiers de sortie, qui est supprimé avec une licence de production valide.
Pour les équipes développant des applications de production, les licences IronXL incluent des options pour les développeurs individuels, les équipes et les déploiements à l'échelle de l'organisation. Toutes les licences de production incluent :
Si vous évaluez IronXL en parallèle avec d'autres bibliothèques Excel, la présentation des fonctionnalités IronXL fournit une description détaillée de ce qui est inclus à chaque niveau.
Pour commencer à utiliser IronXL dans votre projet dès aujourd'hui, consultez la page produit IronXL ou commencez directement par la documentation IronXL pour obtenir des guides d'installation, des articles pratiques et des références API couvrant toutes les fonctionnalités de la bibliothèque.
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.
