Comment lire un fichier CSV dans une DataTable en C#

Pourquoi la conversion CSV en DataTable est-elle essentielle ?

La conversion CSV en DataTable permet aux développeurs de transformer des valeurs séparées par des virgules (données CSV) en objets structurés comme une DataTable pour un traitement ultérieur. Que vous traitiez des données d'inventaire, des enregistrements clients ou des journaux de transactions, être capable de convertir un CSV en une nouvelle DataTable efficacement est crucial. En utilisant la première ligne comme en-têtes de colonne, vous pouvez vous assurer que les colonnes de la datatable s'alignent avec le schéma de votre table de base de données.

Les approches traditionnelles rencontrent souvent des difficultés avec les fichiers volumineux, les différents délimiteurs ou la gestion de la mémoire. IronXL élimine ces défis et gère différents délimiteurs, champs entre guillemets et virgules intégrées en toute transparence. Les capacités de lecture CSV d'IronXL éliminent ces points de douleur courants.

Comment installer IronXL ?

Commencer avec IronXL nécessite juste une simple installation de package NuGet. Ouvrez la console du gestionnaire de packages NuGet dans Visual Studio et exécutez :

Install-Package IronXL.Excel

Une fois installé, ajoutez l'espace de noms IronXL à votre projet :

using IronXL;
using System.Data;

using IronXL;
using System.Data;

Imports IronXL
Imports System.Data

Cela vous donne accès à toutes les puissantes capacités de traitement CSV sans aucune dépendance Excel. Pour plus de détails sur l'API étendue d'IronXL, référez-vous à la Documentation de référence API.

Installer avec NuGet

PM >  Install-Package IronXL.Excel

Consultez IronXL sur NuGet pour une installation rapide. Avec plus de 10 millions de téléchargements, il transforme le développement PDF avec C#. Vous pouvez également télécharger le DLL.

Comment convertir un CSV en DataTable ?

La beauté d'IronXL réside dans sa simplicité. Voici comment lire un fichier CSV et le convertir en DataTable :

// Load CSV file into a WorkBook object
WorkBook workbook = WorkBook.LoadCSV("sales_data.csv", 
    fileFormat: ExcelFileFormat.XLSX);
// Access the default worksheet
WorkSheet worksheet = workbook.DefaultWorkSheet;
// Convert to DataTable with headers
DataTable dataTable = worksheet.ToDataTable(true);
// Display the data
foreach (DataRow row in dataTable.Rows)
{
    foreach (var item in row.ItemArray)
    {
        Console.Write($"{item}\t");
    }
    Console.WriteLine();
}

// Load CSV file into a WorkBook object
WorkBook workbook = WorkBook.LoadCSV("sales_data.csv", 
    fileFormat: ExcelFileFormat.XLSX);
