Importieren von Excel in SQL Server in C#

Einführung

In vielen verschiedenen Geschäftskontexten ist der Import von Daten aus Excel in SQL Server eine typische Notwendigkeit. Bei dieser Tätigkeit geht es darum, Daten aus einer Excel-Datei zu lesen und sie in eine SQL-Server-Datenbank einzugeben. Während der Export-Assistent häufig verwendet wird, bietet IronXL einen programmatischeren und flexibleren Ansatz für die Datenverarbeitung. IronXL ist eine leistungsstarke C#-Bibliothek, die Excel-Daten aus Dateien importieren kann; daher ist es möglich, diesen Vorgang zu beschleunigen. Zu diesem Zweck bietet dieser Beitrag eine ausführliche Anleitung, die sich mit der Konfiguration, Ausführung und Verbesserung des Excel-Imports in SQL Server mit C# befasst.

So importieren Sie Excel in SQL Server in C

1. Einrichten Ihrer Entwicklungsumgebung

2. Bereiten Sie Ihre Excel-Datei vor

3. Verbinden Sie sich mit Ihrer SQL Server-Datenbank

4. Lesen von Daten aus Excel-Dateien mit IronXL

5. Daten exportieren und einen PDF-Bericht mit IronPDF generieren

6. Überprüfen Sie den PDF-Bericht

Was ist IronXL?

IronXL, manchmal auch als IronXL.Excel bezeichnet, ist eine funktionsreiche C#-Bibliothek, die die Arbeit mit Excel-Dateien in .NET-Anwendungen erleichtert. Dieses robuste Tool ist ideal für serverseitige Anwendungen, da es Entwicklern ermöglicht, Excel-Dateien zu lesen, zu erstellen und zu bearbeiten, ohne Microsoft Excel auf dem Computer installieren zu müssen. Excel 2007 und höher(.xlsx) und Excel 97-2003(.xls) formate werden von IronXL unterstützt, was eine vielseitige Verwaltung verschiedener Excel-Dateiversionen ermöglicht. Es ermöglicht umfangreiche Datenmanipulationen, wie z. B. die Bearbeitung von Arbeitsblättern, Zeilen und Spalten sowie das Einfügen, Aktualisieren und Entfernen von Daten.

IronXL unterstützt auch die Formatierung von Zellen und Excel-Formeln und ermöglicht so die programmierte Erstellung komplexer und gut formatierter Tabellenkalkulationen. Mit seiner Leistungsoptimierung und Kompatibilität mit mehreren .NET-Plattformen, einschließlich .NET-Framework, .NET Core und .NET 5/6, garantiert IronXL die effektive Verarbeitung großer Datenmengen. Dank seiner reibungslosen Schnittstelle zu anderen .NET-Frameworks ist es eine flexible Option für Entwickler, die Excel-Datei-Operationen in ihre Anwendungen integrieren möchten, sei es für einfache Datenimport/-export-Aktivitäten oder komplizierte Berichtssysteme.

Wesentliche Merkmale

Lesen und Schreiben von Excel-Dateien

Entwickler können mit IronXL Daten aus und in Excel-Dateien lesen und schreiben. Es ist einfach, neue Excel-Dateien zu erstellen und bereits vorhandene zu bearbeiten.

Keine Installation für Microsoft Excel erforderlich

Im Gegensatz zu einigen anderen Bibliotheken erfordert IronXL keine Installation von Microsoft Excel auf dem Computer, auf dem die Anwendung läuft. Aus diesem Grund ist sie perfekt für serverseitige Anwendungen geeignet.

Unterstützung für verschiedene Excel-Formate

Die Bibliothek bietet Vielseitigkeit bei der Verwaltung verschiedener Excel-Dateitypen durch Unterstützung der .xls(Excel 97-2003) und .xlsx(Excel 2007 und höher) formate.

Erstellen Sie ein neues Visual Studio-Projekt

Ein Visual Studio-Konsolenprojekt ist einfach zu erstellen. Gehen Sie in Visual Studio wie folgt vor, um eine Konsolenanwendung zu erstellen:

1. Öffnen Sie Visual Studio: Stellen Sie sicher, dass Sie Visual Studio auf Ihrem Computer installiert haben, bevor Sie es öffnen.

2. Starten Sie ein neues Projekt: Wählen Sie Datei -> Neu -> Projekt.

   

3. Wählen Sie im linken Bereich des Feldes "Neues Projekt erstellen" Ihre bevorzugte Programmiersprache, z. B. C#.

4. Wählen Sie die "Konsolenanwendung" oder "Konsolenanwendung(.NET Core)` Vorlage aus der Liste der verfügbaren Projektvorlagen.

5. Geben Sie Ihrem Projekt im Bereich Name einen Namen.

   

6. Entscheiden Sie sich für einen Speicherort für das Projekt.

7. Klicken Sie auf Erstellen, um ein Anwendungsprojekt für eine Konsole zu starten.

   

Installation der IronXL-Bibliothek

