Dans le monde numérique d'aujourd'hui, la gestion efficace des données est une tâche importante. Une exigence courante en développement logiciel consiste à lire des données à partir d'un fichier CSV et à les stocker dans une base de données. Ce tutoriel décrit les étapes permettant de lire des données à partir d'un fichier CSV et de les stocker dans une base de données SQL Server en utilisant C#, et plus précisément la bibliothèque IronXL . Ce guide est conçu pour les débutants et sera expliqué de manière simple et attrayante.

Comprendre les principes de base

Qu'est-ce qu'un fichier CSV ?

Un fichier CSV (Comma-Separated Values) est un fichier texte brut contenant des données séparées par des virgules. C'est un format populaire pour le transfert de données en raison de sa simplicité et de sa compatibilité avec diverses applications, telles qu'Excel.

Le rôle de SQL Server et des bases de données

SQL Server est un système de gestion de bases de données développé par Microsoft. Il sert à stocker et à gérer des données de manière structurée. Dans notre cas, nous stockerons les données CSV dans une table SQL Server.

Introduction à IronXL

IronXL est une bibliothèque Excel conçue spécifiquement pour les applications .NET, permettant aux développeurs de lire, générer et modifier des fichiers Excel sans avoir recours à l'interopérabilité Microsoft Office. Cette bibliothèque se distingue par sa compatibilité avec différentes versions et plateformes .NET, notamment .NET Core, .NET Standard et .NET Framework, ainsi que par sa prise en charge de divers systèmes d'exploitation tels que Windows, Linux et macOS. C'est une bibliothèque puissante pour l'importation de données, notamment pour la gestion des fichiers CSV.

How to Read and Store Data From CSV Files in C#

1. Créez un programme console C# dans Visual Studio.
2. Installez la bibliothèque CSV à l'aide du gestionnaire de packages NuGet.
3. Chargez le fichier CSV dans le programme en utilisant la bibliothèque.
4. Établissez une connexion avec la base de données.
5. Lire le contenu du fichier CSV avec la bibliothèque.
6. Copiez ce contenu dans la base de données en utilisant la méthode SqlBulkCopy.

Voici un exemple d'extrait de code :

using System;
using System.Data;
using System.Data.SqlClient; // For .NET Core/.NET 5+, use Microsoft.Data.SqlClient instead
using System.Globalization;
using System.IO;
using CsvHelper;

namespace CsvReader
{
    class Program
    {
        static void Main(string[] args)
        {
            string csvPath = @"path\to\your\csv\file.csv";

            using (var reader = new StreamReader(csvPath))
            using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
            {
                // Mapping the CSV data to the corresponding model
                var records = csv.GetRecords<YourModel>();

                using (var sqlBulkCopy = new SqlBulkCopy("your_connection_string"))
                {
                    sqlBulkCopy.DestinationTableName = "YourTableName";
                    sqlBulkCopy.WriteToServer(records.AsDataReader());
                }

                Console.WriteLine("Data imported successfully!");
            }
        }
    }

    // Define your model that maps to the CSV columns
    public class YourModel
    {
        // Define properties here representing the CSV columns
    }
}

using System;
using System.Data;
using System.Data.SqlClient; // For .NET Core/.NET 5+, use Microsoft.Data.SqlClient instead
using System.Globalization;
using System.IO;
using CsvHelper;

namespace CsvReader
{
    class Program
    {
        static void Main(string[] args)
        {
            string csvPath = @"path\to\your\csv\file.csv";

            using (var reader = new StreamReader(csvPath))
            using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
            {
                // Mapping the CSV data to the corresponding model
                var records = csv.GetRecords<YourModel>();

                using (var sqlBulkCopy = new SqlBulkCopy("your_connection_string"))
                {
                    sqlBulkCopy.DestinationTableName = "YourTableName";
                    sqlBulkCopy.WriteToServer(records.AsDataReader());
                }

                Console.WriteLine("Data imported successfully!");
            }
        }
    }