// Access the default worksheet
WorkSheet worksheet = workbook.DefaultWorkSheet;
// Convert to DataTable with headers
DataTable dataTable = worksheet.ToDataTable(true);
// Display the data
foreach (DataRow row in dataTable.Rows)
{
    foreach (var item in row.ItemArray)
    {
        Console.Write($"{item}\t");
    }
    Console.WriteLine();
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

La méthode LoadCSV analyse intelligemment votre fichier CSV, gérant automatiquement les cas courants tels que les champs entre guillemets et les virgules intégrées. Le paramètre fileFormat indique à IronXL comment interpréter les données CSV en interne, garantissant qu'elles sont traitées comme une structure compatible avec Excel. Une fois chargé, la méthode ToDataTable(true) convertit la feuille de calcul en une DataTable, avec le paramètre true indiquant que la première ligne doit être utilisée comme en-têtes de colonne. Cela aboutit à une DataTable propre et structurée avec des colonnes nommées qui correspondent à vos en-têtes CSV. Pour plus d'options de manipulation avancées, explorez le didacticiel complet Excel vers DataTable.

Comment importer une DataTable dans SQL Server ?

Une fois que vous avez votre DataTable, l'importer dans SQL Server devient remarquablement efficace en utilisant SqlBulkCopy :

using System.Data;
using Microsoft.Data.SqlClient;
using IronXL;
class Program
{
    static void Main(string[] args)
    {
        // Create connection string
        string connectionString = @"Data Source=localhost;Initial Catalog=SalesDB;
                           Integrated Security=True;TrustServerCertificate=True;";
        // Read CSV into DataTable
        WorkBook workbook = WorkBook.LoadCSV("inventory_report.csv");
        DataTable dataTable = workbook.DefaultWorkSheet.ToDataTable(true);
        // Bulk insert into SQL Server
        using (SqlConnection connection = new SqlConnection(connectionString))
        {
            connection.Open();
            using (SqlBulkCopy bulkCopy = new SqlBulkCopy(connection))
            {
                // Set destination table name
                bulkCopy.DestinationTableName = "dbo.Inventory";
                // Map DataTable columns to SQL table columns
                bulkCopy.ColumnMappings.Add("ProductCode", "product_code");
                bulkCopy.ColumnMappings.Add("Quantity", "quantity");
                bulkCopy.ColumnMappings.Add("LastUpdated", "last_updated");
                // Set batch size for better performance
                bulkCopy.BatchSize = 1000;
                // Write data to SQL Server
                bulkCopy.WriteToServer(dataTable);
            }
        }
        Console.WriteLine($"Successfully imported {dataTable.Rows.Count} records");
    }
}

using System.Data;
using Microsoft.Data.SqlClient;
using IronXL;
class Program
{
    static void Main(string[] args)
    {
        // Create connection string
        string connectionString = @"Data Source=localhost;Initial Catalog=SalesDB;
                           Integrated Security=True;TrustServerCertificate=True;";
        // Read CSV into DataTable
        WorkBook workbook = WorkBook.LoadCSV("inventory_report.csv");
        DataTable dataTable = workbook.DefaultWorkSheet.ToDataTable(true);
        // Bulk insert into SQL Server
        using (SqlConnection connection = new SqlConnection(connectionString))
        {
            connection.Open();
            using (SqlBulkCopy bulkCopy = new SqlBulkCopy(connection))
            {
                // Set destination table name
                bulkCopy.DestinationTableName = "dbo.Inventory";
                // Map DataTable columns to SQL table columns
                bulkCopy.ColumnMappings.Add("ProductCode", "product_code");
                bulkCopy.ColumnMappings.Add("Quantity", "quantity");
                bulkCopy.ColumnMappings.Add("LastUpdated", "last_updated");
                // Set batch size for better performance
                bulkCopy.BatchSize = 1000;
                // Write data to SQL Server
                bulkCopy.WriteToServer(dataTable);
            }
        }
        Console.WriteLine($"Successfully imported {dataTable.Rows.Count} records");
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

La classe SqlBulkCopy offre une performance exceptionnelle pour les importations de données à grande échelle. La collection ColumnMappings vous permet de mapper les colonnes de la DataTable aux colonnes de la base de données avec des noms différents, assurant une flexibilité dans votre schéma de données. La propriété BatchSize optimise l'utilisation de la mémoire en traitant les enregistrements par lots plutôt que de tout charger d'un coup. Cette approche peut gérer efficacement des millions d'enregistrements, ce qui la rend idéale pour les opérations de données à l'échelle de l'entreprise. En savoir plus sur les capacités d'IronXL en matière de DataSet et DataTable.

Comment gérer différents délimiteurs ?

Tous les fichiers CSV n'utilisent pas de virgules. IronXL gère en toute transparence divers délimiteurs :

using IronXL;
using System;
using System.Data;
using System.IO;
class Program
{
    static void Main()
    {
        // --- Tab-delimited file ---
        string tsvPath = @"export_data.tsv";
        WorkBook tsvWorkbook = WorkBook.LoadCSV(tsvPath, ExcelFileFormat.XLSX, "\t");
        // --- Semicolon-delimited file ---
        string semiPath = @"european_data.csv";
        string tempCsv = Path.Combine(Path.GetTempPath(), "european_data_comma.csv");
        // Replace semicolons with commas for proper parsing
        var lines = File.ReadAllLines(semiPath);
        for (int i = 0; i < lines.Length; i++)
        {
            lines[i] = lines[i].Replace(';', ',');
        }
        File.WriteAllLines(tempCsv, lines);
        WorkBook semiWorkbook = WorkBook.LoadCSV(tempCsv, ExcelFileFormat.XLSX);
        // Print both workbooks
        PrintWorkbook(tsvWorkbook, "Tab-delimited File");
        PrintWorkbook(semiWorkbook, "Semicolon-delimited File");
    }
    static void PrintWorkbook(WorkBook workbook, string name)
    {
        Console.WriteLine($"\n--- {name} ---\n");
        DataTable dt = workbook.DefaultWorkSheet.ToDataTable(true);
        // Print column headers
        foreach (DataColumn col in dt.Columns)
        {
            Console.Write($"{col.ColumnName}\t");
        }
        Console.WriteLine();
        // Print rows
        foreach (DataRow row in dt.Rows)
        {
            foreach (var item in row.ItemArray)
            {
                Console.Write($"{item}\t");
            }
            Console.WriteLine();
        }
    }
}

using IronXL;
using System;
using System.Data;
using System.IO;
class Program
{
    static void Main()
    {
        // --- Tab-delimited file ---
        string tsvPath = @"export_data.tsv";
        WorkBook tsvWorkbook = WorkBook.LoadCSV(tsvPath, ExcelFileFormat.XLSX, "\t");
        // --- Semicolon-delimited file ---
        string semiPath = @"european_data.csv";
        string tempCsv = Path.Combine(Path.GetTempPath(), "european_data_comma.csv");
        // Replace semicolons with commas for proper parsing
        var lines = File.ReadAllLines(semiPath);
        for (int i = 0; i < lines.Length; i++)
        {
            lines[i] = lines[i].Replace(';', ',');
        }
        File.WriteAllLines(tempCsv, lines);
        WorkBook semiWorkbook = WorkBook.LoadCSV(tempCsv, ExcelFileFormat.XLSX);
        // Print both workbooks
        PrintWorkbook(tsvWorkbook, "Tab-delimited File");
        PrintWorkbook(semiWorkbook, "Semicolon-delimited File");
    }
    static void PrintWorkbook(WorkBook workbook, string name)
    {
        Console.WriteLine($"\n--- {name} ---\n");
        DataTable dt = workbook.DefaultWorkSheet.ToDataTable(true);
        // Print column headers
        foreach (DataColumn col in dt.Columns)
        {
            Console.Write($"{col.ColumnName}\t");
        }
        Console.WriteLine();
        // Print rows
        foreach (DataRow row in dt.Rows)
        {
            foreach (var item in row.ItemArray)
            {
                Console.Write($"{item}\t");
            }
            Console.WriteLine();
        }
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Ce code charge des fichiers CSV avec différents délimiteurs dans des objets IronXL WorkBook. Les fichiers délimités par des tabulations sont lus en utilisant "\t" comme séparateur, tandis que les fichiers délimités par des points-virgules sont convertis en format CSV standard avant le chargement. La feuille de travail par défaut de chaque workbook est convertie en une DataTable avec ToDataTable(true), qui utilise la première ligne comme en-têtes de colonne.

La méthode PrintWorkbook parcourt ensuite la DataTable et affiche les données dans la console, y compris les en-têtes et toutes les lignes. Cette flexibilité répond à de nombreux défis courants de parsing CSV discutés par des développeurs.

Conclusion

IronXL transforme la tâche complexe des importations de base de données CSV en un processus simple et fiable. Avec seulement quelques lignes de code, vous pouvez :

• Lire des fichiers CSV depuis n'importe quel chemin de fichier
• Convertir les données CSV en une nouvelle DataTable
• Préserver les en-têtes de colonne et les colonnes de la DataTable
• Importer des millions de lignes dans une table de base de données efficacement

La bibliothèque gère automatiquement les subtilités du parsing CSV, de la gestion de la mémoire et des conversions de types de données, vous permettant de vous concentrer sur votre logique métier plutôt que sur les détails du traitement des fichiers.

Prêt à rationaliser votre flux de travail d'importation de données ? Commencez votre essai gratuit pour trouver l'ajustement parfait aux besoins de votre équipe.