Die Installation der IronXL-Bibliothek ist wegen des bevorstehenden Updates erforderlich. Um den Vorgang abzuschließen, starten Sie die NuGet-Paketmanager-Konsole und geben den folgenden Befehl ein:

Install-Package IronXL.Excel

Eine weitere Methode ist die Suche nach dem IronXL-Paket mit dem NuGet Package Manager. Damit können wir auswählen, welche der mit IronXL verknüpften NuGet-Pakete wir herunterladen möchten.

Excel-Import in SQL mit IronXL

Lesen von Daten aus Excel mit IronXL

Das Einlesen von Daten aus Excel-Dateien wird mit IronXL vereinfacht. Das folgende Beispiel zeigt Ihnen, wie Sie IronXL verwenden, um Daten aus einer Excel-Datei zu lesen. Bei diesem Ansatz werden die Daten gelesen und in einer Liste von Wörterbüchern gespeichert, von denen jedes einer Zeile in der Excel-Tabelle entspricht.

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

Verbinden mit SQL Server

Verwenden Sie die Klasse SqlConnection aus dem Namespace System.Data.SqlClient, um eine Verbindung zu SQL Server herzustellen. Vergewissern Sie sich, dass Sie die richtige Verbindungszeichenfolge haben, die normalerweise aus dem Datenbanknamen, dem Servernamen und den Authentifizierungsinformationen besteht. Wie man eine Verbindung zu einer SQL Server-Datenbank herstellt und Daten hinzufügt, wird im folgenden Beispiel beschrieben.

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

Kombination von IronXL mit SQL Server

Sobald die Logik für das Lesen von Excel-Dateien und das Einfügen von Daten in eine SQL-Datenbank festgelegt ist, integrieren Sie diese Funktionen, um den Importprozess abzuschließen. Die folgende Anwendung empfängt Informationen aus einer Excel-Datei und fügt sie in eine Microsoft SQL Server-Datenbank ein.

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

Diese Klasse ist dafür zuständig, IronXL zu benutzen, um die Daten aus der gegebenen Excel-Datei zu lesen. Die Funktion "ReadExcelFile" lädt die Excel-Arbeitsmappe, öffnet das erste Arbeitsblatt und sammelt die Daten in einer Schleife durch die Zeilen des Arbeitsblatts. Um die Handhabung der Tabellen zu erleichtern, werden die Informationen in einer Liste von Wörterbüchern gespeichert.

Die Daten werden von dieser Klasse in die vorgesehene Datenbanktabelle eingefügt, die auch die Verbindung zur SQL Server-Datenbank verwaltet. Die Methode "InsertData" verwendet parametrisierte Abfragen, um SQL-Injektionen zu verhindern, und erstellt dynamisch eine SQL INSERT-Abfrage auf der Grundlage der Schlüssel des Wörterbuchs, die für die Spaltennamen stehen.

Mit Hilfe der Klasse "ExcelReader" werden die Daten aus der Excel-Datei in die SQL-Tabelle eingelesen und mit der Klasse "SQLServerConnector" wird jede Zeile in die SQL-Server-Tabelle eingefügt. Die Funktion "Main" verwaltet den gesamten Prozess.

Fehlerbehandlung und Optimierung sind entscheidend für einen robusten und effizienten Importprozess. Durch die Implementierung einer robusten Fehlerbehandlung können potenzielle Probleme wie fehlende Dateien, ungültige Datenformate und SQL-Ausnahmen bewältigt werden. Hier ist ein Beispiel für die Einbeziehung der Fehlerbehandlung.

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

Schlussfolgerung

Eine effektive und zuverlässige Methode zur Verwaltung von Excel-Dateien in .NET-Anwendungen ist der Import von Daten aus Excel in eine MS SQL-Datenbank mit C# und IronXL. IronXL ist mit mehreren Excel-Formaten kompatibel und verfügt über leistungsstarke Funktionen, die das Lesen und Schreiben von Excel-Daten erleichtern, ohne dass Microsoft Excel installiert werden muss. Durch die Integration von System.Data.SqlClient in IronXL können Entwickler auf einfache Weise Daten zwischen SQL-Servern verschieben und dabei parametrisierte Abfragen verwenden, um die Sicherheit zu verbessern und SQL-Injection zu verhindern.

Wenn Sie schließlich IronXL und Iron Software zu Ihrem Toolset für die .NET-Entwicklung hinzufügen, können Sie Excel effizient bearbeiten, PDFs erstellen, OCR durchführen und Barcodes verwenden. Die Kombination der flexiblen Suite von Iron Software mit der Benutzerfreundlichkeit, Interoperabilität und Leistung von IronXL garantiert eine rationalisierte Entwicklung und verbesserte Anwendungsmöglichkeiten. Mit klaren Lizenzoptionen, die auf die Anforderungen des Projekts zugeschnitten sind, können Entwickler das richtige Modell mit Sicherheit auswählen. Durch die Nutzung dieser Vorteile können Entwickler eine Reihe von Problemen effektiv angehen und gleichzeitig die Einhaltung von Vorschriften und Offenheit gewährleisten.