Introduction au travail avec des fichiers CSV

Les fichiers CSV (Comma Separated Values) sont un élément essentiel de l'échange et du stockage de données, grâce à leur simplicité et à leur large compatibilité. Qu'il s'agisse d'importer des données dans une base de données, d'exporter des rapports ou d'intégrer des systèmes tiers, les fichiers CSV constituent un format léger et flexible pour traiter des données tabulaires. En .NET, l'utilisation de fichiers CSV est une tâche courante : les développeurs doivent souvent analyser, lire et écrire des données CSV dans le cadre d'une logique métier, de rapports ou de flux de migration de données.

Le système .NET offre plusieurs façons de traiter les fichiers CSV, depuis les opérations de base sur les chaînes et les fichiers jusqu'aux bibliothèques robustes comme CsvHelper. Une analyse correcte est essentielle, car même une simple virgule peut introduire de la complexité lorsqu'elle apparaît à l'intérieur de champs cités ou en tant que partie des données elles-mêmes. En exploitant les bons outils .NET et en comprenant les nuances de l'analyse CSV, les développeurs peuvent garantir l'intégrité des données et rationaliser le traitement des données dans leurs applications.

Quel est le moyen le plus simple de lire des fichiers CSV dans .NET?

L'approche la plus simple utilise la méthode WorkBook.LoadCSV pour importer des données CSV directement dans une structure de classeur. Cette méthode unique gère automatiquement l'analyse syntaxique, la détection des délimiteurs et l'organisation des données, sans qu'il soit nécessaire de créer un nouveau StreamReader ou de traiter manuellement chaque ligne de chaîne.

Installez IronXL via la console NuGet Package Manager dans Visual Studio. Ouvrez votre projet .NET et exécutez-le :

Install-Package IronXL.Excel

Read CSV .NET : L'approche C# la plus simple à l'aide d'IronXL : Image 1 - Installation

using IronXL;
using System;

class Program
{
    static void Main(string[] args)
    {
        // Load CSV file into a workbook with one method call
        WorkBook workbook = WorkBook.LoadCSV("sales_data.csv", fileFormat: ExcelFileFormat.XLSX, listDelimiter: ",");
        // Access the default worksheet containing CSV data
        WorkSheet sheet = workbook.DefaultWorkSheet;
        // Display all rows and CSV columns
        foreach (var row in sheet.Rows)
        {
            foreach (var cell in row)
            {
                Console.Write(cell.Value + "\t");
            }
            Console.WriteLine();
        }
    }
}

using IronXL;
using System;

class Program
{
    static void Main(string[] args)
    {
        // Load CSV file into a workbook with one method call
        WorkBook workbook = WorkBook.LoadCSV("sales_data.csv", fileFormat: ExcelFileFormat.XLSX, listDelimiter: ",");
        // Access the default worksheet containing CSV data
        WorkSheet sheet = workbook.DefaultWorkSheet;
        // Display all rows and CSV columns
        foreach (var row in sheet.Rows)
        {
            foreach (var cell in row)
            {
                Console.Write(cell.Value + "\t");
            }
            Console.WriteLine();
        }
    }
}

Imports IronXL
Imports System

Module Program
    Sub Main(args As String())
        ' Load CSV file into a workbook with one method call
        Dim workbook As WorkBook = WorkBook.LoadCSV("sales_data.csv", fileFormat:=ExcelFileFormat.XLSX, listDelimiter:=",")
        ' Access the default worksheet containing CSV data
        Dim sheet As WorkSheet = workbook.DefaultWorkSheet
        ' Display all rows and CSV columns
        For Each row In sheet.Rows
            For Each cell In row
                Console.Write(cell.Value & vbTab)
            Next
            Console.WriteLine()
        Next
    End Sub
End Module

using (var reader = new StreamReader("sales_data.csv"))
using (var csv = new CsvHelper.CsvReader(reader, System.Globalization.CultureInfo.InvariantCulture))
{
    var records = csv.GetRecords<dynamic>().ToList();
    // Process records as needed
}

