Les fichiers CSV (Virgule Separated Values) sont omniprésents dans les applications d'entreprise, des rapports financiers à l'exportation des données clients. Le format CSV est d'une simplicité trompeuse en apparence, mais son analyse dans le code de production peut rapidement devenir difficile lorsqu'il s'agit de champs entre guillemets, de plusieurs types de délimiteurs, de sauts de ligne intégrés et de la nécessité de convertir du texte brut en objets .NET fortement typés. IronXL est une bibliothèque .NET qui offre une gestion CSV adaptée aux entreprises, permettant aux développeurs de convertir des données CSV en Excel, XML ou autres formats avec un minimum de code.
Ce guide vous explique comment IronXL fonctionne en tant que lecteur de fichiers CSV C# et comment vous pouvez l'implémenter dans vos applications .NET 10. Essayez IronXL vous-même grâce à une licence d'essai gratuite et suivez ce tutoriel pour découvrir comment il gère les tâches liées aux fichiers CSV et Excel.
Intégrer IronXL à votre projet ne prend qu'un instant. Vous pouvez l'installer via le gestionnaire de packages NuGet dans Visual Studio, ou via la ligne de commande en utilisant soit l'interface de ligne de commande .NET , soit la console du gestionnaire de packages NuGet dans PowerShell. Les deux méthodes installent le même package et fonctionnent avec tout type de projet .NET 10.
Pour plus de détails sur les options d'installation et la configuration, consultez la documentation d'installation d'IronXL.
Une fois installé, la lecture de votre premier fichier CSV nécessite très peu de code. L'exemple ci-dessous utilise des instructions de niveau supérieur .NET 10 :
using IronXL;
// Load CSV file
WorkBook workbook = WorkBook.LoadCSV("data.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;
// Read a specific cell
string cellValue = sheet["A1"].StringValue;
// Iterate through all rows and cells
foreach (var row in sheet.Rows)
{
foreach (var cell in row)
{
Console.WriteLine(cell.StringValue);
}
}Imports IronXL
' Load CSV file
Dim workbook As WorkBook = WorkBook.LoadCSV("data.csv")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
' Read a specific cell
Dim cellValue As String = sheet("A1").StringValue
' Iterate through all rows and cells
For Each row In sheet.Rows
For Each cell In row
Console.WriteLine(cell.StringValue)
Next
NextLa méthode WorkBook.LoadCSV gère l'identification des en-têtes, crée une structure de données interne et effectue une analyse syntaxique efficace en termes de mémoire -- simplifiant ainsi votre gestion des données dès la première ligne de code.
Dans la réalité, les fichiers CSV n'utilisent pas toujours de virgules. Les points-virgules, les barres verticales et les tabulations sont des alternatives courantes, notamment dans les ensembles de données internationaux où les virgules servent de séparateurs décimaux. IronXL prend en charge tous les délimiteurs grâce à ses options de chargement flexibles.
using IronXL;
// Load CSV with semicolon delimiter (common in European data exports)
WorkBook workbook = WorkBook.LoadCSV("european-data.csv",
fileFormat: ExcelFileFormat.XLSX,
listDelimiter: ";");
// Load tab-separated values (TSV)
WorkBook tsvWorkbook = WorkBook.LoadCSV("export_data.tsv",
fileFormat: ExcelFileFormat.XLSX,
listDelimiter: "\t");
// Load pipe-delimited file
WorkBook pipeWorkbook = WorkBook.LoadCSV("log_export.csv",
fileFormat: ExcelFileFormat.XLSX,
listDelimiter: "|");
// Access data normally after loading
WorkSheet sheet = workbook.DefaultWorkSheet;
decimal totalSales = sheet["B2:B10"].Sum();
Console.WriteLine($"Total sales: {totalSales}");Imports IronXL
' Load CSV with semicolon delimiter (common in European data exports)
Dim workbook As WorkBook = WorkBook.LoadCSV("european-data.csv", fileFormat:=ExcelFileFormat.XLSX, listDelimiter:=";")
' Load tab-separated values (TSV)
Dim tsvWorkbook As WorkBook = WorkBook.LoadCSV("export_data.tsv", fileFormat:=ExcelFileFormat.XLSX, listDelimiter:=vbTab)
' Load pipe-delimited file
Dim pipeWorkbook As WorkBook = WorkBook.LoadCSV("log_export.csv", fileFormat:=ExcelFileFormat.XLSX, listDelimiter:="|")
' Access data normally after loading
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
Dim totalSales As Decimal = sheet("B2:B10").Sum()
Console.WriteLine($"Total sales: {totalSales}")Le paramètre listDelimiter accepte n'importe quelle chaîne, ce qui vous permet de contrôler entièrement le comportement de l'analyse. IronXL préserve les valeurs des colonnes et les types de données lors de l'analyse : les valeurs numériques restent des nombres, les dates restent des objets DateTime, et les formules conservent leurs relations.
Pour les fichiers dont la mise en forme est incohérente, la gestion des erreurs d'IronXL traite les lignes malformées sans faire planter l'application, de sorte que les données valides continuent d'être traitées même lorsque des lignes individuelles posent problème.
IronXL prend en charge le chargement des types de délimiteurs suivants lors de la lecture de fichiers CSV :
| Délimiteur | Personnage | Cas d'utilisation courant |
|---|---|---|
| Virgule | , | Exportations CSV standard, en langue américaine |
| Point-virgule | ; | Exportations locales européennes (où la virgule est le séparateur décimal) |
| Languette | \t | Valeurs séparées par des tabulations (TSV), exportations de bases de données |
| Tuyau | | | Fichiers journaux, exportations système |
| Chaîne personnalisée | N'importe lequel | Formats de données propriétaires, délimiteurs multi-caractères |
Transformer les lignes CSV en objets fortement typés simplifie le traitement des données et permet les opérations LINQ. IronXL simplifie ce mappage grâce à ses méthodes d'accès aux cellules. Le code suivant illustre comment mapper un fichier CSV vers une liste d'objets typés à l'aide d'instructions de niveau supérieur .NET 10 :
using IronXL;
// Define a typed model matching your CSV structure
public record Product(string Name, decimal Price, int Stock, DateTime? LastUpdated);
// Load and parse CSV file
WorkBook workbook = WorkBook.LoadCSV("inventory.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;
var products = new List<Product>();
// Start from row 2 to skip the header row
for (int row = 2; row <= sheet.RowCount; row++)
{
products.Add(new Product(
Name: sheet[$"A{row}"].StringValue,
Price: sheet[$"B{row}"].DecimalValue,
Stock: sheet[$"C{row}"].IntValue,
LastUpdated: sheet[$"D{row}"].DateTimeValue
));
}
// Use LINQ for analysis after loading
var lowStock = products.Where(p => p.Stock < 10).ToList();
var highValue = products.Where(p => p.Price > 100m).OrderByDescending(p => p.Price).ToList();
Console.WriteLine($"Products with low stock: {lowStock.Count}");
Console.WriteLine($"High-value products: {highValue.Count}");Imports IronXL
' Define a typed model matching your CSV structure
Public Class Product
Public Property Name As String
Public Property Price As Decimal
Public Property Stock As Integer
Public Property LastUpdated As DateTime?
Public Sub New(name As String, price As Decimal, stock As Integer, lastUpdated As DateTime?)
Me.Name = name
Me.Price = price
Me.Stock = stock
Me.LastUpdated = lastUpdated
End Sub
End Class
' Load and parse CSV file
Dim workbook As WorkBook = WorkBook.LoadCSV("inventory.csv")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
Dim products As New List(Of Product)()
' Start from row 2 to skip the header row
For row As Integer = 2 To sheet.RowCount
products.Add(New Product(
Name:=sheet($"A{row}").StringValue,
Price:=sheet($"B{row}").DecimalValue,
Stock:=sheet($"C{row}").IntValue,
LastUpdated:=sheet($"D{row}").DateTimeValue
))
Next
' Use LINQ for analysis after loading
Dim lowStock = products.Where(Function(p) p.Stock < 10).ToList()
Dim highValue = products.Where(Function(p) p.Price > 100D).OrderByDescending(Function(p) p.Price).ToList()
Console.WriteLine($"Products with low stock: {lowStock.Count}")
Console.WriteLine($"High-value products: {highValue.Count}")Les propriétés de valeurs typées d'IronXL -- StringValue, DecimalValue, IntValue, DateTimeValue -- gèrent les conversions en toute sécurité, renvoyant des valeurs par défaut pour les données non valides plutôt que de lancer des exceptions. Cette approche défensive garantit que les applications traitent les données imparfaites sans interruption. Il s'associe naturellement aux types d'enregistrements C# , introduits dans C# 9 et qui fournissent un modèle de données concis et immuable pour les lignes CSV mappées.
La page des fonctionnalités IronXL fournit un aperçu complet des types d'accesseurs de valeurs disponibles pour la lecture des données cellulaires.
Une fois les données CSV chargées dans un WorkSheet, vous pouvez les utiliser à l'aide de sélecteurs de plage ou les convertir en objets pour les requêtes LINQ. Pour les opérations simples sur les colonnes, l'accès par plage est la voie la plus directe :
using IronXL;
WorkBook workbook = WorkBook.LoadCSV("sales-data.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;
// Read entire columns using range notation
var productNames = sheet["A2:A100"]
.Select(cell => cell.StringValue)
.Where(name => !string.IsNullOrEmpty(name))
.ToList();
// Aggregate numeric columns directly
decimal totalRevenue = sheet["C2:C100"].Sum();
decimal averageOrder = sheet["C2:C100"].Avg();
Console.WriteLine($"Products loaded: {productNames.Count}");
Console.WriteLine($"Total revenue: {totalRevenue:C}");
Console.WriteLine($"Average order value: {averageOrder:C}");Imports IronXL
Dim workbook As WorkBook = WorkBook.LoadCSV("sales-data.csv")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
' Read entire columns using range notation
Dim productNames = sheet("A2:A100") _
.Select(Function(cell) cell.StringValue) _
.Where(Function(name) Not String.IsNullOrEmpty(name)) _
.ToList()
' Aggregate numeric columns directly
Dim totalRevenue As Decimal = sheet("C2:C100").Sum()
Dim averageOrder As Decimal = sheet("C2:C100").Avg()
Console.WriteLine($"Products loaded: {productNames.Count}")
Console.WriteLine($"Total revenue: {totalRevenue:C}")
Console.WriteLine($"Average order value: {averageOrder:C}")Cette approche par plage évite l'itération ligne par ligne pour les agrégations simples, ce qui améliore les performances sur les fichiers volumineux. Consultez la documentation IronXL pour obtenir la liste complète des opérations de tir prises en charge.
De nombreux processus métier nécessitent des données CSV au format Excel pour des analyses, une mise en forme ou une distribution avancées. IronXL facilite cette conversion tout en préservant l'intégrité des données.
using IronXL;
// Load CSV file
WorkBook csvWorkbook = WorkBook.LoadCSV("monthly-report.csv");
WorkSheet sheet = csvWorkbook.DefaultWorkSheet;
// Apply formatting before saving
sheet["A1:D1"].Style.Font.Bold = true;
sheet["A1:D1"].Style.BackgroundColor = "#4472C4";
sheet["A1:D1"].Style.Font.Color = "#FFFFFF";
// Apply currency format to price column
sheet["B2:B1000"].FormatString = "$#,##0.00";
// Apply date format to date column
sheet["D2:D1000"].FormatString = "yyyy-MM-dd";
// Save as Excel with a single method call
csvWorkbook.SaveAs("monthly-report.xlsx");
Console.WriteLine("Conversion complete: monthly-report.xlsx");Imports IronXL
' Load CSV file
Dim csvWorkbook As WorkBook = WorkBook.LoadCSV("monthly-report.csv")
Dim sheet As WorkSheet = csvWorkbook.DefaultWorkSheet
' Apply formatting before saving
sheet("A1:D1").Style.Font.Bold = True
sheet("A1:D1").Style.BackgroundColor = "#4472C4"
sheet("A1:D1").Style.Font.Color = "#FFFFFF"
' Apply currency format to price column
sheet("B2:B1000").FormatString = "$#,##0.00"
' Apply date format to date column
sheet("D2:D1000").FormatString = "yyyy-MM-dd"
' Save as Excel with a single method call
csvWorkbook.SaveAs("monthly-report.xlsx")
Console.WriteLine("Conversion complete: monthly-report.xlsx")La conversion préserve la précision numérique, les formats de date et les caractères spéciaux qui posent souvent problème avec les méthodes de conversion manuelles. IronXL optimise automatiquement la structure du fichier Excel résultant, créant ainsi des fichiers efficaces qui s'ouvrent rapidement même avec de grands ensembles de données.
Pour un contrôle accru sur le format de sortie, le guide pratique d'exportation présente les options disponibles, notamment l'exportation au format XLSX, XLS, CSV et PDF. Vous pouvez également apprendre à rédiger des fichiers Excel et à créer des fichiers Excel à partir de zéro.
Lorsque vous devez charger des données CSV dans un DataSet pour un traitement ultérieur ou une insertion dans une base de données, IronXL fournit une aide à la conversion directe. Le guide Excel to DataSet explique cela en détail :
using IronXL;
using System.Data;
WorkBook workbook = WorkBook.LoadCSV("customer-export.csv");
// Convert entire workbook to DataSet
DataSet dataSet = workbook.ToDataSet();
// The first sheet becomes the first DataTable
DataTable customerTable = dataSet.Tables[0];
Console.WriteLine($"Rows loaded: {customerTable.Rows.Count}");
Console.WriteLine($"Columns: {customerTable.Columns.Count}");
// Process with standard ADO.NET
foreach (DataRow row in customerTable.Rows)
{
string name = row["Name"]?.ToString() ?? string.Empty;
string email = row["Email"]?.ToString() ?? string.Empty;
Console.WriteLine($"Customer: {name} <{email}>");
}Imports IronXL
Imports System.Data
Dim workbook As WorkBook = WorkBook.LoadCSV("customer-export.csv")
' Convert entire workbook to DataSet
Dim dataSet As DataSet = workbook.ToDataSet()
' The first sheet becomes the first DataTable
Dim customerTable As DataTable = dataSet.Tables(0)
Console.WriteLine($"Rows loaded: {customerTable.Rows.Count}")
Console.WriteLine($"Columns: {customerTable.Columns.Count}")
' Process with standard ADO.NET
For Each row As DataRow In customerTable.Rows
Dim name As String = If(row("Name")?.ToString(), String.Empty)
Dim email As String = If(row("Email")?.ToString(), String.Empty)
Console.WriteLine($"Customer: {name} <{email}>")
NextCette approche s'intègre directement aux flux de travail .NET et s'avère utile lors de l'envoi de données CSV vers SQL Server, SQLite ou d'autres bases de données relationnelles via des adaptateurs de données standard. Étant donné que DataSet et DataTable sont des types .NET de base, ce chemin ne nécessite aucune dépendance supplémentaire au-delà d'IronXL for .NET lui-même.
Le traitement de fichiers CSV volumineux (des dizaines de milliers de lignes, voire plus) exige une attention particulière à la manière dont les données sont accessibles et dont la mémoire est gérée. IronXL inclut des fonctionnalités qui facilitent la gestion des fichiers volumineux.
Pour des performances optimales avec de grands ensembles de données, utilisez les opérations sur les plages plutôt que d'accéder aux cellules une par une. Les opérations sur les plages sont traitées plus efficacement par le moteur interne d'IronXL.
using IronXL;
WorkBook workbook = WorkBook.LoadCSV("large-dataset.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;
int rowCount = sheet.RowCount;
int colCount = sheet.ColumnCount;
Console.WriteLine($"Dataset dimensions: {rowCount} rows x {colCount} columns");
// Efficient: read entire range at once
var allData = sheet[$"A1:{GetColumnLetter(colCount)}{rowCount}"]
.Select(cell => cell.StringValue)
.ToList();
// Efficient: aggregate a column without row-by-row iteration
decimal columnSum = sheet[$"B2:B{rowCount}"].Sum();
Console.WriteLine($"Column B total: {columnSum}");
static string GetColumnLetter(int col)
{
string result = string.Empty;
while (col > 0)
{
col--;
result = (char)('A' + col % 26) + result;
col /= 26;
}
return result;
}Imports IronXL
Dim workbook As WorkBook = WorkBook.LoadCSV("large-dataset.csv")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
Dim rowCount As Integer = sheet.RowCount
Dim colCount As Integer = sheet.ColumnCount
Console.WriteLine($"Dataset dimensions: {rowCount} rows x {colCount} columns")
' Efficient: read entire range at once
Dim allData = sheet($"A1:{GetColumnLetter(colCount)}{rowCount}") _
.Select(Function(cell) cell.StringValue) _
.ToList()
' Efficient: aggregate a column without row-by-row iteration
Dim columnSum As Decimal = sheet($"B2:B{rowCount}").Sum()
Console.WriteLine($"Column B total: {columnSum}")
Private Shared Function GetColumnLetter(col As Integer) As String
Dim result As String = String.Empty
While col > 0
col -= 1
result = ChrW(AscW("A"c) + col Mod 26) & result
col \= 26
End While
Return result
End FunctionIronXL gère automatiquement les variations d'encodage de texte ( UTF-8, UTF-16, ASCII ) lors du chargement de fichiers CSV, garantissant ainsi un affichage correct des caractères internationaux dans les valeurs des colonnes sans configuration supplémentaire. Ceci est particulièrement important pour les fichiers exportés depuis des systèmes situés dans des régions où l'encodage UTF-8 BOM ou d'autres encodages alternatifs sont courants.
Lors du traitement de fichiers CSV provenant de sources non fiables ou variables, l'encapsulation des opérations dans des blocs try-catch offre une couche de sécurité supplémentaire :
using IronXL;
string filePath = "user-uploaded-data.csv";
try
{
WorkBook workbook = WorkBook.LoadCSV(filePath);
WorkSheet sheet = workbook.DefaultWorkSheet;
Console.WriteLine($"Loaded {sheet.RowCount} rows from {filePath}");
for (int row = 2; row <= sheet.RowCount; row++)
{
string value = sheet[$"A{row}"].StringValue;
if (!string.IsNullOrWhiteSpace(value))
{
Console.WriteLine(value);
}
}
}
catch (IronXL.Exceptions.IronXLException ex)
{
Console.WriteLine($"IronXL error reading {filePath}: {ex.Message}");
}
catch (IOException ex)
{
Console.WriteLine($"File access error: {ex.Message}");
}Imports IronXL
Module Module1
Sub Main()
Dim filePath As String = "user-uploaded-data.csv"
Try
Dim workbook As WorkBook = WorkBook.LoadCSV(filePath)
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
Console.WriteLine($"Loaded {sheet.RowCount} rows from {filePath}")
For row As Integer = 2 To sheet.RowCount
Dim value As String = sheet($"A{row}").StringValue
If Not String.IsNullOrWhiteSpace(value) Then
Console.WriteLine(value)
End If
Next
Catch ex As IronXL.Exceptions.IronXLException
Console.WriteLine($"IronXL error reading {filePath}: {ex.Message}")
Catch ex As IOException
Console.WriteLine($"File access error: {ex.Message}")
End Try
End Sub
End ModuleLes guides pratiques IronXL couvrent les modèles d'importation de données pour diverses sources, notamment les fichiers, les flux et les tableaux d'octets.
IronXL fonctionne indépendamment de Microsoft Office, ce qui le rend adapté aux environnements serveur et aux déploiements cloud. Que ce soit pour un déploiement sur Windows, Linux, macOS, des conteneurs Docker ou des fonctions cloud sur Azure ou AWS, IronXL offre des résultats cohérents sur toutes les plateformes sans modification de configuration.
Cette capacité multiplateforme est précieuse pour les architectures de microservices où des conteneurs légers gèrent les tâches de traitement des données. La présentation des fonctionnalités IronXL détaille la liste complète des environnements et cibles d'exécution pris en charge.
IronXL nécessite une clé de licence pour une utilisation en environnement de production. Une licence d'essai gratuite est disponible pour évaluation, et des licences commerciales sont disponibles pour les développeurs individuels, les équipes et les organisations.
Saisissez la clé de licence dans votre application avant de passer des appels IronXL :
using IronXL;
// Apply license key at application startup
IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";
// Verify the license is active
if (IronXL.License.IsValidLicense("YOUR-LICENSE-KEY-HERE"))
{
Console.WriteLine("IronXL license is active.");
}
// Now use IronXL normally
WorkBook workbook = WorkBook.LoadCSV("data.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;
Console.WriteLine($"Loaded {sheet.RowCount} rows.");Imports IronXL
' Apply license key at application startup
IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"
' Verify the license is active
If IronXL.License.IsValidLicense("YOUR-LICENSE-KEY-HERE") Then
Console.WriteLine("IronXL license is active.")
End If
' Now use IronXL normally
Dim workbook As WorkBook = WorkBook.LoadCSV("data.csv")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
Console.WriteLine($"Loaded {sheet.RowCount} rows.")Pour connaître les options d'essai et de licence, consultez la page de licences IronXL .
IronXL transforme la lecture des fichiers CSV en C#, une tâche d'analyse fastidieuse, en une opération simple. La bibliothèque gère les cas limites courants que l'analyse manuelle ne parvient pas à identifier correctement — virgules imbriquées, sauts de ligne dans des champs entre guillemets, délimiteurs incohérents, variations d'encodage et lignes mal formées — sans nécessiter de code personnalisé pour chaque scénario. Que vous ayez besoin d'une importation de données ponctuelle et rapide ou d'un pipeline de production traitant des milliers de fichiers par jour, la même API fonctionne dans les deux cas.
L'analyse CSV manuelle avec string.Split ou StreamReader s'interrompt rapidement lorsque les champs entre guillemets contiennent le caractère de délimitation ou lorsque des sauts de ligne apparaissent à l'intérieur des valeurs des champs. IronXL gère correctement ces cas par défaut, conformément à la spécification CSV pour la gestion des champs entre guillemets et les séquences d'échappement.
Les principaux avantages qui distinguent IronXL pour le traitement des fichiers CSV sous .NET 10 :
listDelimiterStringValue, DecimalValue, IntValue et DateTimeValue renvoient des valeurs par défaut sûres au lieu d'être rejetés en cas de mauvaises donnéesDataSet / DataTable pour ADO.NET et les opérations de base de donnéesLa documentation IronXL et le guide de mise en forme des cellules fournissent des détails supplémentaires sur la mise en forme, la prise en charge des formules et les opérations avancées sur les classeurs.
Prêt à manipuler les fichiers CSV en toute confiance ? Démarrez avec un essai gratuit et découvrez toutes les fonctionnalités IronXL .
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.