    // Define your model that maps to the CSV columns
    public class YourModel
    {
        // Define properties here representing the CSV columns
    }
}

Imports System
Imports System.Data
Imports System.Data.SqlClient ' For .NET Core/.NET 5+, use Microsoft.Data.SqlClient instead
Imports System.Globalization
Imports System.IO
Imports CsvHelper

Namespace CsvReader
    Class Program
        Shared Sub Main(args As String())
            Dim csvPath As String = "path\to\your\csv\file.csv"

            Using reader As New StreamReader(csvPath)
                Using csv As New CsvReader(reader, CultureInfo.InvariantCulture)
                    ' Mapping the CSV data to the corresponding model
                    Dim records = csv.GetRecords(Of YourModel)()

                    Using sqlBulkCopy As New SqlBulkCopy("your_connection_string")
                        sqlBulkCopy.DestinationTableName = "YourTableName"
                        sqlBulkCopy.WriteToServer(records.AsDataReader())
                    End Using

                    Console.WriteLine("Data imported successfully!")
                End Using
            End Using
        End Sub
    End Class

    ' Define your model that maps to the CSV columns
    Public Class YourModel
        ' Define properties here representing the CSV columns
    End Class
End Namespace

Imports System
Imports System.Data
Imports System.Data.SqlClient ' For .NET Core/.NET 5+, use Microsoft.Data.SqlClient instead
Imports System.Globalization
Imports System.IO
Imports CsvHelper

Namespace CsvReader
    Class Program
        Shared Sub Main(args As String())
            Dim csvPath As String = "path\to\your\csv\file.csv"

            Using reader As New StreamReader(csvPath)
                Using csv As New CsvReader(reader, CultureInfo.InvariantCulture)
                    ' Mapping the CSV data to the corresponding model
                    Dim records = csv.GetRecords(Of YourModel)()

                    Using sqlBulkCopy As New SqlBulkCopy("your_connection_string")
                        sqlBulkCopy.DestinationTableName = "YourTableName"
                        sqlBulkCopy.WriteToServer(records.AsDataReader())
                    End Using

                    Console.WriteLine("Data imported successfully!")
                End Using
            End Using
        End Sub
    End Class

    ' Define your model that maps to the CSV columns
    Public Class YourModel
        ' Define properties here representing the CSV columns
    End Class
End Namespace

Assurez-vous de remplacer "path\to\your\csv\file.csv" par le chemin réel vers votre fichier CSV, YourModel par le modèle représentant vos données CSV, "your_connection_string" par votre chaîne de connexion à la base de données, et "YourTableName" par le nom de votre table de base de données.

Configurer l'Environnement

Prérequis

1. Visual Studio : assurez-vous d'avoir installé Visual Studio.
2. Serveur SQL : Vous devez avoir installé et accessible le serveur SQL.
3. Installation IronXL : Installez IronXL en exécutant la commande NuGet suivante :

dotnet add package IronXL.Excel

Veillez à exécuter ces commandes dans le répertoire du projet où vous souhaitez installer IronXL.

Création d'une table SQL Server

Avant d'importer des données, créez une table de destination dans votre base de données SQL Server. Ce tableau stockera les données CSV.

CREATE TABLE YourTableName (
    Column1 DataType,
    Column2 DataType,
    ...
);

CREATE TABLE YourTableName (
    Column1 DataType,
    Column2 DataType,
    ...
);

Remplacez YourTableName, Column1, Column2, et DataType par vos détails spécifiques.

Guide étape par étape pour importer des données CSV

1. Tout d'abord, assurez-vous de disposer d'un fichier CSV contenant les données que vous souhaitez importer.

2. Créez un nouveau projet d'application console C# dans Visual Studio.

3. Installez le package NuGet CsvHelper pour la lecture des fichiers CSV. Vous pouvez le faire en ouvrant la console du gestionnaire de packages NuGet dans Visual Studio et en exécutant la commande suivante :

   Install-Package CsvHelper

   SHELL