using (var reader = new StreamReader("sales_data.csv"))
using (var csv = new CsvHelper.CsvReader(reader, System.Globalization.CultureInfo.InvariantCulture))
{
    var records = csv.GetRecords<dynamic>().ToList();
    // Process records as needed
}

Imports System.Globalization
Imports System.IO
Imports CsvHelper

Using reader As New StreamReader("sales_data.csv")
    Using csv As New CsvReader(reader, CultureInfo.InvariantCulture)
        Dim records = csv.GetRecords(Of Object)().ToList()
        ' Process records as needed
    End Using
End Using

Comment l'analyse CSV manuelle se compare-t-elle à l'utilisation d'une bibliothèque ?

Comprendre la complexité qu'élimine IronXL permet d'en apprécier la valeur. L'analyse CSV manuelle nécessite de traiter de nombreux cas de figure qui semblent simples mais qui deviennent rapidement problématiques dans n'importe quel projet.

using System;
using System.IO;

class Program
{
    static void Main(string[] args)
    {
        // Manual approach - requires extensive code for basic functionality
        string path = "data.csv";
        string[] lines = File.ReadAllLines(path);
        foreach (string line in lines)
        {
            // This breaks when CSV fields contain commas inside quotes
            string[] fields = line.Split(',');
            foreach (string field in fields)
            {
                Console.Write(field.Trim() + "\t");
            }
            Console.WriteLine();
        }
    }
}

using System;
using System.IO;

class Program
{
    static void Main(string[] args)
    {
        // Manual approach - requires extensive code for basic functionality
        string path = "data.csv";
        string[] lines = File.ReadAllLines(path);
        foreach (string line in lines)
        {
            // This breaks when CSV fields contain commas inside quotes
            string[] fields = line.Split(',');
            foreach (string field in fields)
            {
                Console.Write(field.Trim() + "\t");
            }
            Console.WriteLine();
        }
    }
}

Imports System
Imports System.IO

Module Program
    Sub Main(args As String())
        ' Manual approach - requires extensive code for basic functionality
        Dim path As String = "data.csv"
        Dim lines As String() = File.ReadAllLines(path)
        For Each line As String In lines
            ' This breaks when CSV fields contain commas inside quotes
            Dim fields As String() = line.Split(","c)
            For Each field As String In fields
                Console.Write(field.Trim() & vbTab)
            Next
            Console.WriteLine()
        Next
    End Sub
End Module

using IronXL;
using System;

class Program
{
    static void Main(string[] args)
    {
        // IronXL approach - handles all edge cases automatically
        WorkBook workbook = WorkBook.LoadCSV("data.csv", fileFormat: ExcelFileFormat.XLSX, listDelimiter: ",");
        var records = workbook.DefaultWorkSheet.Rows;
        foreach (var row in records)
        {
            foreach (var cell in row)
            {
                Console.Write(cell.Value + "\t");
            }
            Console.WriteLine();
        }
    }
}

using IronXL;
using System;

class Program
{
    static void Main(string[] args)
    {
        // IronXL approach - handles all edge cases automatically
        WorkBook workbook = WorkBook.LoadCSV("data.csv", fileFormat: ExcelFileFormat.XLSX, listDelimiter: ",");
        var records = workbook.DefaultWorkSheet.Rows;
        foreach (var row in records)
        {
            foreach (var cell in row)
            {
                Console.Write(cell.Value + "\t");
            }
            Console.WriteLine();
        }
    }
}

Imports IronXL
Imports System

Class Program
    Shared Sub Main(args As String())
        ' IronXL approach - handles all edge cases automatically
        Dim workbook As WorkBook = WorkBook.LoadCSV("data.csv", fileFormat:=ExcelFileFormat.XLSX, listDelimiter:=",")
        Dim records = workbook.DefaultWorkSheet.Rows
        For Each row In records
            For Each cell In row
                Console.Write(cell.Value & vbTab)
            Next
            Console.WriteLine()
        Next
    End Sub
End Class

Comment gérer les différents délimiteurs CSV?

Les fichiers CSV n'utilisent pas toujours des virgules comme séparateurs. Les exportations de systèmes européens utilisent fréquemment des points-virgules en raison de l'utilisation de virgules dans les nombres décimaux, tandis que les valeurs séparées par des tabulations (TSV) et les fichiers délimités par des tuyaux apparaissent régulièrement dans les exportations de données provenant de diverses applications.

