In vielen verschiedenen Geschäftskontexten ist das Importieren von Daten von Excel in den SQL Server eine typische Notwendigkeit. Das Lesen von Daten aus einer Excel-Datei und das Eingeben in eine SQL Server-Datenbank sind die Aufgaben, die mit dieser Tätigkeit verbunden sind. Während der Export-Assistent oft verwendet wird, bietet IronXL einen programmatischeren und flexibleren Ansatz zur 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 wird dieser Beitrag eine ausführliche Anleitung bieten, die die Konfiguration, Ausführung und Verbesserung des Importierens von Excel in den SQL Server mit C# behandelt.

How to Import Excel to SQL Server in C#

1. Richten Sie Ihre Entwicklungsumgebung ein
2. Bereiten Sie Ihre Excel-Datei vor
3. Verbinden Sie sich mit Ihrer SQL Server-Datenbank
4. Lesen Sie Daten aus Excel-Dateien mit IronXL
5. Exportieren Sie Daten und erstellen Sie einen PDF-Bericht mit IronPDF
6. Überprüfen Sie den PDF-Bericht

Was ist IronXL?

IronXL, manchmal auch IronXL.Excel genannt, ist eine funktionsreiche C#-Bibliothek, die entwickelt wurde, um die Arbeit mit Excel-Dateien in .NET-Anwendungen zu erleichtern. 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. Die Formate Excel 2007 und später (.xlsx) sowie Excel 97-2003 (.xls) werden von IronXL unterstützt, was Vielseitigkeit im Umgang mit verschiedenen Excel-Dateiversionen bietet. Es ermöglicht erhebliche Datenmanipulationen, wie z. B. das Bearbeiten von Arbeitsblättern, Zeilen und Spalten zusätzlich zum Einfügen, Aktualisieren und Entfernen von Daten.

IronXL unterstützt auch die Zellformatierung und Excel-Formeln, was die programmierte Erzeugung von komplexen und gut formatierten Tabellenkalkulationen ermöglicht. Mit seiner Leistungsoptimierung und Kompatibilität mit mehreren .NET-Plattformen, darunter .NET Framework, .NET Core und .NET 5/6, garantiert IronXL eine effektive Handhabung großer Datensätze. Es ist eine flexible Option für Entwickler, die Excel-Dateioperationen in ihre Anwendungen integrieren möchten, sei es für einfache Datenimport/-exportaktivitäten oder komplexe Berichtssysteme, dank seiner nahtlosen Schnittstelle mit anderen .NET-Frameworks.

Wichtige Merkmale

Excel-Dateien lesen und schreiben

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

Keine Installation von Microsoft Excel erforderlich

IronXL erfordert keine Installation von Microsoft Excel auf dem Computer, der die Anwendung hostet, im Gegensatz zu einigen anderen Bibliotheken. Es ist ideal für serverseitige Anwendungen aus diesem Grund.

Unterstützung für verschiedene Excel-Formate

Die Bibliothek bietet Vielseitigkeit im Umgang mit verschiedenen Excel-Dateitypen, indem sie die Formate .xls (Excel 97-2003) und .xlsx (Excel 2007 und später) unterstützt.

Ein neues Visual Studio-Projekt erstellen

Ein Visual Studio-Konsolenprojekt ist einfach zu erstellen. Führen Sie in Visual Studio die folgenden Schritte aus, um eine Konsolenanwendung zu erstellen:

1. Visual Studio öffnen: Stellen Sie sicher, dass Visual Studio auf Ihrem Computer installiert ist, bevor Sie es öffnen.
2. Starten Sie ein neues Projekt: Wählen Sie File -> New -> Project.

3. Wählen Sie aus dem linken Bereich des Create a new project-Fensters Ihre bevorzugte Programmiersprache aus – zum Beispiel C#.
4. Wählen Sie die Console App- oder Console App (.NET Core)-Vorlage aus der Liste der verfügbaren Projektvorlagen aus.
5. Gib im Bereich Name deinem Projekt einen Namen.

6. Entscheiden Sie sich für einen Speicherort des Projekts.
7. Klicken Sie auf Erstellen, um ein Anwendungsprojekt für eine Konsole zu starten.

Installation der IronXL-Bibliothek

Die Installation der IronXL-Bibliothek ist erforderlich, bis zur nächsten Aktualisierung. Zuletzt, um den Vorgang abzuschließen, öffnen Sie die NuGet-Paket-Manager-Konsole und geben Sie folgenden Befehl ein:

Install-Package IronXL.Excel

Eine weitere Methode ist die Verwendung des NuGet-Paket-Managers, um nach dem IronXL Paket zu suchen. Dadurch können wir wählen, welches der mit IronXL verbundenen NuGet-Pakete heruntergeladen werden soll.

Importieren von Excel nach SQL mit IronXL

Daten aus Excel mit IronXL lesen

