Comment importer Excel vers le serveur SQL en C#

Introduction

Dans de nombreux contextes professionnels, l'importation de données d'Excel vers le serveur SQL est une nécessité courante. Cette activité consiste à lire les données d'un fichier Excel et à les introduire dans une base de données SQL Server. Bien que l'assistant d'exportation soit souvent utilisé, IronXL offre une approche plus programmatique et plus souple du traitement des données. IronXL est une puissante bibliothèque C# qui permet d'importer des données Excel à partir de fichiers ; il est donc possible d'accélérer cette opération. À cette fin, ce billet propose un guide pratique complet qui aborde la configuration, l'exécution et l'amélioration de l'importation d'Excel vers SQL Server à l'aide de C#.

Comment importer Excel vers SQL Server en C

1. Mise en place de l'environnement de développement

2. Préparer votre fichier Excel

3. Connexion à votre base de données SQL Server

4. Lire des données à partir de fichiers Excel à l'aide d'IronXL

5. Exporter des données et générer un rapport PDF à l'aide d'IronPDF

6. Consulter le rapport PDF

Qu'est-ce qu'IronXL ?

IronXL, parfois appelé IronXL.Excel, est une bibliothèque C# riche en fonctionnalités, conçue pour faciliter le travail avec les fichiers Excel dans les applications .NET. Cet outil robuste est idéal pour les applications côté serveur, car il permet aux développeurs de lire, de créer et de modifier des fichiers Excel sans devoir installer Microsoft Excel sur l'ordinateur. Excel 2007 et versions ultérieures(.xlsx) et Excel 97-2003(.xls) sont pris en charge par IronXL, ce qui offre une grande souplesse dans la gestion des différentes versions de fichiers Excel. Il permet d'importantes manipulations de données, telles que la manipulation de feuilles de calcul, de lignes et de colonnes, ainsi que l'insertion, la mise à jour et la suppression de données.

IronXL prend également en charge le formatage des cellules et les formules Excel, ce qui permet la génération programmée de feuilles de calcul complexes et bien formatées. Grâce à l'optimisation des performances et à la compatibilité avec plusieurs plateformes .NET, notamment .NET Framework, .NET Core et .NET 5/6, IronXL garantit un traitement efficace d'énormes ensembles de données. Il s'agit d'une option flexible pour les développeurs qui souhaitent intégrer des opérations sur les fichiers Excel dans leurs applications, qu'il s'agisse d'activités simples d'importation/exportation de données ou de systèmes complexes de création de rapports, grâce à son interface fluide avec d'autres frameworks .NET.

Caractéristiques principales

Lire et écrire des fichiers Excel

Les développeurs peuvent lire et écrire des données dans des fichiers Excel à l'aide d'IronXL. Il est facile de créer de nouveaux fichiers Excel et de modifier ceux qui existent déjà.

Aucune installation n'est requise pour Microsoft Excel

IronXL ne nécessite pas l'installation de Microsoft Excel sur l'ordinateur qui héberge l'application, contrairement à certaines autres bibliothèques. C'est pour cette raison qu'il est parfait pour les applications côté serveur.

Prise en charge de divers formats Excel

La bibliothèque offre une grande souplesse dans la gestion des différents types de fichiers Excel en prenant en charge les fichiers .xls(Excel 97-2003) et .xlsx(Excel 2007 et versions ultérieures) formats.

Créer un nouveau projet Visual Studio

Un projet de console Visual Studio est simple à créer. Dans Visual Studio, procédez comme suit pour créer une application console :

1. Ouvrez Visual Studio : Assurez-vous d'avoir installé Visual Studio sur votre ordinateur avant de l'ouvrir.

2. Démarrer un nouveau projet : Choisissez Fichier -> Nouveau -> Projet.

   

3. Dans le panneau de gauche de la boîte "Créer un nouveau projet", choisissez votre langage de programmation préféré - par exemple, C#.

4. Sélectionnez l'option Console App ou Console App(.NET Core)` dans la liste des modèles de projet disponibles.