using IronXL;
using System;

class Program
{
    static void Main(string[] args)
    {
        // Reading a semicolon-delimited file (common in European exports)
        WorkBook euroData = WorkBook.LoadCSV("german_report.csv", fileFormat: ExcelFileFormat.XLSX, listDelimiter: ";");
        // Reading a tab-separated file
        WorkBook tsvData = WorkBook.LoadCSV("exported_data.tsv", fileFormat: ExcelFileFormat.XLSX, listDelimiter: "\t");
        // Reading a pipe-delimited file
        WorkBook pipeData = WorkBook.LoadCSV("legacy_system.csv", fileFormat: ExcelFileFormat.XLSX, listDelimiter: "|");
        // Access data identically regardless of original delimiter
        WorkSheet sheet = euroData.DefaultWorkSheet;
        int rowsCount = sheet.RowCount;
        Console.WriteLine($"Loaded {rowsCount} rows with {sheet.ColumnCount} CSV columns");
    }
}

using IronXL;
using System;

class Program
{
    static void Main(string[] args)
    {
        // Reading a semicolon-delimited file (common in European exports)
        WorkBook euroData = WorkBook.LoadCSV("german_report.csv", fileFormat: ExcelFileFormat.XLSX, listDelimiter: ";");
        // Reading a tab-separated file
        WorkBook tsvData = WorkBook.LoadCSV("exported_data.tsv", fileFormat: ExcelFileFormat.XLSX, listDelimiter: "\t");
        // Reading a pipe-delimited file
        WorkBook pipeData = WorkBook.LoadCSV("legacy_system.csv", fileFormat: ExcelFileFormat.XLSX, listDelimiter: "|");
        // Access data identically regardless of original delimiter
        WorkSheet sheet = euroData.DefaultWorkSheet;
        int rowsCount = sheet.RowCount;
        Console.WriteLine($"Loaded {rowsCount} rows with {sheet.ColumnCount} CSV columns");
    }
}

Imports IronXL
Imports System

Class Program
    Shared Sub Main(args As String())
        ' Reading a semicolon-delimited file (common in European exports)
        Dim euroData As WorkBook = WorkBook.LoadCSV("german_report.csv", fileFormat:=ExcelFileFormat.XLSX, listDelimiter:=";")
        ' Reading a tab-separated file
        Dim tsvData As WorkBook = WorkBook.LoadCSV("exported_data.tsv", fileFormat:=ExcelFileFormat.XLSX, listDelimiter:=vbTab)
        ' Reading a pipe-delimited file
        Dim pipeData As WorkBook = WorkBook.LoadCSV("legacy_system.csv", fileFormat:=ExcelFileFormat.XLSX, listDelimiter:="|")
        ' Access data identically regardless of original delimiter
        Dim sheet As WorkSheet = euroData.DefaultWorkSheet
        Dim rowsCount As Integer = sheet.RowCount
        Console.WriteLine($"Loaded {rowsCount} rows with {sheet.ColumnCount} CSV columns")
    End Sub
End Class

Le paramètre listDelimiter dans LoadCSV accepte n'importe quel caractère unique ou séquence d'échappement comme séparateur de champ. Les caractères de tabulation utilisent la séquence d'échappement \t. Après le chargement, la structure des données reste cohérente quel que soit le format d'origine, ce qui facilite le traitement des fichiers CSV provenant de sources multiples avec des délimiteurs différents. La valeur par défaut de la plupart des fichiers CSV est une virgule, mais cette flexibilité permet de gérer toute variation rencontrée par votre projet.

Quelles sont les meilleures méthodes pour convertir CSV en DataTable?

La conversion de données CSV en DataTable permet l'intégration avec des opérations de base de données, la liaison de données dans les applications d'interface utilisateur et les requêtes LINQ. La méthode ToDataTable effectue cette conversion en un seul appel.

using IronXL;
using System;
using System.Data;