Der Prozess des Lesens von Daten aus Excel-Dateien wird mit IronXL erleichtert. Das folgende Beispiel zeigt Ihnen, wie Sie mit IronXL Daten aus einer Excel-Datei lesen. Mit diesem Ansatz werden die Daten gelesen und in einer Liste von Wörterbüchern gespeichert, von denen jedes einer Zeile im Excel-Blatt entspricht.

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

public class ExcelReader
{
    public static List<Dictionary<string, object>> ReadExcelFile(string filePath)
    {
        // Initialize a list to store data from Excel
        var data = new List<Dictionary<string, object>>();

        // Load the workbook from the file path provided
        WorkBook workbook = WorkBook.Load(filePath);

        // Access the first worksheet in the workbook
        WorkSheet sheet = workbook.WorkSheets[0];

        // Retrieve column headers from the first row
        var headers = new List<string>();
        foreach (var header in sheet.Rows[0].Columns)
        {
            headers.Add(header.ToString());
        }

        // Loop through each row starting from the second row
        for (int i = 1; i < sheet.Rows.Count; i++)
        {
            // Create a dictionary to store the row data associated with column headers
            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)
    {
        // Initialize a list to store data from Excel
        var data = new List<Dictionary<string, object>>();

        // Load the workbook from the file path provided
        WorkBook workbook = WorkBook.Load(filePath);

        // Access the first worksheet in the workbook
        WorkSheet sheet = workbook.WorkSheets[0];

        // Retrieve column headers from the first row
        var headers = new List<string>();
        foreach (var header in sheet.Rows[0].Columns)
        {
            headers.Add(header.ToString());
        }

        // Loop through each row starting from the second row
        for (int i = 1; i < sheet.Rows.Count; i++)
        {
            // Create a dictionary to store the row data associated with column headers
            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))
		' Initialize a list to store data from Excel
		Dim data = New List(Of Dictionary(Of String, Object))()

		' Load the workbook from the file path provided
		Dim workbook As WorkBook = WorkBook.Load(filePath)

		' Access the first worksheet in the workbook
		Dim sheet As WorkSheet = workbook.WorkSheets(0)

		' Retrieve column headers from the first row
		Dim headers = New List(Of String)()
		For Each header In sheet.Rows(0).Columns
			headers.Add(header.ToString())
		Next header

		' Loop through each row starting from the second row
		For i As Integer = 1 To sheet.Rows.Count - 1
			' Create a dictionary to store the row data associated with column headers
			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

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))
		' Initialize a list to store data from Excel
		Dim data = New List(Of Dictionary(Of String, Object))()

		' Load the workbook from the file path provided
		Dim workbook As WorkBook = WorkBook.Load(filePath)

		' Access the first worksheet in the workbook
		Dim sheet As WorkSheet = workbook.WorkSheets(0)

		' Retrieve column headers from the first row
		Dim headers = New List(Of String)()
		For Each header In sheet.Rows(0).Columns
			headers.Add(header.ToString())
		Next header

		' Loop through each row starting from the second row
		For i As Integer = 1 To sheet.Rows.Count - 1
			' Create a dictionary to store the row data associated with column headers
			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

Verbindung zu SQL Server

Verwenden Sie die SqlConnection-Klasse aus dem System.Data.SqlClient-Namespace, um eine Verbindung zu SQL Server herzustellen. Stellen Sie sicher, dass Sie den richtigen Verbindungsstring haben, der normalerweise aus dem Datenbanknamen, dem Servernamen und den Authentifikationsinformationen besteht. Wie man eine Verbindung zu einer SQL Server-Datenbank herstellt und Daten hinzufügt, wird im folgenden Beispiel behandelt.

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

public class SqlServerConnector
{
    private string connectionString;

    // Constructor accepts a connection string
    public SqlServerConnector(string connectionString)
    {
        this.connectionString = connectionString;
    }

    // Inserts data into the specified table
    public void InsertData(Dictionary<string, object> data, string tableName)
    {
        using (SqlConnection connection = new SqlConnection(connectionString))
        {
            connection.Open();

            // Construct an SQL INSERT command with parameterized values to prevent SQL injection
            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))
            {
                // Add parameters to the command
                foreach (var kvp in data)
                {
                    command.Parameters.AddWithValue("@" + kvp.Key, kvp.Value ?? DBNull.Value);
                }

                // Execute the command
                command.ExecuteNonQuery();
            }
        }
    }
}

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

public class SqlServerConnector
{
    private string connectionString;

    // Constructor accepts a connection string
    public SqlServerConnector(string connectionString)
    {
        this.connectionString = connectionString;
    }

    // Inserts data into the specified table
    public void InsertData(Dictionary<string, object> data, string tableName)
    {
        using (SqlConnection connection = new SqlConnection(connectionString))
        {
            connection.Open();

            // Construct an SQL INSERT command with parameterized values to prevent SQL injection
            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))
            {
                // Add parameters to the command
                foreach (var kvp in data)
                {
                    command.Parameters.AddWithValue("@" + kvp.Key, kvp.Value ?? DBNull.Value);
                }

                // Execute the command
                command.ExecuteNonQuery();
            }
        }
    }
}

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