4. Ajoutez les instructions using nécessaires en haut de votre fichier de code C# :

   using System;
   using System.IO;
   using System.Globalization;
   using CsvHelper;
   using System.Data.SqlClient; // For .NET Core/.NET 5+, use Microsoft.Data.SqlClient instead

   Imports System
   Imports System.IO
   Imports System.Globalization
   Imports CsvHelper
   Imports System.Data.SqlClient ' For .NET Core/.NET 5+, use Microsoft.Data.SqlClient instead

   C#VB

5. Dans votre code, spécifiez le chemin d'accès à votre fichier CSV. Par exemple :

   string csvFilePath = @"C:\path\to\your\csv\file.csv";

   Dim csvFilePath As String = "C:\path\to\your\csv\file.csv"

   C#VB

   Assurez-vous de remplacer C:\path\to\your\csv\file.csv par le chemin réel vers votre fichier CSV.

6. Créez une nouvelle instance de la classe StreamReader pour lire le fichier CSV :

   using (var reader = new StreamReader(csvFilePath))
   {
       // code goes here
   }

   Using reader = New StreamReader(csvFilePath)
   	' code goes here
   End Using

   C#VB

7. Créez une nouvelle instance de la classe CsvReader, en passant l'objet StreamReader :

   using (var reader = new StreamReader(csvFilePath))
   using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
   {
       // code goes here
   }

   Using reader = New StreamReader(csvFilePath)
   Using csv = New CsvReader(reader, CultureInfo.InvariantCulture)
   	' code goes here
   End Using
   End Using

   C#VB

8. Facultativement, configurez le CsvReader avec tous les paramètres nécessaires en passant un objet CsvConfiguration à son constructeur. Par exemple :

   var config = new CsvConfiguration(CultureInfo.InvariantCulture)
   {
       HasHeaderRecord = true,
   };
   using var csv = new CsvReader(reader, config);

   Imports System.Globalization
   Imports CsvHelper
   
   Dim config As New CsvConfiguration(CultureInfo.InvariantCulture) With {
       .HasHeaderRecord = True
   }
   
   Using csv As New CsvReader(reader, config)
       ' Use csv here
   End Using

   C#VB

9. Utilisez la méthode GetRecords<t>() de l'objet CsvReader pour lire les données CSV dans une collection d'objets. Remplacez <t> par le type d'objet qui représente chaque enregistrement dans le fichier CSV. Par exemple :

   var records = csv.GetRecords<YourModel>();

   Dim records = csv.GetRecords(Of YourModel)()

   C#VB

   Assurez-vous de remplacer YourModel par le nom réel de votre classe modèle.

10. Parcourir les enregistrements et effectuer tout traitement ou validation requis :

    foreach (var record in records)
    {
        // Process each record as needed
    }

    For Each record In records
    	' Process each record as needed
    Next record

    C#VB

11. Facultatif : établissez une connexion à votre base de données SQL Server à l'aide d'ADO.NET ou d'un outil ORM comme Entity Framework.

12. Insérez chaque enregistrement dans la base de données en utilisant le mécanisme d'accès à la base de données que vous avez choisi. Par exemple, si vous utilisez ADO.NET, vous pouvez tirer parti de la classe SqlBulkCopy pour insérer efficacement en masse les données.

13. Gérez les exceptions qui pourraient survenir pendant le processus d'importation et fournissez des messages d'erreur ou une journalisation appropriés.

14. Testez votre application en l'exécutant et en vérifiant que les données CSV sont correctement importées dans votre base de données.

Et voilà ! Vous avez maintenant importé avec succès des données CSV dans votre base de données SQL Server en utilisant C#.

Étape 1 : Lecture du fichier CSV

Lorsqu'on commence l'importation de données à partir d'un fichier CSV, la première étape cruciale consiste à lire correctement les données qu'il contient. Chaque ligne d'un fichier CSV représente généralement un enregistrement de données, et chaque enregistrement est constitué d'un ou plusieurs champs, séparés par des virgules.