5. Dans la zone Nom, donnez un nom à votre projet.

   

6. Décidez de l'endroit où vous souhaitez enregistrer le projet.

7. Cliquez sur Créer pour lancer un projet d'application pour une console.

   

Installation de la bibliothèque IronXL

L'installation de la bibliothèque IronXL est nécessaire en raison de la prochaine mise à jour. Enfin, pour terminer la procédure, lancez la console NuGet Package Manager et tapez la commande suivante :

Install-Package IronXL.Excel

Une autre méthode consiste à utiliser le gestionnaire de paquets NuGet pour rechercher le paquet IronXL. Cela nous permet de sélectionner, parmi les paquets NuGet liés à IronXL, ceux qui doivent être téléchargés.

Importer Excel vers SQL avec IronXL

Lecture de données à partir d'Excel à l'aide d'IronXL

Le processus de lecture de données à partir de fichiers Excel est facilité par IronXL. L'exemple qui suit vous montre comment utiliser IronXL pour lire les données d'un fichier Excel. Dans cette approche, les données sont lues et sauvegardées dans une liste de dictionnaires, chacun d'entre eux correspondant à une ligne de la feuille Excel.

using IronXL;
using System;
using System.Collections.Generic;

public class ExcelReader
{
    public static List<Dictionary<string, object>> ReadExcelFile(string filePath)
    {
        var data = new List<Dictionary<string, object>>();
        WorkBook workbook = WorkBook.Load(filePath);
        WorkSheet sheet = workbook.WorkSheets[0];

        var headers = new List<string>();
        foreach (var header in sheet.Rows[0].Columns)
        {
            headers.Add(header.ToString());
        }

        for (int i = 1; i < sheet.Rows.Count; i++)
        {
            var rowData = new Dictionary<string, object>();
            for (int j = 0; j < headers.Count; j++)
            {
                rowData[headers[j]] = sheet.Rows[i][j].Value;
            }
            data.Add(rowData);
        }

        return data;
    }
}

using IronXL;
using System;
using System.Collections.Generic;

public class ExcelReader
{
    public static List<Dictionary<string, object>> ReadExcelFile(string filePath)
    {
        var data = new List<Dictionary<string, object>>();
        WorkBook workbook = WorkBook.Load(filePath);
        WorkSheet sheet = workbook.WorkSheets[0];

        var headers = new List<string>();
        foreach (var header in sheet.Rows[0].Columns)
        {
            headers.Add(header.ToString());
        }

        for (int i = 1; i < sheet.Rows.Count; i++)
        {
            var rowData = new Dictionary<string, object>();
            for (int j = 0; j < headers.Count; j++)
            {
                rowData[headers[j]] = sheet.Rows[i][j].Value;
            }
            data.Add(rowData);
        }

        return data;
    }
}

Imports IronXL
Imports System
Imports System.Collections.Generic

Public Class ExcelReader
	Public Shared Function ReadExcelFile(ByVal filePath As String) As List(Of Dictionary(Of String, Object))
		Dim data = New List(Of Dictionary(Of String, Object))()
		Dim workbook As WorkBook = WorkBook.Load(filePath)
		Dim sheet As WorkSheet = workbook.WorkSheets(0)

		Dim headers = New List(Of String)()
		For Each header In sheet.Rows(0).Columns
			headers.Add(header.ToString())
		Next header

		For i As Integer = 1 To sheet.Rows.Count - 1
			Dim rowData = New Dictionary(Of String, Object)()
			For j As Integer = 0 To headers.Count - 1
				rowData(headers(j)) = sheet.Rows(i)(j).Value
			Next j
			data.Add(rowData)
		Next i

		Return data
	End Function
End Class

Connexion au serveur SQL

Utilisez la classe SqlConnection de l'espace de noms System.Data.SqlClient pour établir une connexion avec le serveur SQL. Assurez-vous d'avoir la bonne chaîne de connexion, qui se compose normalement du nom de la base de données, du nom du serveur et des informations d'authentification. L'exemple suivant explique comment se connecter à une base de données SQL Server et ajouter des données.

