Lecteur de fichiers CSV en C# : analyse et traitement des données CSV avec IronXL

Comment installer IronXL pour la lecture de fichiers CSV ?

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.

# .NET CLI
dotnet add package IronXL.Excel

# NuGet Package Manager Console
Install-Package IronXL.Excel

# .NET CLI
dotnet add package IronXL.Excel

# NuGet Package Manager Console
Install-Package IronXL.Excel

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

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
Next

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

Tutoriel du lecteur de fichiers CSV C# : Analyse et conversion de données CSV avec IronXL : Image 1 - Installation NuGet d'IronXL

Comment lire des fichiers CSV avec des délimiteurs personnalisés ?

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,
    listDélimiteur: ";");

// Load tab-separated values (TSV)
WorkBook tsvWorkbook = WorkBook.LoadCSV("export_data.tsv",
    fileFormat: ExcelFileFormat.XLSX,
    listDélimiteur: "\t");

// Load pipe-delimited file
WorkBook pipeWorkbook = WorkBook.LoadCSV("log_export.csv",
    fileFormat: ExcelFileFormat.XLSX,
    listDélimiteur: "|");

// Access data normally after loading
WorkSheet sheet = workbook.DefaultWorkSheet;
decimal totalSales = sheet["B2:B10"].Sum();

Console.WriteLine($"Total sales: {totalSales}");

using IronXL;

// Load CSV with semicolon delimiter (common in European data exports)
WorkBook workbook = WorkBook.LoadCSV("european-data.csv",
    fileFormat: ExcelFileFormat.XLSX,
    listDélimiteur: ";");

// Load tab-separated values (TSV)
WorkBook tsvWorkbook = WorkBook.LoadCSV("export_data.tsv",
    fileFormat: ExcelFileFormat.XLSX,
    listDélimiteur: "\t");

// Load pipe-delimited file
WorkBook pipeWorkbook = WorkBook.LoadCSV("log_export.csv",
    fileFormat: ExcelFileFormat.XLSX,
    listDélimiteur: "|");

// 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,
    listDélimiteur:=";")

' Load tab-separated values (TSV)
Dim tsvWorkbook As WorkBook = WorkBook.LoadCSV("export_data.tsv",
    fileFormat:=ExcelFileFormat.XLSX,
    listDélimiteur:=vbTab)

' Load pipe-delimited file
Dim pipeWorkbook As WorkBook = WorkBook.LoadCSV("log_export.csv",
    fileFormat:=ExcelFileFormat.XLSX,
    listDélimiteur:="|")

' 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 listDélimiteur 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.

Tutoriel du lecteur de fichiers CSV C# : Analyser et convertir des données CSV avec IronXL : Image 2 - Exemple de sortie de démarrage

Comment analyser des données CSV et les convertir en objets C# ?

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

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.

Tutoriel du lecteur de fichiers CSV C# : Analyser et convertir des données CSV avec IronXL : Image 3 - Sortie pour la lecture de différents délimiteurs

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

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

Comment convertir un fichier CSV au format Excel en C# ?

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

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.

Tutoriel du lecteur de fichiers CSV C# : Analyse et conversion de données CSV avec IronXL : Image 4 - Analyse de la sortie des données CSV

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 DataLanguettele
DataLanguettele customerLanguettele = dataSet.Languetteles[0];

Console.WriteLine($"Rows loaded: {customerLanguettele.Rows.Count}");
Console.WriteLine($"Columns: {customerLanguettele.Columns.Count}");

// Process with standard ADO.NET
foreach (DataRow row in customerLanguettele.Rows)
{
    string name = row["Name"]?.ToString() ?? string.Empty;
    string email = row["Email"]?.ToString() ?? string.Empty;
    Console.WriteLine($"Customer: {name} <{email}>");
}

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 DataLanguettele
DataLanguettele customerLanguettele = dataSet.Languetteles[0];

Console.WriteLine($"Rows loaded: {customerLanguettele.Rows.Count}");
Console.WriteLine($"Columns: {customerLanguettele.Columns.Count}");

// Process with standard ADO.NET
foreach (DataRow row in customerLanguettele.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}>")
Next

Comment gérer les fichiers CSV volumineux et optimiser les performances ?

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.

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

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 Function

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

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 Module

Comment obtenir une licence pour IronXL?

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

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 .

Pourquoi IronXL est-il le bon choix pour le traitement des fichiers CSV ?

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 :

• Aucune dépendance à Office : les déploiements serveur et cloud fonctionnent sans installer Microsoft Office ni aucune interface COM
• Délimiteurs personnalisés : N'importe quel caractère ou chaîne de délimitation est pris en charge par le paramètre listDélimiteur
• Type-safe cell access : les accesseurs StringValue, DecimalValue, IntValue et DateTimeValue renvoient des valeurs par défaut sûres au lieu d'être rejetés en cas de mauvaises données
• Opérations sur les plages : Agrégation et interrogation des données sur des plages sans itération ligne par ligne
• Conversion de format : Chargez un fichier CSV et enregistrez-le aux formats XLSX, XLS, PDF ou autres, en une seule étape.
• Intégration des ensembles de données : Convertissez les classeurs chargés en DataSet / DataLanguettele pour ADO.NET et les opérations de base de données
• Multiplateforme : Fonctionne sous Windows, Linux, macOS, Docker et dans les environnements cloud sans modification

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