Wie man Daten aus einer CSV-Datei in einer Datenbank in C# liest und speichert

Was ist eine CSV-Datei?

Eine CSV (Comma-Separated Values) Datei ist eine einfache Textdatei, die Daten enthält, die durch Kommas getrennt sind. Es ist ein beliebtes Format für den Datenaustausch aufgrund seiner Einfachheit und Kompatibilität mit verschiedenen Anwendungen wie Excel.

Die Rolle von SQL Server und Datenbanken

SQL Server ist ein Datenbankverwaltungssystem von Microsoft. Es wird verwendet, um Daten strukturiert zu speichern und zu verwalten. In unserem Fall speichern wir die CSV-Daten in einer SQL Server-Tabelle.

Voraussetzungen

1. Visual Studio: Stellen Sie sicher, dass Sie Visual Studio installiert haben.
2. SQL Server: Sie sollten SQL Server installiert und zugänglich haben.
3. IronXL-Installation: Installieren Sie IronXL, indem Sie den folgenden NuGet-Befehl ausführen:

dotnet add package IronXL

Stellen Sie sicher, dass Sie diese Befehle im Projektverzeichnis ausführen, in dem Sie IronXL installieren möchten.

Erstellen einer SQL Server-Tabelle

Bevor Sie Daten importieren, erstellen Sie eine Ziel-Tabelle in Ihrer SQL Server-Datenbank. Diese Tabelle wird die CSV-Daten speichern.

CREATE TABLE YourTableName (
    Column1 DataType,
    Column2 DataType,
    ...
);

Ersetzen Sie YourTableName, Column1, Column2 und DataType mit Ihren spezifischen Details.

Schritt 1: Lesen der CSV-Datei

Beim Beginn der Aufgabe, Daten aus einer CSV-Datei zu importieren, ist der erste entscheidende Schritt, die darin enthaltenen Daten korrekt zu lesen. Jede Zeile in einer CSV-Datei stellt typischerweise einen Datenrekord dar, und jeder Rekord besteht aus einem oder mehreren Feldern, die durch Kommas getrennt sind.

Wir verwenden dann die IronXL-Bibliothek, um die CSV-Datei zu handhaben. Um die CSV-Datei mit IronXL zu lesen, verwenden Sie ihre WorkBook und WorkSheet-Klassen. Die WorkBook-Klasse repräsentiert ein ganzes Arbeitsblatt, das eine Excel-Datei oder, in unserem Fall, eine CSV-Datei sein könnte. Wenn Sie den CSV-Dateipfad in ein WorkBook-Objekt laden, behandelt IronXL die CSV-Datei als Arbeitsblatt/Datentabelle.

using IronXL;
using System.Data;

public class CSVReader
{
    // Reads a CSV file and converts it to a DataTable
    public DataTable ReadCSV(string filePath)
    {
        WorkBook workbook = WorkBook.Load(filePath);
        WorkSheet sheet = workbook.DefaultWorkSheet;
        // Convert to DataTable for easier processing
        DataTable dataTable = sheet.ToDataTable(true); // Set to 'true' if your CSV has a header row
        return dataTable;
    }
}

using IronXL;
using System.Data;

public class CSVReader
{
    // Reads a CSV file and converts it to a DataTable
    public DataTable ReadCSV(string filePath)
    {
        WorkBook workbook = WorkBook.Load(filePath);
        WorkSheet sheet = workbook.DefaultWorkSheet;
        // Convert to DataTable for easier processing
        DataTable dataTable = sheet.ToDataTable(true); // Set to 'true' if your CSV has a header row
        return dataTable;
    }
}

Imports IronXL
Imports System.Data

Public Class CSVReader
	' Reads a CSV file and converts it to a DataTable
	Public Function ReadCSV(ByVal filePath As String) As DataTable
		Dim workbook As WorkBook = WorkBook.Load(filePath)
		Dim sheet As WorkSheet = workbook.DefaultWorkSheet
		' Convert to DataTable for easier processing
		Dim dataTable As DataTable = sheet.ToDataTable(True) ' Set to 'true' if your CSV has a header row
		Return dataTable
	End Function
End Class

Schritt 2: Herstellen einer Datenbankverbindung

Das Herstellen einer Verbindung zu Ihrer SQL Server-Datenbank ist ein grundlegender Schritt im Prozess des Speicherns Ihrer CSV-Daten. Dieser Schritt beinhaltet das Einrichten einer Kommunikationsverbindung zwischen Ihrer Anwendung und dem Datenbankserver. Eine erfolgreiche Verbindung ist entscheidend, da ohne sie eine Datenübertragung in die Datenbank unmöglich wäre.

Dieser Schritt konzentriert sich auf das Erstellen und Öffnen einer Verbindung mit einem Verbindungsstring in C#. Der Verbindungsstring ist eine wesentliche Komponente, da er die Informationen enthält, die zur Erstellung der Verbindung erforderlich sind. Es ist wie ein Schlüssel, der die Tür zu Ihrer Datenbank öffnet.