using System;
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Linq;

public class SqlServerConnector
{
    private string connectionString;

    public SqlServerConnector(string connectionString)
    {
        this.connectionString = connectionString;
    }

    public void InsertData(Dictionary<string, object> data, string tableName)
    {
        using (SqlConnection connection = new SqlConnection(connectionString))
        {
            connection.Open();
            var columns = string.Join(",", data.Keys);
            var parameters = string.Join(",", data.Keys.Select(key => "@" + key));
            string query = $"INSERT INTO {tableName} ({columns}) VALUES ({parameters})";

            using (SqlCommand command = new SqlCommand(query, connection))
            {
                foreach (var kvp in data)
                {
                    command.Parameters.AddWithValue("@" + kvp.Key, kvp.Value ?? DBNull.Value);
                }
                command.ExecuteNonQuery();
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Linq;

public class SqlServerConnector
{
    private string connectionString;

    public SqlServerConnector(string connectionString)
    {
        this.connectionString = connectionString;
    }

    public void InsertData(Dictionary<string, object> data, string tableName)
    {
        using (SqlConnection connection = new SqlConnection(connectionString))
        {
            connection.Open();
            var columns = string.Join(",", data.Keys);
            var parameters = string.Join(",", data.Keys.Select(key => "@" + key));
            string query = $"INSERT INTO {tableName} ({columns}) VALUES ({parameters})";

            using (SqlCommand command = new SqlCommand(query, connection))
            {
                foreach (var kvp in data)
                {
                    command.Parameters.AddWithValue("@" + kvp.Key, kvp.Value ?? DBNull.Value);
                }
                command.ExecuteNonQuery();
            }
        }
    }
}

Imports System
Imports System.Collections.Generic
Imports System.Data.SqlClient
Imports System.Linq

Public Class SqlServerConnector
	Private connectionString As String

	Public Sub New(ByVal connectionString As String)
		Me.connectionString = connectionString
	End Sub

	Public Sub InsertData(ByVal data As Dictionary(Of String, Object), ByVal tableName As String)
		Using connection As New SqlConnection(connectionString)
			connection.Open()
			Dim columns = String.Join(",", data.Keys)
			Dim parameters = String.Join(",", data.Keys.Select(Function(key) "@" & key))
			Dim query As String = $"INSERT INTO {tableName} ({columns}) VALUES ({parameters})"

			Using command As New SqlCommand(query, connection)
				For Each kvp In data
					command.Parameters.AddWithValue("@" & kvp.Key, If(kvp.Value, DBNull.Value))
				Next kvp
				command.ExecuteNonQuery()
			End Using
		End Using
	End Sub
End Class

Combinaison d'IronXL et de SQL Server

Une fois que la logique de lecture des fichiers Excel et d'insertion des données dans une base de données SQL a été établie, intégrez ces fonctionnalités pour terminer le processus d'importation. L'application suivante reçoit des informations d'un fichier Excel et les ajoute à une base de données Microsoft SQL Server.

using System;
using System.Collections.Generic;

class Program
{
    static void Main(string[] args)
    {
        string excelFilePath = "path_to_your_excel_file.xlsx";
        string connectionString = "your_sql_server_connection_string";
        string tableName = "your_table_name";

        // Read data from Excel
        List<Dictionary<string, object>> excelData = ExcelReader.ReadExcelFile(excelFilePath);

        // Insert data into SQL Server
        SqlServerConnector sqlConnector = new SqlServerConnector(connectionString);
        foreach (var row in excelData)
        {
            sqlConnector.InsertData(row, tableName);
        }

        Console.WriteLine("Data import completed successfully.");
    }
}

using System;
using System.Collections.Generic;

class Program
{
    static void Main(string[] args)
    {
        string excelFilePath = "path_to_your_excel_file.xlsx";
        string connectionString = "your_sql_server_connection_string";
        string tableName = "your_table_name";

        // Read data from Excel
        List<Dictionary<string, object>> excelData = ExcelReader.ReadExcelFile(excelFilePath);

        // Insert data into SQL Server
        SqlServerConnector sqlConnector = new SqlServerConnector(connectionString);
        foreach (var row in excelData)
        {
            sqlConnector.InsertData(row, tableName);
        }

        Console.WriteLine("Data import completed successfully.");
    }
}

Imports System
Imports System.Collections.Generic

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim excelFilePath As String = "path_to_your_excel_file.xlsx"
		Dim connectionString As String = "your_sql_server_connection_string"
		Dim tableName As String = "your_table_name"

		' Read data from Excel
		Dim excelData As List(Of Dictionary(Of String, Object)) = ExcelReader.ReadExcelFile(excelFilePath)

		' Insert data into SQL Server
		Dim sqlConnector As New SqlServerConnector(connectionString)
		For Each row In excelData
			sqlConnector.InsertData(row, tableName)
		Next row

		Console.WriteLine("Data import completed successfully.")
	End Sub
End Class

Cette classe est chargée d'utiliser IronXL pour lire les données du fichier Excel donné. La fonction ReadExcelFile charge le classeur Excel, ouvre la première feuille de calcul et recueille les données en parcourant en boucle les lignes de la feuille de calcul des données. Pour faciliter la manipulation des tableaux, les informations sont conservées dans une liste de dictionnaires.

Les données sont insérées dans la table de base de données désignée par cette classe, qui gère également la connexion à la base de données SQL Server. La méthode InsertData utilise des requêtes paramétrées pour prévenir les injections SQL et construit une requête SQL INSERT dynamiquement basée sur les clés du dictionnaire, qui remplacent les noms de colonnes.

En utilisant la classe ExcelReader pour lire les données dans la table SQL à partir du fichier Excel et la classe SqlServerConnector pour insérer chaque ligne dans la table du serveur SQL, la fonction Main gère l'ensemble du processus.

La gestion et l'optimisation des erreurs sont essentielles pour garantir un processus d'importation robuste et efficace. La mise en œuvre d'un traitement robuste des erreurs permet de gérer les problèmes potentiels tels que les fichiers manquants, les formats de données non valides et les exceptions SQL. Voici un exemple d'intégration de la gestion des erreurs.

try
{
    // Insert the importing logic here
}
catch(Exception ex)
{
    Console.WriteLine("An error occurred: " + ex.Message);
}

try
{
    // Insert the importing logic here
}
catch(Exception ex)
{
    Console.WriteLine("An error occurred: " + ex.Message);
}

Try
	' Insert the importing logic here
Catch ex As Exception
	Console.WriteLine("An error occurred: " & ex.Message)
End Try

Conclusion

Enfin, une méthode efficace et fiable pour gérer les fichiers Excel dans les applications .NET consiste à importer les données d'Excel dans une base de données MS SQL à l'aide de C# et d'IronXL for .NET. IronXL est compatible avec de nombreux formats Excel et possède de solides capacités qui facilitent la lecture et l'écriture de données Excel sans qu'il soit nécessaire d'installer Microsoft Excel. Grâce à l'intégration de System.Data.SqlClient à IronXL, les développeurs peuvent facilement déplacer des données entre les serveurs SQL en utilisant des requêtes paramétrées pour améliorer la sécurité et prévenir les injections SQL.

Enfin, l'ajout d'IronXL et d'Iron Software à votre ensemble d'outils de développement .NET vous permet de manipuler efficacement Excel, de créer des PDF, de faire de l'OCR et d'utiliser des codes-barres. La combinaison de la suite flexible d'Iron Software avec la simplicité d'utilisation, l'interopérabilité et la performance d'IronXL garantit un développement rationalisé et des capacités d'application améliorées. Grâce à des options de licence claires et adaptées aux exigences du projet, les développeurs peuvent choisir le bon modèle en toute confiance. En tirant parti de ces avantages, les développeurs peuvent s'attaquer efficacement à toute une série de difficultés tout en maintenant la conformité et l'ouverture.