Nous utilisons alors la bibliothèque IronXL pour gérer le fichier CSV. Pour lire le fichier CSV avec IronXL, vous utiliserez ses classes WorkBook et WorkSheet. La classe WorkBook représente une feuille de calcul entière, qui pourrait être un fichier Excel ou, dans notre cas, un fichier CSV. Lorsque vous chargez le chemin du fichier CSV dans un objet WorkBook, IronXL traite le fichier CSV comme une feuille de calcul/table de données.

using IronXL;
using System.Data;

public class CSVReader
{
    // Reads a CSV file and converts it to a DataTable
    public DataTable ReadCSV(string filePath)
    {
        WorkBook workbook = WorkBook.Load(filePath);
        WorkSheet sheet = workbook.DefaultWorkSheet;
        // Convert to DataTable for easier processing
        DataTable dataTable = sheet.ToDataTable(true); // Set to 'true' if your CSV has a header row
        return dataTable;
    }
}

using IronXL;
using System.Data;

public class CSVReader
{
    // Reads a CSV file and converts it to a DataTable
    public DataTable ReadCSV(string filePath)
    {
        WorkBook workbook = WorkBook.Load(filePath);
        WorkSheet sheet = workbook.DefaultWorkSheet;
        // Convert to DataTable for easier processing
        DataTable dataTable = sheet.ToDataTable(true); // Set to 'true' if your CSV has a header row
        return dataTable;
    }
}

Imports IronXL
Imports System.Data

Public Class CSVReader
	' Reads a CSV file and converts it to a DataTable
	Public Function ReadCSV(ByVal filePath As String) As DataTable
		Dim workbook As WorkBook = WorkBook.Load(filePath)
		Dim sheet As WorkSheet = workbook.DefaultWorkSheet
		' Convert to DataTable for easier processing
		Dim dataTable As DataTable = sheet.ToDataTable(True) ' Set to 'true' if your CSV has a header row
		Return dataTable
	End Function
End Class

Imports IronXL
Imports System.Data

Public Class CSVReader
	' Reads a CSV file and converts it to a DataTable
	Public Function ReadCSV(ByVal filePath As String) As DataTable
		Dim workbook As WorkBook = WorkBook.Load(filePath)
		Dim sheet As WorkSheet = workbook.DefaultWorkSheet
		' Convert to DataTable for easier processing
		Dim dataTable As DataTable = sheet.ToDataTable(True) ' Set to 'true' if your CSV has a header row
		Return dataTable
	End Function
End Class

Étape 2 : Établissement d'une connexion à la base de données

L'établissement d'une connexion à votre base de données SQL Server est une étape fondamentale du processus de stockage de vos données CSV. Cette étape consiste à établir une liaison de communication entre votre application et le serveur de base de données. Une connexion réussie est cruciale car, sans elle, le transfert de données vers la base de données serait impossible.

Cette étape consiste à créer et à ouvrir une connexion à l'aide d'une chaîne de connexion en C#. La chaîne de connexion est un élément essentiel car elle contient les informations nécessaires à l'établissement de la connexion. C'est comme une clé qui ouvre la porte de votre base de données.

using System.Data.SqlClient; // For .NET Core/.NET 5+, use Microsoft.Data.SqlClient instead

public class DatabaseConnector
{
    // Connection string to connect to the database
    private string connectionString = "your_connection_string_here";

    public SqlConnection ConnectToDatabase()
    {
        SqlConnection connection = new SqlConnection(connectionString);
        connection.Open();
        return connection;
    }
}

using System.Data.SqlClient; // For .NET Core/.NET 5+, use Microsoft.Data.SqlClient instead

public class DatabaseConnector
{
    // Connection string to connect to the database
    private string connectionString = "your_connection_string_here";

    public SqlConnection ConnectToDatabase()
    {
        SqlConnection connection = new SqlConnection(connectionString);
        connection.Open();
        return connection;
    }
}

