Zum Fußzeileninhalt springen
IRONXL VERWENDEN

Wie man Excel nach SQL Server in C# importiert

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.

Wie man Excel nach SQL Server in C# importiert: Abbildung 1 - IronXL: Die C# Excel-Bibliothek

Wie man Excel nach SQL Server in C# importiert

  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. Ö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.

Wie man Excel nach SQL Server in C# importiert: Abbildung 2 - Klicken Sie auf Neu

  1. Wählen Sie aus dem linken Bereich des Erstellen eines neuen Projekts-Fensters Ihre bevorzugte Programmiersprache aus, zum Beispiel C#.
  2. Wählen Sie die Vorlage Konsolenanwendung oder Konsolenanwendung (.NET Core) aus der Liste der verfügbaren Projektvorlagen.
  3. Geben Sie im Bereich Name Ihrem Projekt einen Namen.

Wie man Excel nach SQL Server in C# importiert: Abbildung 3 - Einen Namen und einen Speicherort angeben

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

Wie man Excel nach SQL Server in C# importiert: Abbildung 4 - Schließlich klicken Sie auf Erstellen, um eine Anwendung 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

Wie man Excel nach SQL Server in C# importiert: Abbildung 5 - Geben Sie den obigen Befehl in die NuGet-Paket-Manager-Konsole ein, um IronXL zu installieren

Eine weitere Möglichkeit ist, die NuGet-Paket-Manager zu verwenden, um nach dem Paket IronXL zu suchen. Dadurch können wir wählen, welches der mit IronXL verbundenen NuGet-Pakete heruntergeladen werden soll.

Wie man Excel nach SQL Server in C# importiert: Abbildung 6 - Alternativ suchen Sie mit dem NuGet-Paket-Manager nach IronXL und installieren es

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
$vbLabelText   $csharpLabel

Verbindung zu SQL Server

Verwenden Sie die Klasse SqlConnection aus dem Namespace System.Data.SqlClient, 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
$vbLabelText   $csharpLabel

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
$vbLabelText   $csharpLabel

Diese Klasse ist dafür verantwortlich, mit IronXL die Daten aus der angegebenen Excel-Datei zu lesen. Die Funktion ReadExcelFile lädt das Excel-Arbeitsbuch, öffnet das erste Arbeitsblatt und sammelt Daten, indem sie durch die Zeilen des Datenarbeitsblatts läuft. Um die Handhabung der Tabellen zu erleichtern, werden die Informationen in einer Liste von Wörterbüchern gespeichert.

Wie man Excel nach SQL Server in C# importiert: Abbildung 7 - Beispielhafte Eingabe-Excel-Datei

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 eine SQL INSERT-Abfrage dynamisch basierend auf den Schlüsseln des Wörterbuchs, die die Spaltennamen darstellen.

Die Funktion Main verwaltet den gesamten Prozess, indem sie die Klasse ExcelReader verwendet, um die Daten in die SQL-Tabelle aus der Excel-Datei zu lesen und die Klasse SqlServerConnector, um jede Zeile in die SQL Server-Tabelle einzufügen.

Wie man Excel nach SQL Server in C# importiert: Abbildung 8 - Ausgabe, die erfolgreiche Abfrage auf dem SQL Server zeigt

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
$vbLabelText   $csharpLabel

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 Daten problemlos zwischen SQL Servern verschieben, indem sie parametrische 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.

Häufig gestellte Fragen

Was ist der beste Weg, um Excel-Daten mit C# in SQL Server zu importieren?

Mit der IronXL-Bibliothek können Sie Excel-Daten effizient in SQL Server importieren, indem Sie die Excel-Datei lesen und die Daten in die Datenbank einfügen, ohne Microsoft Excel installiert zu haben.

Wie kann ich Excel-Dateien in C# lesen, ohne Microsoft Excel zu verwenden?

IronXL ermöglicht es Ihnen, Excel-Dateien in C# zu lesen, ohne dass Microsoft Excel erforderlich ist. Sie können die Excel-Arbeitsmappe laden, auf Arbeitsblätter zugreifen und Daten mit einfachen Methoden extrahieren.

Welche Schritte sind erforderlich, um eine Excel-Datei in einer C#-Anwendung mit SQL Server zu verbinden?

Verwenden Sie zunächst IronXL, um die Excel-Datei zu lesen. Stellen Sie dann eine Verbindung zu SQL Server mit der SqlConnection-Klasse her und verwenden Sie SqlCommand, um Daten in die SQL-Datenbank einzufügen.

Warum sollte ich IronXL für Excel-Operationen in .NET-Anwendungen verwenden?

IronXL bietet effiziente Datenverarbeitung, Kompatibilität mit mehreren .NET-Plattformen und erfordert keine Excel-Installation, was es ideal für serverseitige Anwendungen und das Handling großer Datensätze macht.

Wie gehe ich mit großen Excel-Datensätzen in C# um?

IronXL bietet robuste Unterstützung für große Datensätze und ermöglicht es Ihnen, Daten in Excel-Dateien effizient zu lesen und zu manipulieren und in Anwendungen zu integrieren, ohne dass es zu Leistungsproblemen kommt.

Welche Fehlerbehandlungsstrategien sollten beim Import von Excel nach SQL Server angewendet werden?

Implementieren Sie Try-Catch-Blöcke, um potenzielle Fehler wie Datei nicht gefunden, ungültige Datenformate oder SQL-Ausnahmen zu behandeln und einen reibungslosen Importprozess zu gewährleisten.

Kann ich den Import von Excel-Daten in SQL Server in einer C#-Anwendung automatisieren?

Ja, mit IronXL können Sie den Importprozess automatisieren, indem Sie eine C#-Anwendung schreiben, die Excel-Dateien liest und die Daten mit minimalem manuellen Eingriff in SQL Server einfügt.

Wie verhindern Parameterabfragen in C# SQL-Injection?

Parameterabfragen in C# ermöglichen es Ihnen, Daten sicher in SQL Server einzufügen, indem Platzhalter für Parameter in SQL-Anweisungen verwendet werden, was hilft, SQL-Injection-Angriffe zu verhindern.

Wie kann ich die Leistung beim Importieren von Excel-Daten in SQL Server optimieren?

Optimieren Sie die Leistung, indem Sie Batch-Einfügungen verwenden, große Datensätze effizient mit IronXL handhaben und sicherstellen, dass Ihre SQL Server-Verbindung und Befehle ordnungsgemäß konfiguriert sind.

Welche Lizenzierungsoptionen bietet IronXL für die Verwendung in einem Projekt?

IronXL bietet flexible Lizenzierungsoptionen, die auf die Projektanforderungen zugeschnitten sind, sodass Entwickler den besten Plan wählen können, der zu den Anforderungen ihrer Anwendungen und ihrem Budget passt.

Jordi Bardia
Software Ingenieur
Jordi ist am besten in Python, C# und C++ versiert. Wenn er nicht bei Iron Software seine Fähigkeiten einsetzt, programmiert er Spiele. Mit Verantwortung für Produkttests, Produktentwicklung und -forschung trägt Jordi mit immensem Wert zur kontinuierlichen Produktverbesserung bei. Die abwechslungsreiche Erfahrung hält ihn gefordert und engagiert, ...
Weiterlesen