Comment importer des données Excel en C# avec IronXL

Comment installer IronXL et commencer à importer des fichiers Excel ?

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.

Comment importer, lire et manipuler facilement des données de fichiers MS Excel en C# avec IronXL: Image 2 - Multiplateforme

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" :

Install-Package IronXL
dotnet add package IronXL

Install-Package IronXL
dotnet add package 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);

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);

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 du fichier (XLS, XLSX ou CSV). La syntaxe intuitive de l'indexeur sheet["B1"] rend l'accès aux cellules aussi naturel que la manipulation de tableaux. Pour une référence complète des membres et surcharges disponibles, consultez la documentation de l'API IronXL .

Comment lire des données Excel et les convertir en objets C# ?

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 de calcul et associe chaque ligne à un objet Product saisi :

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}"
    );
}

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}"
    );
}

Les 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.

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);
}

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);
}

Comment convertir un fichier Excel en DataTable en C# ?

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. Étant donné 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 de 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);
}

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);
}

La méthode ToDataTable() accepte un paramètre booléen indiquant si la première ligne contient des en-têtes. Lorsque la valeur 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();
}

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();
}

Cette approche vous offre une flexibilité totale lors de l'importation. Les valeurs nulles sont gérées avec élégance en les convertissant en DBNull.Value, assurant ainsi la compatibilité avec les contraintes des colonnes 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 .

Comment travaillez-vous avec les formules, les classeurs à plusieurs feuilles et Entity Framework ?

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)"

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)"

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.");

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.");

Comment gérez-vous la mise en forme des cellules lors de l'importation ?

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}");
}

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}");
}

Pour 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 .

Comment choisir la licence IronXL adaptée à votre projet ?

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 :

• Droits de redistribution libres de redevances
• Assistance prioritaire de l'équipe de développement IronXL
• Accès à toutes les mises à jour, y compris les mises à jour mineures, pendant la période de licence.

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.