class Program
{
    static void Main(string[] args)
    {
        // Load CSV and convert to DataTable
        WorkBook workbook = WorkBook.LoadCSV("customers.csv", ExcelFileFormat.XLSX, ",");
        WorkSheet sheet = workbook.DefaultWorkSheet;
        // Convert worksheet to DataTable - true parameter uses CSV file header as column names
        DataTable dataTable = sheet.ToDataTable(true);
        // DataTable is now ready for database operations, binding, or LINQ queries
        Console.WriteLine($"DataTable created with {dataTable.Columns.Count} columns:");
        foreach (DataColumn column in dataTable.Columns)
        {
            // Property names from CSV header become column names
            Console.WriteLine($"  - {column.ColumnName}");
        }
        Console.WriteLine($"\nTotal records: {dataTable.Rows.Count}");
        // Access data using standard DataTable syntax
        foreach (DataRow row in dataTable.Rows)
        {
            // Access by column index or name attribute
            string name = row["Name"].ToString();
            string email = row["Email"].ToString();
            Console.WriteLine($"Customer: {name}, Email: {email}");
        }
    }
}

using IronXL;
using System;
using System.Data;

class Program
{
    static void Main(string[] args)
    {
        // Load CSV and convert to DataTable
        WorkBook workbook = WorkBook.LoadCSV("customers.csv", ExcelFileFormat.XLSX, ",");
        WorkSheet sheet = workbook.DefaultWorkSheet;
        // Convert worksheet to DataTable - true parameter uses CSV file header as column names
        DataTable dataTable = sheet.ToDataTable(true);
        // DataTable is now ready for database operations, binding, or LINQ queries
        Console.WriteLine($"DataTable created with {dataTable.Columns.Count} columns:");
        foreach (DataColumn column in dataTable.Columns)
        {
            // Property names from CSV header become column names
            Console.WriteLine($"  - {column.ColumnName}");
        }
        Console.WriteLine($"\nTotal records: {dataTable.Rows.Count}");
        // Access data using standard DataTable syntax
        foreach (DataRow row in dataTable.Rows)
        {
            // Access by column index or name attribute
            string name = row["Name"].ToString();
            string email = row["Email"].ToString();
            Console.WriteLine($"Customer: {name}, Email: {email}");
        }
    }
}

Imports IronXL
Imports System
Imports System.Data

Module Program
    Sub Main(args As String())
        ' Load CSV and convert to DataTable
        Dim workbook As WorkBook = WorkBook.LoadCSV("customers.csv", ExcelFileFormat.XLSX, ",")
        Dim sheet As WorkSheet = workbook.DefaultWorkSheet
        ' Convert worksheet to DataTable - true parameter uses CSV file header as column names
        Dim dataTable As DataTable = sheet.ToDataTable(True)
        ' DataTable is now ready for database operations, binding, or LINQ queries
        Console.WriteLine($"DataTable created with {dataTable.Columns.Count} columns:")
        For Each column As DataColumn In dataTable.Columns
            ' Property names from CSV header become column names
            Console.WriteLine($"  - {column.ColumnName}")
        Next
        Console.WriteLine($"\nTotal records: {dataTable.Rows.Count}")
        ' Access data using standard DataTable syntax
        For Each row As DataRow In dataTable.Rows
            ' Access by column index or name attribute
            Dim name As String = row("Name").ToString()
            Dim email As String = row("Email").ToString()
            Console.WriteLine($"Customer: {name}, Email: {email}")
        Next
    End Sub
End Module

Le paramètre booléen dans ToDataTable détermine si la première ligne doit devenir des en-têtes de colonnes (true) ou des données (false). Lorsque la valeur est true, les colonnes de la DataTable résultante portent les noms de propriété de la ligne d'en-tête du fichier CSV, ce qui permet un accès intuitif aux données à l'aide de noms de colonnes tels que row["Name"].

Cette conversion s'avère précieuse pour les scénarios nécessitant des insertions en masse dans les bases de données à l'aide de SqlBulkCopy, le remplissage des contrôles DataGridView dans les applications Windows Forms, ou l'exécution de transformations de données complexes à l'aide d'expressions LINQ. Le format DataTable s'intègre également naturellement à Entity Framework et à d'autres outils ORM dans votre projet .NET Core Web API.