using System.Data.SqlClient;

public class DatabaseConnector
{
    // Connection string to connect to the database
    private string connectionString = "your_connection_string_here";

    public SqlConnection ConnectToDatabase()
    {
        SqlConnection connection = new SqlConnection(connectionString);
        connection.Open();
        return connection;
    }
}

using System.Data.SqlClient;

public class DatabaseConnector
{
    // Connection string to connect to the database
    private string connectionString = "your_connection_string_here";

    public SqlConnection ConnectToDatabase()
    {
        SqlConnection connection = new SqlConnection(connectionString);
        connection.Open();
        return connection;
    }
}

Imports System.Data.SqlClient

Public Class DatabaseConnector
	' Connection string to connect to the database
	Private connectionString As String = "your_connection_string_here"

	Public Function ConnectToDatabase() As SqlConnection
		Dim connection As New SqlConnection(connectionString)
		connection.Open()
		Return connection
	End Function
End Class

Die connectionString-Variable enthält alle notwendigen Details, um die Verbindung zu Ihrem SQL Server herzustellen. Sie umfasst typischerweise den Servernamen, den Datenbanknamen, die Benutzer-ID und das Passwort. Ein Beispiel für einen Verbindungsstring sieht so aus: Server=myServerAddress;Database=myDataBase;User Id=myUsername;Password=myPassword;. Es ist wichtig, diese Platzhalter durch Ihre tatsächlichen Serverdetails zu ersetzen.

Schritt 3: Speichern von Daten in der Datenbank

Nachdem Sie eine Verbindung mit der SQL Server-Datenbank hergestellt haben, ist der nächste kritische Schritt, die CSV-Daten in der Datenbank zu speichern. Dieser Schritt beinhaltet das Übertragen der gelesenen und verarbeiteten Daten in Ihre SQL Server Tabelle. Es ist ein entscheidender Teil des Datenhandhabungsprozesses, da es die tatsächliche Datenmigration von einer lokalen Datei zu einem Datenbankserver beinhaltet.

In diesem Schritt konzentrieren wir uns darauf, wie die CSV-Daten, die jetzt in einem DataTable gespeichert sind, in die SQL Server-Datenbank übertragen werden. Wir verwenden eine Kombination aus C# und SQL Server-Funktionen, um diese Aufgabe effizient zu erledigen.

using System;
using System.Data;
using System.Data.SqlClient;

public class DataImporter
{
    public void ImportData(DataTable dataTable)
    {
        using (SqlConnection connection = new DatabaseConnector().ConnectToDatabase())
        {
            // Check if the table exists and create it if it does not.
            string tableName = "CSVData"; // Use a valid SQL table name format
            string checkTable = $"IF NOT EXISTS (SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = '{tableName}') BEGIN ";
            string createTable = "CREATE TABLE " + tableName + " (";
            for (int i = 0; i < dataTable.Columns.Count; i++)
            {
                createTable += $"[{dataTable.Columns[i].ColumnName}] NVARCHAR(MAX)";
                if (i < dataTable.Columns.Count - 1)
                    createTable += ", ";
            }
            createTable += ") END";
            SqlCommand createTableCommand = new SqlCommand(checkTable + createTable, connection);
            createTableCommand.ExecuteNonQuery();

            // Now we use SqlBulkCopy to import the data
            using (SqlBulkCopy bulkCopy = new SqlBulkCopy(connection))
            {
                bulkCopy.DestinationTableName = tableName;
                try
                {
                    bulkCopy.WriteToServer(dataTable);
                    Console.WriteLine("Data imported successfully!");
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
            }
        }
    }
}

using System;
using System.Data;
using System.Data.SqlClient;

public class DataImporter
{
    public void ImportData(DataTable dataTable)
    {
        using (SqlConnection connection = new DatabaseConnector().ConnectToDatabase())
        {
            // Check if the table exists and create it if it does not.
            string tableName = "CSVData"; // Use a valid SQL table name format
            string checkTable = $"IF NOT EXISTS (SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = '{tableName}') BEGIN ";
            string createTable = "CREATE TABLE " + tableName + " (";
            for (int i = 0; i < dataTable.Columns.Count; i++)
            {
                createTable += $"[{dataTable.Columns[i].ColumnName}] NVARCHAR(MAX)";
                if (i < dataTable.Columns.Count - 1)
                    createTable += ", ";
            }
            createTable += ") END";
            SqlCommand createTableCommand = new SqlCommand(checkTable + createTable, connection);
            createTableCommand.ExecuteNonQuery();

            // Now we use SqlBulkCopy to import the data
            using (SqlBulkCopy bulkCopy = new SqlBulkCopy(connection))
            {
                bulkCopy.DestinationTableName = tableName;
                try
                {
                    bulkCopy.WriteToServer(dataTable);
                    Console.WriteLine("Data imported successfully!");
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
            }
        }
    }
}

Imports System
Imports System.Data
Imports System.Data.SqlClient

Public Class DataImporter
	Public Sub ImportData(ByVal dataTable As DataTable)
		Using connection As SqlConnection = (New DatabaseConnector()).ConnectToDatabase()
			' Check if the table exists and create it if it does not.
			Dim tableName As String = "CSVData" ' Use a valid SQL table name format
			Dim checkTable As String = $"IF NOT EXISTS (SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = '{tableName}') BEGIN "
			Dim createTable As String = "CREATE TABLE " & tableName & " ("
			For i As Integer = 0 To dataTable.Columns.Count - 1
				createTable &= $"[{dataTable.Columns(i).ColumnName}] NVARCHAR(MAX)"
				If i < dataTable.Columns.Count - 1 Then
					createTable &= ", "
				End If
			Next i
			createTable &= ") END"
			Dim createTableCommand As New SqlCommand(checkTable & createTable, connection)
			createTableCommand.ExecuteNonQuery()