Imports System.Data.SqlClient ' For .NET Core/.NET 5+, use Microsoft.Data.SqlClient instead

Public Class DatabaseConnector
    ' Connection string to connect to the database
    Private connectionString As String = "your_connection_string_here"

    Public Function ConnectToDatabase() As SqlConnection
        Dim connection As New SqlConnection(connectionString)
        connection.Open()
        Return connection
    End Function
End Class

Imports System.Data.SqlClient ' For .NET Core/.NET 5+, use Microsoft.Data.SqlClient instead

Public Class DatabaseConnector
    ' Connection string to connect to the database
    Private connectionString As String = "your_connection_string_here"

    Public Function ConnectToDatabase() As SqlConnection
        Dim connection As New SqlConnection(connectionString)
        connection.Open()
        Return connection
    End Function
End Class

La variable connectionString contient tous les détails nécessaires pour se connecter à votre SQL Server. Il comprend généralement le nom du serveur, le nom de la base de données, l'identifiant de l'utilisateur et le mot de passe. Un exemple de chaîne de connexion ressemble à ceci : Server=myServerAddress;Database=myDataBase;User Id=myUsername;Password=myPassword;. Il est essentiel de remplacer ces espaces réservés par les informations réelles de votre serveur.

Étape 3 : Stockage des données dans la base de données

Une fois la connexion établie avec la base de données SQL Server, l'étape cruciale suivante consiste à stocker les données CSV dans la base de données. Cette étape consiste à transférer les données que vous avez lues et traitées dans votre table SQL Server. Il s'agit d'une étape cruciale du processus de traitement des données, car elle implique la migration effective des données d'un fichier local vers un serveur de base de données.

Dans cette étape, nous nous concentrerons sur la manière dont les données CSV, maintenant stockées dans un DataTable, sont transférées vers la base de données SQL Server. Nous utilisons une combinaison de fonctionnalités C# et SQL Server pour accomplir cette tâche efficacement.

using System;
using System.Data;
using System.Data.SqlClient; // For .NET Core/.NET 5+, use Microsoft.Data.SqlClient instead

public class DataImporter
{
    public void ImportData(DataTable dataTable)
    {
        using (SqlConnection connection = new DatabaseConnector().ConnectToDatabase())
        {
            // Check if the table exists and create it if it does not.
            string tableName = "CSVData"; // Use a valid SQL table name format
            string checkTable = $"IF NOT EXISTS (SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = '{tableName}') BEGIN ";
            string createTable = "CREATE TABLE " + tableName + " (";
            for (int i = 0; i < dataTable.Columns.Count; i++)
            {
                createTable += $"[{dataTable.Columns[i].ColumnName}] NVARCHAR(MAX)";
                if (i < dataTable.Columns.Count - 1)
                    createTable += ", ";
            }
            createTable += ") END";
            SqlCommand createTableCommand = new SqlCommand(checkTable + createTable, connection);
            createTableCommand.ExecuteNonQuery();

            // Now we use SqlBulkCopy to import the data
            using (SqlBulkCopy bulkCopy = new SqlBulkCopy(connection))
            {
                bulkCopy.DestinationTableName = tableName;
                try
                {
                    bulkCopy.WriteToServer(dataTable);
                    Console.WriteLine("Data imported successfully!");
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
            }
        }
    }
}

using System;
using System.Data;
using System.Data.SqlClient; // For .NET Core/.NET 5+, use Microsoft.Data.SqlClient instead

public class DataImporter
{
    public void ImportData(DataTable dataTable)
    {
        using (SqlConnection connection = new DatabaseConnector().ConnectToDatabase())
        {
            // Check if the table exists and create it if it does not.
            string tableName = "CSVData"; // Use a valid SQL table name format
            string checkTable = $"IF NOT EXISTS (SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = '{tableName}') BEGIN ";
            string createTable = "CREATE TABLE " + tableName + " (";
            for (int i = 0; i < dataTable.Columns.Count; i++)
            {
                createTable += $"[{dataTable.Columns[i].ColumnName}] NVARCHAR(MAX)";
                if (i < dataTable.Columns.Count - 1)
                    createTable += ", ";
            }
            createTable += ") END";
            SqlCommand createTableCommand = new SqlCommand(checkTable + createTable, connection);
            createTableCommand.ExecuteNonQuery();

            // Now we use SqlBulkCopy to import the data
            using (SqlBulkCopy bulkCopy = new SqlBulkCopy(connection))
            {
                bulkCopy.DestinationTableName = tableName;
                try
                {
                    bulkCopy.WriteToServer(dataTable);
                    Console.WriteLine("Data imported successfully!");
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
            }
        }
    }
}

Imports System
Imports System.Data
Imports System.Data.SqlClient ' For .NET Core/.NET 5+, use Microsoft.Data.SqlClient instead

Public Class DataImporter
    Public Sub ImportData(dataTable As DataTable)
        Using connection As SqlConnection = New DatabaseConnector().ConnectToDatabase()
            ' Check if the table exists and create it if it does not.
            Dim tableName As String = "CSVData" ' Use a valid SQL table name format
            Dim checkTable As String = $"IF NOT EXISTS (SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = '{tableName}') BEGIN "
            Dim createTable As String = "CREATE TABLE " & tableName & " ("
            For i As Integer = 0 To dataTable.Columns.Count - 1
                createTable &= $"[{dataTable.Columns(i).ColumnName}] NVARCHAR(MAX)"
                If i < dataTable.Columns.Count - 1 Then
                    createTable &= ", "
                End If
            Next
            createTable &= ") END"
            Dim createTableCommand As New SqlCommand(checkTable & createTable, connection)
            createTableCommand.ExecuteNonQuery()