Public Class SqlServerConnector
	Private connectionString As String

	' Constructor accepts a connection string
	Public Sub New(ByVal connectionString As String)
		Me.connectionString = connectionString
	End Sub

	' Inserts data into the specified table
	Public Sub InsertData(ByVal data As Dictionary(Of String, Object), ByVal tableName As String)
		Using connection As New SqlConnection(connectionString)
			connection.Open()

			' Construct an SQL INSERT command with parameterized values to prevent SQL injection
			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)
				' Add parameters to the command
				For Each kvp In data
					command.Parameters.AddWithValue("@" & kvp.Key, If(kvp.Value, DBNull.Value))
				Next kvp

				' Execute the command
				command.ExecuteNonQuery()
			End Using
		End Using
	End Sub
End Class

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

Public Class SqlServerConnector
	Private connectionString As String

	' Constructor accepts a connection string
	Public Sub New(ByVal connectionString As String)
		Me.connectionString = connectionString
	End Sub

	' Inserts data into the specified table
	Public Sub InsertData(ByVal data As Dictionary(Of String, Object), ByVal tableName As String)
		Using connection As New SqlConnection(connectionString)
			connection.Open()

			' Construct an SQL INSERT command with parameterized values to prevent SQL injection
			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)
				' Add parameters to the command
				For Each kvp In data
					command.Parameters.AddWithValue("@" & kvp.Key, If(kvp.Value, DBNull.Value))
				Next kvp

				' Execute the command
				command.ExecuteNonQuery()
			End Using
		End Using
	End Sub
End Class

Kombinieren von IronXL mit SQL Server

Sobald die Logik zum Lesen von Excel-Dateien und 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)
    {
        // Define the path to the Excel file, SQL connection string, and target table name
        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);

        // Create an instance of the SQL connector and insert data
        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)
    {
        // Define the path to the Excel file, SQL connection string, and target table name
        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);

        // Create an instance of the SQL connector and insert data
        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)
		' Define the path to the Excel file, SQL connection string, and target table name
		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)

		' Create an instance of the SQL connector and insert data
		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

Imports System
Imports System.Collections.Generic

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Define the path to the Excel file, SQL connection string, and target table name
		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)

		' Create an instance of the SQL connector and insert data
		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 verantwortlich dafür, die Daten aus der angegebenen Excel-Datei mit IronXL zu lesen. Die ReadExcelFile-Funktion lädt die Excel-Arbeitsmappe, öffnet das erste Arbeitsblatt und sammelt Daten, indem sie die Zeilen des Datenarbeitsblatts durchläuft. 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 InsertData-Methode verwendet parametrisierte Abfragen, um SQL Injektionen zu verhindern, und erstellt dynamisch eine SQL INSERT-Abfrage basierend auf den Schlüsseln des Wörterbuchs, die die Spaltennamen darstellen.

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

Fehlerbehandlung und Optimierung sind entscheidend, um einen robusten und effizienten Importprozess sicherzustellen. Die Implementierung einer robusten Fehlerbehandlung kann potenzielle Probleme wie fehlende Dateien, ungültige Datenformate und SQL-Ausnahmen verwalten. Hier ist ein Beispiel für die Einbindung 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

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

Abschluss

Schließlich ist ein effektiver und zuverlässiger Ansatz zur Verwaltung von Excel-Dateien innerhalb von .NET-Anwendungen, Daten aus Excel in eine MS SQL-Datenbank mit C# und IronXL zu importieren. IronXL ist mit mehreren Excel-Formaten kompatibel und bietet starke Funktionen, die das Lesen und Schreiben von Excel-Daten erleichtern, ohne Microsoft Excel installieren zu müssen. Durch die Integration von System.Data.SqlClient mit IronXL können Entwickler einfach Daten zwischen SQL-Servern verschieben, indem sie parametrisierte Abfragen verwenden, um die Sicherheit zu verbessern und SQL-Injektionen zu verhindern.

Abschließend ermöglicht die Einbindung von IronXL und Iron Software in Ihr Werkzeugset für die .NET-Entwicklung die effiziente Bearbeitung von Excel, das Erstellen von PDFs, das Durchführen von OCR und die Nutzung von Barcodes. Die Kombination der flexiblen Suite von Iron Software mit der Benutzerfreundlichkeit, Interoperabilität und Leistung von IronXL garantiert eine vereinfachte Entwicklung und verbesserte Anwendungsfunktionen. Mit klaren Lizenzoptionen, die auf die Anforderungen des Projekts zugeschnitten sind, können Entwickler das passende Modell mit Zuversicht auswählen. Indem sie diese Vorteile nutzen, können Entwickler effektiv eine Vielzahl von Herausforderungen bewältigen und gleichzeitig Compliance und Transparenz wahren.