			' Now we use SqlBulkCopy to import the data
			Using bulkCopy As New SqlBulkCopy(connection)
				bulkCopy.DestinationTableName = tableName
				Try
					bulkCopy.WriteToServer(dataTable)
					Console.WriteLine("Data imported successfully!")
				Catch ex As Exception
					Console.WriteLine(ex.Message)
				End Try
			End Using
		End Using
	End Sub
End Class

Es beginnt damit, eine Verbindung zur SQL Server-Datenbank mit der DatabaseConnector-Klasse zu öffnen, um einen Weg für Datenübertragungen zu gewährleisten. Die Methode überprüft das Vorhandensein der Tabelle mit dem Namen "CSVData" in der Datenbank.

Wenn die Tabelle nicht gefunden wird, fährt sie fort, sie zu erstellen. Das Schema der Tabelle wird basierend auf dem übergebenen DataTable-Schema erstellt, wobei alle Spalten auf NVARCHAR(MAX) gesetzt werden, um alle Textdaten aufzunehmen. Dies ist ein generischer Ansatz und muss möglicherweise verfeinert werden, um den spezifischen Datentypen besser zu entsprechen.

Anschließend wird ein SQL-Befehl formuliert und ausgeführt, um entweder das Vorhandensein der Tabelle zu überprüfen oder sie zu erstellen. Dies stellt sicher, dass die nachfolgende Bulk-Kopieroperation eine Ziel-Tabelle für die Dateneinfügung bereit hat. Mit der fertigen Tabelle wird die SqlBulkCopy-Klasse verwendet, um die Daten aus dem DataTable direkt in die SQL Server-Tabelle zu übertragen. Diese Operation ist für Hochleistungs-Bulk-Datenübertragungen ausgelegt, wodurch sie sich für die effiziente Handhabung großer Datenmengen eignet.

Schritt 4: Alles zusammenfügen

Nachdem Sie die vorherigen Schritte des Lesens von CSV-Daten, des Herstellens einer Datenbankverbindung und der Vorbereitung auf die Datenübertragung sorgsam durchgearbeitet haben, kommen wir zum letzten und entscheidenden Schritt: der Integration dieser einzelnen Komponenten zu einem zusammenhängenden Prozess.

Diese Integration erfolgt in der Main-Methode Ihrer C#-Anwendung, in der alles zusammenkommt, um den tatsächlichen Datenimport von der CSV-Datei in die SQL Server-Datenbank zu ermöglichen.

class Program
{
    static void Main(string[] args)
    {
        string filePath = "path_to_your_csv_file.csv";
        CSVReader reader = new CSVReader();
        DataTable dataTable = reader.ReadCSV(filePath);
        DataImporter importer = new DataImporter();
        importer.ImportData(dataTable);
        Console.WriteLine("Data imported successfully!");
    }
}

class Program
{
    static void Main(string[] args)
    {
        string filePath = "path_to_your_csv_file.csv";
        CSVReader reader = new CSVReader();
        DataTable dataTable = reader.ReadCSV(filePath);
        DataImporter importer = new DataImporter();
        importer.ImportData(dataTable);
        Console.WriteLine("Data imported successfully!");
    }
}

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim filePath As String = "path_to_your_csv_file.csv"
		Dim reader As New CSVReader()
		Dim dataTable As DataTable = reader.ReadCSV(filePath)
		Dim importer As New DataImporter()
		importer.ImportData(dataTable)
		Console.WriteLine("Data imported successfully!")
	End Sub
End Class

Ersetzen Sie path_to_your_csv_file.csv durch den Pfad zu Ihrer CSV-Datei.

Das Projekt ausführen

Sobald Sie das Projekt ausführen, sehen Sie die folgende Ausgabe. Die Erfolgsmeldungen zeigen an, dass alle Vorgänge erfolgreich ausgeführt wurden und die Daten in die Datenbank kopiert wurden.

Data imported successfully!

Jetzt können Sie den SQL Server Management Studio (SSMS) öffnen und die Tabelle in der Datenbank überprüfen. Sie sehen die folgenden Daten in der Tabelle.