Les fichiers CSV peuvent-ils être convertis au format Excel ?

L'une des capacités remarquables d'IronXL est la conversion de données CSV en formats Excel appropriés. Cela permet d'ajouter des formules, du formatage, des graphiques et plusieurs feuilles de calcul à des données CSV initialement plates, ce qu'il est impossible de faire en écrivant uniquement des fichiers CSV.

using IronXL;
using System;

class Program
{
    static void Main(string[] args)
    {
        // Load CSV data from file path
        string path = "quarterly_sales.csv";
        WorkBook workbook = WorkBook.LoadCSV(path, ExcelFileFormat.XLSX, ",");
        // Save as Excel XLSX format - create new Excel file
        workbook.SaveAs("quarterly_sales.xlsx");
        // Alternative: Save as legacy XLS format for older Excel versions
        workbook.SaveAs("quarterly_sales.xls");
        Console.WriteLine("CSV successfully converted to Excel format");
    }
}

using IronXL;
using System;

class Program
{
    static void Main(string[] args)
    {
        // Load CSV data from file path
        string path = "quarterly_sales.csv";
        WorkBook workbook = WorkBook.LoadCSV(path, ExcelFileFormat.XLSX, ",");
        // Save as Excel XLSX format - create new Excel file
        workbook.SaveAs("quarterly_sales.xlsx");
        // Alternative: Save as legacy XLS format for older Excel versions
        workbook.SaveAs("quarterly_sales.xls");
        Console.WriteLine("CSV successfully converted to Excel format");
    }
}

Imports IronXL
Imports System

Module Program
    Sub Main(args As String())
        ' Load CSV data from file path
        Dim path As String = "quarterly_sales.csv"
        Dim workbook As WorkBook = WorkBook.LoadCSV(path, ExcelFileFormat.XLSX, ",")
        ' Save as Excel XLSX format - create new Excel file
        workbook.SaveAs("quarterly_sales.xlsx")
        ' Alternative: Save as legacy XLS format for older Excel versions
        workbook.SaveAs("quarterly_sales.xls")
        Console.WriteLine("CSV successfully converted to Excel format")
    End Sub
End Module

La méthode SaveAs détermine automatiquement le format de sortie en fonction de l'extension du fichier. XLSX crée des fichiers Office Open XML modernes compatibles avec Excel 2007 et les versions ultérieures, tandis que XLS produit des documents au format Binary Interchange File Format pour les applications plus anciennes.

Comment accéder à des valeurs de cellules spécifiques dans des données CSV?

Au-delà de l'itération à travers tous les enregistrements, IronXL fournit un accès direct aux cellules en utilisant un adressage familier de type Excel. Cela permet l'extraction de données ciblées et la récupération de valeurs en toute sécurité à travers différents types de données.

using IronXL;
using System;

// Example class to demonstrate structured data access
public class Employee
{
    public int Id { get; set; }
    public string Name { get; set; }
    public int Age { get; set; }
}

class Program
{
    static void Main(string[] args)
    {
        WorkBook workbook = WorkBook.LoadCSV("inventory.csv", ExcelFileFormat.XLSX, ",");
        WorkSheet sheet = workbook.DefaultWorkSheet;
        // Access specific cells using Excel-style addresses by index
        string productName = sheet["A2"].StringValue;
        int quantity = sheet["B2"].IntValue;
        decimal price = sheet["C2"].DecimalValue;
        Console.WriteLine($"Product: {productName}");
        Console.WriteLine($"Quantity: {quantity}");
        Console.WriteLine($"Price: ${price:F2}");
        // Access a range of cells - return records from column A
        var productRange = sheet["A2:A10"];
        Console.WriteLine("\nAll products:");
        foreach (var cell in productRange)
        {
            Console.WriteLine($"  - {cell.StringValue}");
        }
    }
}

using IronXL;
using System;

// Example class to demonstrate structured data access
public class Employee
{
    public int Id { get; set; }
    public string Name { get; set; }
    public int Age { get; set; }
}

