Importer un fichier CSV en C# avec ASP.NET Core implique de lire un flux de fichier, d'analyser des lignes délimitées et de mapper chaque enregistrement à un objet typé — tout cela avant de pouvoir faire quoi que ce soit d'utile avec les données. IronXL gère chaque étape grâce à une API unique qui fonctionne aussi bien pour les fichiers CSV, XLSX et TSV, vous permettant ainsi de consacrer votre temps à la logique de votre application plutôt qu'à la gestion de cas particuliers liés au fractionnement de chaînes de caractères.
Démarrez votre essai gratuit pour suivre et tester ces exemples de code dans votre propre environnement.
Avant d'écrire le moindre code d'analyse syntaxique, ajoutez IronXL à votre projet. Ouvrez la console du gestionnaire de packages dans Visual Studio ou un terminal dans le répertoire de votre projet et exécutez l'une des commandes suivantes :
Ce package cible .NET 10, .NET 6+, .NET Framework 4.6.2+ et .NET Standard 2.0, il convient donc à tout type de projet moderne. Aucune installation de Microsoft Office n'est requise sur le serveur. Après la restauration du package, ajoutez using IronXL; en haut de tout fichier qui appelle la bibliothèque.
Pour des options de configuration détaillées, y compris l'installation globale des outils et la configuration du pipeline CI/CD, consultez le guide d'installation IronXL .
L'importation d'un fichier CSV dans ASP.NET Core nécessite la lecture du flux de fichiers depuis le serveur, l'analyse de chaque ligne et le mappage des valeurs à une classe de modèle. Alors que certains développeurs se tournent vers des implémentations StreamReader manuelles ou des packages tiers, IronXL fournit une méthode unique qui gère les fichiers CSV ainsi que les formats Excel sans configuration supplémentaire.
Le code suivant montre comment charger un fichier CSV en utilisant la méthode WorkBook.LoadCSV d'IronXL :
using IronXL;
// Load the CSV file directly using the full file path
var csv = WorkBook.LoadCSV("products.csv");
WorkSheet worksheet = csv.DefaultWorkSheet;
// Access CSV data by iterating through rows
foreach (var row in worksheet.Rows)
{
string productName = row.Columns[1].StringValue;
decimal price = row.Columns[2].DecimalValue;
Console.WriteLine($"Product: {productName}, Price: {price}");
}Imports IronXL
' Load the CSV file directly using the full file path
Dim csv = WorkBook.LoadCSV("products.csv")
Dim worksheet As WorkSheet = csv.DefaultWorkSheet
' Access CSV data by iterating through rows
For Each row In worksheet.Rows
Dim productName As String = row.Columns(1).StringValue
Dim price As Decimal = row.Columns(2).DecimalValue
Console.WriteLine($"Product: {productName}, Price: {price}")
NextLa méthode WorkBook.LoadCSV lit le fichier CSV et crée une feuille de calcul où chaque ligne devient une ligne et chaque valeur délimitée devient une cellule. IronXL détecte automatiquement le délimiteur (virgule, point-virgule ou tabulation) et gère les champs entre guillemets contenant des virgules dans leur valeur. Vous n'avez pas besoin de configurer manuellement un délimiteur pour les fichiers CSV standard.
Les accesseurs de valeurs de cellule comme StringValue, DecimalValue, IntValue, et DateTimeValue gèrent la conversion des types pour éviter l'analyse manuelle avec int.TryParse ou decimal.Parse. Lorsqu'une cellule est vide ou contient une valeur non reconnue, ces accesseurs renvoient la valeur par défaut du type plutôt que de lever une exception, ce qui évite les erreurs non gérées lors des opérations d'importation en masse.
Cette approche élimine l'analyse manuelle des chaînes de caractères, source d'erreurs, que nécessitent les implémentations personnalisées, notamment pour les cas particuliers comme les guillemets échappés, les fins de ligne de style Windows et les valeurs de cellules multilignes. Pour plus de détails sur les formats pris en charge et les options de délimiteurs, consultez la documentation CSV IronXL .
La conversion des données CSV en objets fortement typés nécessite une classe de modèle qui reflète la structure du fichier. Vous convertissez les données brutes de type chaîne en types spécifiques tels que les entiers, les nombres décimaux et les valeurs DateTime. Pour les données d'inventaire des produits, créez une classe avec des propriétés correspondant à chaque colonne CSV :
public class Product
{
public int Id { get; set; }
public string Name { get; set; } = string.Empty;
public decimal Price { get; set; }
public int Quantity { get; set; }
}Public Class Product
Public Property Id As Integer
Public Property Name As String = String.Empty
Public Property Price As Decimal
Public Property Quantity As Integer
End ClassUne fois la classe de modèle définie, vous pouvez analyser les enregistrements CSV et les convertir en une collection typée. L'exemple suivant saute la ligne d'en-tête en utilisant un index de boucle et mappe chaque ligne suivante à un objet Product :
using IronXL;
WorkBook workbook = WorkBook.LoadCSV("inventory.csv");
WorkSheet ws = workbook.DefaultWorkSheet;
var records = new List<Product>();
// Skip header row (index 0), iterate through data rows
for (int i = 1; i < ws.Rows.Count(); i++)
{
var row = ws.Rows[i];
var product = new Product
{
Id = row.Columns[0].IntValue,
Name = row.Columns[1].StringValue,
Price = row.Columns[2].DecimalValue,
Quantity = row.Columns[3].IntValue
};
records.Add(product);
}
Console.WriteLine($"Loaded {records.Count} products.");Imports IronXL
Dim workbook As WorkBook = WorkBook.LoadCSV("inventory.csv")
Dim ws As WorkSheet = workbook.DefaultWorkSheet
Dim records As New List(Of Product)()
' Skip header row (index 0), iterate through data rows
For i As Integer = 1 To ws.Rows.Count() - 1
Dim row = ws.Rows(i)
Dim product As New Product With {
.Id = row.Columns(0).IntValue,
.Name = row.Columns(1).StringValue,
.Price = row.Columns(2).DecimalValue,
.Quantity = row.Columns(3).IntValue
}
records.Add(product)
Next
Console.WriteLine($"Loaded {records.Count} products.")La collection records contient maintenant des objets Product typés prêts pour les opérations de base de données, la sérialisation JSON ou d'autres logiques métier. Les accesseurs de valeurs de cellule d'IronXL gèrent automatiquement la conversion de type, y compris la gestion des valeurs nulles pour les champs optionnels.
Les fichiers CSV réels contiennent souvent des cellules vides ou des colonnes facultatives. Les méthodes d'accès aux valeurs d'IronXL renvoient des valeurs par défaut plutôt que des exceptions lorsqu'une cellule est vide. Pour les types pouvant être nuls, vous pouvez utiliser une vérification conditionnelle :
// Reading an optional DateTime field
DateTime? lastUpdated = string.IsNullOrEmpty(row.Columns[4].StringValue)
? null
: row.Columns[4].DateTimeValue;' Reading an optional DateTime field
Dim lastUpdated As DateTime? = If(String.IsNullOrEmpty(row.Columns(4).StringValue), Nothing, row.Columns(4).DateTimeValue)Ce modèle permet de sécuriser votre code d'importation sans avoir à envelopper chaque accès aux cellules dans un bloc try-catch. Pour obtenir des conseils sur la gestion des types de données complexes et des fichiers volumineux, consultez la documentation IronXL WorkSheet .
Créer un point de terminaison d'API qui accepte les téléchargements de fichiers CSV depuis un navigateur nécessite de combiner IFormFile d'ASP.NET Core avec les capacités de parsing d'IronXL. Le code suivant illustre une implémentation complète de contrôleur qui analyse le fichier téléchargé et renvoie une réponse JSON :
using IronXL;
using Microsoft.AspNetCore.Mvc;
[Route("api/[controller]")]
[ApiController]
public class CsvController : ControllerBase
{
[HttpPost("upload")]
public async Task<IActionResult> UploadCsv(IFormFile file)
{
if (file == null || file.Length == 0)
return BadRequest("Please upload a valid CSV file.");
try
{
using var stream = new MemoryStream();
await file.CopyToAsync(stream);
stream.Position = 0;
WorkBook workbook = WorkBook.Load(stream, "csv");
WorkSheet ws = workbook.DefaultWorkSheet;
var records = new List<Product>();
// Skip header row, iterate through data rows
for (int i = 1; i < ws.Rows.Count(); i++)
{
var row = ws.Rows[i];
records.Add(new Product
{
Id = row.Columns[0].IntValue,
Name = row.Columns[1].StringValue,
Price = row.Columns[2].DecimalValue,
Quantity = row.Columns[3].IntValue
});
}
return Ok(new
{
message = "Import successful",
count = records.Count,
data = records
});
}
catch (Exception ex)
{
return BadRequest($"Error processing file: {ex.Message}");
}
}
}Imports IronXL
Imports Microsoft.AspNetCore.Mvc
Imports System.IO
Imports System.Threading.Tasks
<Route("api/[controller]")>
<ApiController>
Public Class CsvController
Inherits ControllerBase
<HttpPost("upload")>
Public Async Function UploadCsv(file As IFormFile) As Task(Of IActionResult)
If file Is Nothing OrElse file.Length = 0 Then
Return BadRequest("Please upload a valid CSV file.")
End If
Try
Using stream As New MemoryStream()
Await file.CopyToAsync(stream)
stream.Position = 0
Dim workbook As WorkBook = WorkBook.Load(stream, "csv")
Dim ws As WorkSheet = workbook.DefaultWorkSheet
Dim records As New List(Of Product)()
' Skip header row, iterate through data rows
For i As Integer = 1 To ws.Rows.Count() - 1
Dim row = ws.Rows(i)
records.Add(New Product With {
.Id = row.Columns(0).IntValue,
.Name = row.Columns(1).StringValue,
.Price = row.Columns(2).DecimalValue,
.Quantity = row.Columns(3).IntValue
})
Next
Return Ok(New With {
.message = "Import successful",
.count = records.Count,
.data = records
})
End Using
Catch ex As Exception
Return BadRequest($"Error processing file: {ex.Message}")
End Try
End Function
End ClassPour que l'action [HttpPost("upload")] accepte les téléchargements de fichiers, le projet doit supporter les données de formulaire multipart. Dans Program.cs pour une configuration d'API minimale, assurez-vous d'avoir appelé builder.Services.AddControllers() et app.MapControllers(). Le point de terminaison devient accessible à /api/csv/upload.
Lors du test à partir d'un formulaire de navigateur, définissez l'attribut enctype du formulaire sur multipart/form-data et utilisez un élément d'entrée de fichier. Pour les clients API comme Postman, sélectionnez "form-data" dans le corps de la requête, ajoutez une clé nommée file, et attachez le fichier CSV. Le contrôleur renvoie un objet JSON contenant le nombre d'enregistrements et le tableau de données analysées, que le JavaScript côté client peut consommer immédiatement.
Avant de transmettre le flux à IronXL, validez l'extension du fichier pour rejeter les téléchargements non CSV :
var extension = Path.GetExtension(file.FileName).ToLowerInvariant();
if (extension != ".csv" && extension != ".txt")
return BadRequest("Only CSV files are accepted.");Dim extension As String = Path.GetExtension(file.FileName).ToLowerInvariant()
If extension <> ".csv" AndAlso extension <> ".txt" Then
Return BadRequest("Only CSV files are accepted.")
End IfCe contrôle empêche les données binaires malformées d'atteindre l'analyseur et fournit un message d'erreur clair aux utilisateurs de l'API. Vous pouvez étendre cette validation pour vérifier le type MIME en utilisant file.ContentType pour une application plus stricte.
Après avoir analysé les fichiers CSV et les avoir convertis en objets typés, vous enregistrez généralement les données dans une base de données. L'exemple suivant étend le modèle de couche de service en utilisant AddRangeAsync d'Entity Framework Core pour des insertions en masse :
using IronXL;
public class CsvImportService
{
private readonly AppDbContext _context;
public CsvImportService(AppDbContext context)
{
_context = context;
}
public async Task<int> ImportProductsAsync(Stream csvStream)
{
WorkBook workbook = WorkBook.LoadCSV(csvStream);
WorkSheet ws = workbook.DefaultWorkSheet;
var products = new List<Product>();
foreach (var row in ws.Rows.Skip(1))
{
products.Add(new Product
{
Id = row.Columns[0].IntValue,
Name = row.Columns[1].StringValue,
Price = row.Columns[2].DecimalValue,
Quantity = row.Columns[3].IntValue
});
}
await _context.Products.AddRangeAsync(products);
return await _context.SaveChangesAsync();
}
}Imports IronXL
Public Class CsvImportService
Private ReadOnly _context As AppDbContext
Public Sub New(context As AppDbContext)
_context = context
End Sub
Public Async Function ImportProductsAsync(csvStream As Stream) As Task(Of Integer)
Dim workbook As WorkBook = WorkBook.LoadCSV(csvStream)
Dim ws As WorkSheet = workbook.DefaultWorkSheet
Dim products As New List(Of Product)()
For Each row In ws.Rows.Skip(1)
products.Add(New Product With {
.Id = row.Columns(0).IntValue,
.Name = row.Columns(1).StringValue,
.Price = row.Columns(2).DecimalValue,
.Quantity = row.Columns(3).IntValue
})
Next
Await _context.Products.AddRangeAsync(products)
Return Await _context.SaveChangesAsync()
End Function
End ClassEnregistrez CsvImportService dans Program.cs afin que le contrôleur puisse le demander via l'injection du constructeur :
builder.Services.AddScoped<CsvImportService>();netMettez ensuite à jour le constructeur du contrôleur pour accepter le service et appelez ImportProductsAsync au lieu de construire la liste en ligne. Cette séparation maintient les actions du contrôleur légères et déplace la logique d'accès aux données dans une classe de service testable. Entity Framework Core regroupe l'appel AddRangeAsync en une seule déclaration INSERT par lot, ce qui fonctionne bien pour les fichiers CSV contenant des milliers de lignes.
Pour des importations très grandes (dizaines de milliers de lignes), envisagez d'utiliser EF Core's Bulk Extensions ou une déclaration SQL brute BULK INSERT pour réduire les allers-retours vers la base de données.
IronXL ne se limite pas à la lecture des fichiers CSV, il peut également les écrire. La méthode SaveAsCsv exporte n'importe quelle feuille de calcul vers un fichier CSV, ce qui est utile pour générer des rapports ou envoyer des données à des systèmes en aval :
using IronXL;
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLS);
WorkSheet ws = workbook.DefaultWorkSheet;
// Write headers
ws["A1"].Value = "Id";
ws["B1"].Value = "Name";
ws["C1"].Value = "Price";
// Write data rows
ws["A2"].Value = 1;
ws["B2"].Value = "Widget A";
ws["C2"].Value = 9.99;
ws["A3"].Value = 2;
ws["B3"].Value = "Widget B";
ws["C3"].Value = 14.49;
// Save as CSV
workbook.SaveAsCsv("export.csv");
Console.WriteLine("CSV export complete.");Imports IronXL
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLS)
Dim ws As WorkSheet = workbook.DefaultWorkSheet
' Write headers
ws("A1").Value = "Id"
ws("B1").Value = "Name"
ws("C1").Value = "Price"
' Write data rows
ws("A2").Value = 1
ws("B2").Value = "Widget A"
ws("C2").Value = 9.99
ws("A3").Value = 2
ws("B3").Value = "Widget B"
ws("C3").Value = 14.49
' Save as CSV
workbook.SaveAsCsv("export.csv")
Console.WriteLine("CSV export complete.")Le fichier exporté utilise par défaut des virgules comme délimiteurs. Pour les fichiers délimités par des points-virgules, courants dans les régions européennes, appelez SaveAsCsv("export.csv", ";") avec un argument délimiteur explicite. Vous pouvez également enregistrer dans un MemoryStream et retourner le résultat comme un téléchargement de fichier depuis un point de terminaison API en utilisant File(stream, "text/csv", "export.csv").
Pour une référence complète sur les options d'exportation, visitez la documentation sur la sauvegarde et l'exportation IronXL.
L'analyse manuelle des fichiers CSV semble simple jusqu'à ce que l'on rencontre des cas particuliers : des valeurs contenant des virgules entre guillemets, des sauts de ligne intégrés dans une cellule, des guillemets échappés et des marques d'ordre d'octets au début des fichiers UTF-8. Manipuler correctement tout cela dans une boucle StreamReader personnalisée nécessite des tests importants et une maintenance continue.
IronXL traite tous ces cas en interne. La comparaison des deux approches met en évidence des avantages clairs :
| Capacité | IronXL | Lecteur de flux manuel |
|---|---|---|
| Détection automatique du délimiteur | Oui | Non – configuration manuelle requise |
| Traitement sur site indiqué | Intégré | Nécessite une logique personnalisée |
| Conversion de type (int, decimal, DateTime) | Accessoires intégrés | Nécessite des appels Parse/TryParse |
| Valeurs de cellules multilignes | Géré automatiquement | Difficile à mettre en œuvre correctement |
| Gestion de la nomenclature | Automatique | Nécessite la configuration de StreamReader |
| Prise en charge des formats Excel (XLSX, XLS) | Même API | Nécessite une bibliothèque séparée |
| Exporter vers CSV | Méthode SaveAsCsv | Nécessite une logique d'écriture séparée |
Un des avantages pratiques d'IronXL est que le même modèle d'itération WorkBook.Load et de feuille de calcul fonctionne pour les fichiers XLSX, XLS, ODS, et CSV. Si votre application doit accepter plusieurs formats de feuilles de calcul de la part des utilisateurs, vous pouvez passer d'un format à l'autre sans modifier la logique d'analyse. Passez le flux de fichier à WorkBook.Load et IronXL détecte automatiquement le format en fonction de la signature du fichier.
Cette API multiformat signifie que vous écrivez et testez un seul chemin de code au lieu de maintenir des implémentations distinctes pour CSV et Excel. Pour obtenir la liste complète des formats pris en charge, consultez la page relative aux formats de fichiers pris en charge par IronXL .
Pour les fichiers CSV de moins de 100 Mo, IronXL fonctionne bien sans aucun réglage. Pour les fichiers volumineux, envisagez les stratégies suivantes :
MemoryStream pour réduire l'allocation de mémoire.ws.Rows.Skip(1) avec LINQ pour éviter de matérialiser la ligne d'en-tête en tant qu'objet Product.Le guide de performance d'IronXL couvre des optimisations supplémentaires pour les scénarios d'importation à haut volume, y compris le traitement parallèle et les modes de streaming.
Vous disposez désormais d'un modèle fonctionnel pour chaque étape de l'importation CSV dans ASP.NET Core: installation de la bibliothèque, chargement des fichiers depuis le disque ou les flux téléchargés, mappage des lignes sur des objets de modèle typés, persistance des enregistrements dans une base de données avec Entity Framework Core et exportation des données au format CSV en cas de besoin.
Pour approfondir ces bases, explorez ces ressources :
Avec IronXL dans votre projet, ajouter le support pour les téléchargements XLSX en parallèle avec les CSV ne nécessite aucun changement de code supplémentaire -- le même appel WorkBook.Load gère les deux. Cette cohérence vous permet d'étendre progressivement les fonctionnalités de votre point de terminaison d'importation à mesure que les besoins de votre application évoluent.
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.
