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.

How to Import Excel to SQL Server in C
- Richten Sie Ihre Entwicklungsumgebung ein
- Bereiten Sie Ihre Excel-Datei vor
- Verbinden Sie sich mit Ihrer SQL Server-Datenbank
- Lesen Sie Daten aus Excel-Dateien mit IronXL
- Exportieren Sie Daten und erstellen Sie einen PDF-Bericht mit IronPDF
- Ü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:
- Visual Studio öffnen: Stellen Sie sicher, dass Visual Studio auf Ihrem Computer installiert ist, bevor Sie es öffnen.
- Neues Projekt starten: Wählen Sie
File->New->Project.

- Wählen Sie im linken Bereich des Feldes
Create a new projectIhre bevorzugte Programmiersprache aus – zum Beispiel C#. - Wählen Sie die Vorlage
Console AppoderConsole App (.NET Core)aus der Liste der verfügbaren Projektvorlagen aus. - Gib im Bereich Name deinem Projekt einen Namen.

- Entscheiden Sie sich für einen Speicherort des Projekts.
- 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 Suche nach dem Paket IronXL mithilfe des NuGet Paketmanagers. 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
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
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
Diese Klasse ist dafür zuständig, mit IronXL die Daten aus der angegebenen Excel-Datei zu lesen. Die Funktion ReadExcelFile lädt die Excel-Arbeitsmappe, öffnet das erste Tabellenblatt und sammelt die Daten, indem sie die Zeilen des Datentabellenblatts 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 Methode InsertData verwendet parametrisierte Abfragen, um SQL-Injection zu verhindern, und erstellt dynamisch eine SQL-INSERT-Abfrage basierend auf den Schlüsseln des Wörterbuchs, die als Spaltennamen dienen.
Mithilfe der Klasse ExcelReader zum Einlesen der Daten aus der Excel-Datei in die SQL-Tabelle und der Klasse SqlServerConnector zum Einfügen jeder Zeile in die SQL-Server-Tabelle steuert die Funktion Main 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
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 einfach zwischen SQL-Servern verschieben, indem sie parametrisierte Abfragen verwenden, um die Sicherheit zu verbessern und SQL-Injection 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.