class Program
{
    static void Main(string[] args)
    {
        WorkBook workbook = WorkBook.LoadCSV("inventory.csv", ExcelFileFormat.XLSX, ",");
        WorkSheet sheet = workbook.DefaultWorkSheet;
        // Access specific cells using Excel-style addresses by index
        string productName = sheet["A2"].StringValue;
        int quantity = sheet["B2"].IntValue;
        decimal price = sheet["C2"].DecimalValue;
        Console.WriteLine($"Product: {productName}");
        Console.WriteLine($"Quantity: {quantity}");
        Console.WriteLine($"Price: ${price:F2}");
        // Access a range of cells - return records from column A
        var productRange = sheet["A2:A10"];
        Console.WriteLine("\nAll products:");
        foreach (var cell in productRange)
        {
            Console.WriteLine($"  - {cell.StringValue}");
        }
    }
}

Imports IronXL
Imports System

' Example class to demonstrate structured data access
Public Class Employee
    Public Property Id As Integer
    Public Property Name As String
    Public Property Age As Integer
End Class

Class Program
    Shared Sub Main(args As String())
        Dim workbook As WorkBook = WorkBook.LoadCSV("inventory.csv", ExcelFileFormat.XLSX, ",")
        Dim sheet As WorkSheet = workbook.DefaultWorkSheet
        ' Access specific cells using Excel-style addresses by index
        Dim productName As String = sheet("A2").StringValue
        Dim quantity As Integer = sheet("B2").IntValue
        Dim price As Decimal = sheet("C2").DecimalValue
        Console.WriteLine($"Product: {productName}")
        Console.WriteLine($"Quantity: {quantity}")
        Console.WriteLine($"Price: ${price:F2}")
        ' Access a range of cells - return records from column A
        Dim productRange = sheet("A2:A10")
        Console.WriteLine(vbCrLf & "All products:")
        For Each cell In productRange
            Console.WriteLine($"  - {cell.StringValue}")
        Next
    End Sub
End Class

L'adressage des cellules suit les conventions Excel où les lettres représentent les colonnes du CSV (A, B, C) et les chiffres représentent les positions d'index de ligne (1, 2, 3). La classe Cell fournit des accesseurs spécifiques au type, notamment StringValue, IntValue, DecimalValue, BoolValue et DateTimeValue. Ces accesseurs gèrent l'analyse syntaxique et la conversion automatiquement, ce qui élimine le moulage manuel des types et réduit la surcharge de mémoire par rapport au stockage de toutes les valeurs sous forme de chaînes.

La sélection d'une plage à l'aide d'une notation telle que A2:A10 renvoie un objet Range qui prend en charge l'itération, les fonctions d'agrégation et les opérations en bloc. Cela s'avère très utile pour extraire des colonnes spécifiques ou des régions de données rectangulaires à partir de fichiers CSV volumineux. Par exemple, vous pouvez créer une nouvelle liste de valeurs à partir d'une colonne spécifique ou écrire des données filtrées dans un autre fichier.

Gestion des erreurs dans les opérations sur les fichiers CSV

Une gestion robuste des erreurs est essentielle lorsque l'on travaille avec des fichiers CSV dans des applications .NET. La lecture et l'écriture de fichiers CSV peuvent entraîner divers problèmes, tels que des fichiers manquants, des données mal formées ou des erreurs d'analyse inattendues. Pour gérer ces scénarios, la meilleure pratique consiste à envelopper les opérations sur les fichiers et les données dans des blocs try-catch, ce qui permet à votre application de gérer les exceptions de manière gracieuse et de fournir un retour d'information significatif.

Conclusion

La lecture de fichiers CSV dans .NET nécessite un effort minimal lorsque l'on utilise la bonne approche. La méthode LoadCSV d'IronXL gère automatiquement la complexité de l'analyse, en prenant en charge divers délimiteurs et en offrant un accès immédiat aux données structurées grâce à des concepts de tableur familiers. Que vous construisiez une application ASP.NET Core, une API Web .NET Core ou un projet de console, cette bibliothèque rationalise le traitement CSV.

Démarrez un essai gratuit pour découvrir comment IronXL simplifie la lecture des fichiers CSV dans vos projets .NET. Pour un déploiement en production, les options de licence commencent à $799 avec des droits d'utilisation perpétuels et un an d'assistance inclus.