Icône de message
Passer au contenu du pied de page
  1. IronXL
  2. Blog IronXL
  3. Utilisation d'IronXL
  4. C# Csv File Reader Blog
UTILISATION D'IRONXL

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

Jordi Bardia
Jordi Bardia
Mis à jour:

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.

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
SHELL

Pour plus de détails sur les options d'installation et la configuration, consultez la documentation d'installation 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);
    }
}
$vbLabelText   $csharpLabel

La méthode WorkBook.LoadCSV gère l'identification de l'en-tête, crée une structure de données interne et effectue une analyse efficace en termes de mémoire, simplifiant ainsi la gestion de vos données dès la première ligne de code.

Tutoriel C# : Lecture et conversion de fichiers CSV avec IronXL : Image 1 - Installation du NuGet 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}");
$vbLabelText   $csharpLabel

Le paramètre listDélimiteur accepte n'importe quelle chaîne de caractères, vous donnant un contrôle total sur le comportement d'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 C# : Lecture et conversion de fichiers CSV avec IronXL: Image 2 - Exemple de sortie pour bien démarrer.

Formats de fichiers et délimiteurs pris en charge

IronXL prend en charge le chargement des types de délimiteurs suivants lors de la lecture de fichiers CSV :

Types de délimiteurs courants pris en charge par la méthode LoadCSV d'IronXL
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

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

Les propriétés de valeur typées d'IronXL -- StringValue, DecimalValue, IntValue, DateTimeValue -- gèrent les conversions en toute sécurité, en renvoyant des valeurs par défaut pour les données invalides plutôt que de lever 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 C# sur la lecture de fichiers CSV : analyser et convertir des données CSV avec IronXL: Image 3 - Sortie pour la lecture de différents délimiteurs.

Comment filtrer et interroger des données CSV avec LINQ ?

Une fois les données CSV chargées dans un WorkSheet, vous pouvez les manipuler à 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}");
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}");
$vbLabelText   $csharpLabel

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.

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 simplifie 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");
$vbLabelText   $csharpLabel

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 d'exportation couvre les options d'exportation aux formats XLSX, XLS, CSV et PDF. Vous pouvez également apprendre à écrire des fichiers Excel et à créer des fichiers Excel à partir de zéro .

Tutoriel C# sur la lecture de fichiers CSV : analyser et convertir des données CSV avec IronXL: Image 4 - Analyse des données CSV en sortie.

Conversion d'un fichier CSV en DataSet pour les opérations de base de données

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 prise en charge de conversion directe. Le guide Excel vers 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 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}>");
}
$vbLabelText   $csharpLabel

Cette 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 DataLanguettele sont des types .NET de base, ce chemin ne nécessite aucune dépendance supplémentaire au-delà IronXL lui-même.

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.

Utilisation des opérations de plage pour les performances

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;
}
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;
}
$vbLabelText   $csharpLabel

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

Gestion des erreurs pour les sources CSV non fiables

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

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

Tutoriel C# sur la lecture de fichiers CSV : analyser et convertir des données CSV avec IronXL: Image 5 - Conversion d'un fichier CSV au format Excel

Déploiement multiplateforme

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.

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

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 manuelle des fichiers CSV avec string.Split ou StreamReader échoue rapidement lorsque les champs entre guillemets contiennent le caractère délimiteur, 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 : Tout caractère ou chaîne de caractères délimiteur est pris en charge via le paramètre listDélimiteur
  • Accès aux cellules sécurisé par type : les accesseurs StringValue, DecimalValue, IntValue et DateTimeValue renvoient des valeurs par défaut sûres au lieu de lever une exception en cas de données incorrectes.
  • Opérations sur les plages : agréger et interroger 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 jeux de données : Convertir les classeurs chargés au format DataSet / DataLanguettele pour les opérations .NET et 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 informations 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 .

Questions Fréquemment Posées

Qu'est-ce qu'un fichier CSV et pourquoi est-il couramment utilisé ?

Un fichier CSV (Comma-Separated Values) est un format texte simple permettant de stocker des données tabulaires. De par sa simplicité et sa facilité d'utilisation, il est largement utilisé dans les applications d'entreprise pour l'exportation et l'importation de données entre différents systèmes.

Comment IronXL facilite-t-il l'analyse des fichiers CSV en C# ?

IronXL simplifie l'analyse des fichiers CSV en C# en fournissant des outils robustes pour gérer les structures CSV complexes, notamment les différents séparateurs de colonnes, les champs entre guillemets et les conversions de types de données.

IronXL peut-il convertir des données CSV en d'autres formats ?

Oui, IronXL permet aux développeurs de convertir des données CSV en différents formats, tels que XML et Excel, ce qui le rend polyvalent pour répondre à différents besoins de traitement des données.

Quels sont les problèmes courants liés à l'analyse des fichiers CSV ?

Les difficultés courantes incluent la gestion des différents séparateurs de colonnes, des champs entre guillemets et la conversion précise des types de données. IronXL contribue à atténuer ces problèmes grâce à ses fonctionnalités d'analyse avancées.

IronXL est-il adapté à la gestion des fichiers CSV en entreprise ?

Oui, IronXL est conçu pour être prêt pour l'entreprise, offrant des solutions de gestion de fichiers CSV robustes et évolutives pour les applications .NET .

IronXL permet-il de traiter efficacement les fichiers CSV volumineux ?

IronXL est optimisé pour la performance, ce qui lui permet de traiter efficacement les fichiers CSV volumineux sans compromettre la vitesse ni la précision.

IronXL peut-il gérer les fichiers CSV avec des délimiteurs personnalisés ?

Oui, IronXL prend en charge les fichiers CSV avec des délimiteurs personnalisés, offrant ainsi aux développeurs une grande flexibilité lorsqu'ils travaillent avec des formats CSV non standard.

Comment IronXL gère-t-il les champs entre guillemets dans les fichiers CSV ?

IronXL analyse avec précision les champs entre guillemets dans les fichiers CSV, garantissant ainsi l'intégrité des données et une conversion correcte lors du processus de lecture.

Quels langages de programmation peuvent être utilisés avec IronXL pour l'analyse des fichiers CSV ?

IronXL est une bibliothèque .NET , elle peut donc être utilisée avec les langages pris en charge par le .NET Framework, tels que C# et VB .NET.

Existe-t-il des exemples de code disponibles pour utiliser IronXL avec des fichiers CSV ?

Oui, la documentation IronXL fournit des exemples de code complets pour la lecture, l'analyse et le traitement des fichiers CSV dans les applications C#.

Jordi Bardia
Jordi Bardia
  Discutez maintenant avec l'équipe d'ingénierie
Ingénieur logiciel
Jordi est le plus compétent en Python, C# et C++, et lorsqu'il ne met pas à profit ses compétences chez Iron Software, il programme des jeux. Partageant les responsabilités des tests de produit, du développement de produit et de la recherche, Jordi apporte une immense valeur à l'amé...
Lire la suite

Articles connexes

Essai de 30 jours → Produit complet. Pas de limites. Pas de carte. Essai gratuit

Iron Support Team

We're online 24 hours, 5 days a week.
Chat
Email
Call Me