            ' Now we use SqlBulkCopy to import the data
            Using bulkCopy As New SqlBulkCopy(connection)
                bulkCopy.DestinationTableName = tableName
                Try
                    bulkCopy.WriteToServer(dataTable)
                    Console.WriteLine("Data imported successfully!")
                Catch ex As Exception
                    Console.WriteLine(ex.Message)
                End Try
            End Using
        End Using
    End Sub
End Class

Imports System
Imports System.Data
Imports System.Data.SqlClient ' For .NET Core/.NET 5+, use Microsoft.Data.SqlClient instead

Public Class DataImporter
    Public Sub ImportData(dataTable As DataTable)
        Using connection As SqlConnection = New DatabaseConnector().ConnectToDatabase()
            ' Check if the table exists and create it if it does not.
            Dim tableName As String = "CSVData" ' Use a valid SQL table name format
            Dim checkTable As String = $"IF NOT EXISTS (SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = '{tableName}') BEGIN "
            Dim createTable As String = "CREATE TABLE " & tableName & " ("
            For i As Integer = 0 To dataTable.Columns.Count - 1
                createTable &= $"[{dataTable.Columns(i).ColumnName}] NVARCHAR(MAX)"
                If i < dataTable.Columns.Count - 1 Then
                    createTable &= ", "
                End If
            Next
            createTable &= ") END"
            Dim createTableCommand As New SqlCommand(checkTable & createTable, connection)
            createTableCommand.ExecuteNonQuery()

            ' Now we use SqlBulkCopy to import the data
            Using bulkCopy As New SqlBulkCopy(connection)
                bulkCopy.DestinationTableName = tableName
                Try
                    bulkCopy.WriteToServer(dataTable)
                    Console.WriteLine("Data imported successfully!")
                Catch ex As Exception
                    Console.WriteLine(ex.Message)
                End Try
            End Using
        End Using
    End Sub
End Class

Cela commence par l'ouverture d'une connexion à la base de données SQL Server en utilisant la classe DatabaseConnector, garantissant un chemin pour les transactions de données. Cette méthode vérifie l'existence de la table nommée " CSVData " dans la base de données.

Si la table est introuvable, le programme procède à sa création. Le schéma de la table est construit sur la base du schéma DataTable passé à la méthode, avec toutes les colonnes définies sur NVARCHAR(MAX) pour accueillir toutes les données texte. Il s'agit d'une approche générique qui pourrait nécessiter des ajustements pour mieux correspondre à des types de données spécifiques.

Ensuite, une commande SQL est formulée et exécutée soit pour vérifier l'existence de la table, soit pour la créer. Cela garantit que l'opération de copie en masse suivante dispose d'une table de destination prête pour l'insertion des données. Avec la table prête, la classe SqlBulkCopy est utilisée pour transférer les données du DataTable directement dans la table SQL Server. Cette opération est conçue pour les transferts de données en masse à haute performance, ce qui la rend adaptée au traitement efficace de grands volumes de données.

Étape 4 : Tout assembler

Après avoir travaillé avec diligence sur les étapes précédentes de lecture des données CSV, d'établissement d'une connexion à la base de données et de préparation du transfert des données, nous arrivons à l'étape finale et cruciale : l'intégration de ces composants individuels dans un processus cohérent.

Cette intégration est effectuée dans la méthode Main de votre application C#, où tout se rassemble, permettant l'exécution réelle de l'importation de données du fichier CSV vers la base de données SQL Server.

class Program
{
    static void Main(string[] args)
    {
        string filePath = "path_to_your_csv_file.csv";
        CSVReader reader = new CSVReader();
        DataTable dataTable = reader.ReadCSV(filePath);
        DataImporter importer = new DataImporter();
        importer.ImportData(dataTable);
        Console.WriteLine("Data imported successfully!");
    }
}

class Program
{
    static void Main(string[] args)
    {
        string filePath = "path_to_your_csv_file.csv";
        CSVReader reader = new CSVReader();
        DataTable dataTable = reader.ReadCSV(filePath);
        DataImporter importer = new DataImporter();
        importer.ImportData(dataTable);
        Console.WriteLine("Data imported successfully!");
    }
}

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim filePath As String = "path_to_your_csv_file.csv"
		Dim reader As New CSVReader()
		Dim dataTable As DataTable = reader.ReadCSV(filePath)
		Dim importer As New DataImporter()
		importer.ImportData(dataTable)
		Console.WriteLine("Data imported successfully!")
	End Sub
End Class

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim filePath As String = "path_to_your_csv_file.csv"
		Dim reader As New CSVReader()
		Dim dataTable As DataTable = reader.ReadCSV(filePath)
		Dim importer As New DataImporter()
		importer.ImportData(dataTable)
		Console.WriteLine("Data imported successfully!")
	End Sub
End Class

Remplacez path_to_your_csv_file.csv par le chemin vers votre fichier CSV.

Exécution du projet

Une fois le projet exécuté, vous verrez le résultat suivant. Les messages de succès indiquent que toutes les opérations ont été exécutées avec succès et que les données ont été copiées dans la base de données.

Data imported successfully!

Data imported successfully!

Vous pouvez maintenant ouvrir SQL Server Management Studio (SSMS) et vérifier la table sous la base de données. Vous trouverez les données suivantes dans le tableau.

Comment lire les données à partir d'un fichier CSV et les stocker dans une base de données C# : Figure 1 - Résultat de la base de données

Conclusion

Ce tutoriel vous a guidé tout au long du processus de lecture des données d'un fichier CSV et de leur stockage dans une base de données SQL Server en utilisant C#. En suivant ces étapes et en utilisant la bibliothèque IronXL, vous pouvez gérer efficacement les données CSV dans vos applications C#.

IronXL propose un essai gratuit permettant aux utilisateurs de découvrir ses fonctionnalités avant de procéder à un achat. Cette version d'essai entièrement fonctionnelle permet aux utilisateurs potentiels de tester et d'évaluer le produit en conditions réelles, sans aucune marque d'eau dans la version finale. Après la période d'essai, si vous décidez de continuer à utiliser IronXL pour vos projets, la licence du produit commence à partir de $999.