In der heutigen digitalen Welt ist der effiziente Umgang mit Daten eine wichtige Aufgabe. Eine häufige Anforderung in der Softwareentwicklung besteht darin, Daten aus einer CSV-Datei zu lesen und in einer Datenbank zu speichern. Dieses Tutorial behandelt die Schritte, um Daten aus einer CSV-Datei zu lesen und in einer SQL Server-Datenbank mit C# zu speichern, wobei die IronXL-Bibliothek verwendet wird. Diese Anleitung ist für Anfänger konzipiert und wird auf eine einfache, ansprechende Weise erklärt.

Grundlagen verstehen

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.

Einführung in IronXL

IronXL ist eine Excel-Bibliothek, die für .NET-Anwendungen maßgeschneidert ist. Sie wurde speziell entwickelt, um Entwicklern das Lesen, Generieren und Bearbeiten von Excel-Dateien zu ermöglichen, ohne dass Microsoft Office Interop erforderlich ist. Diese Bibliothek zeichnet sich durch ihre Kompatibilität mit verschiedenen .NET-Versionen und Plattformen, einschließlich .NET Core, .NET Standard und .NET Framework, sowie durch ihre Unterstützung für verschiedene Betriebssysteme wie Windows, Linux und macOS aus. Es ist eine leistungsstarke Bibliothek für den Datenimport, insbesondere für den Umgang mit CSV-Dateien.

How to Read and Store Data From CSV Files in C#

1. Erstellen Sie ein C#-Konsolenprogramm in Visual Studio.
2. Installieren Sie die CSV-Bibliothek mit dem NuGet-Paket-Manager.
3. Laden Sie die CSV-Datei im Programm mit der Bibliothek.
4. Erstellen Sie eine Verbindung mit der Datenbank.
5. Lesen Sie den Inhalt der CSV-Datei mit der Bibliothek.
6. Kopieren Sie diesen Inhalt mithilfe der SqlBulkCopy-Methode in die Datenbank.

Hier ist ein Beispiel für einen Codeauszug:

using System;
using System.Data;
using System.Data.SqlClient; // For .NET Core/.NET 5+, use Microsoft.Data.SqlClient instead
using System.Globalization;
using System.IO;
using CsvHelper;

namespace CsvReader
{
    class Program
    {
        static void Main(string[] args)
        {
            string csvPath = @"path\to\your\csv\file.csv";

            using (var reader = new StreamReader(csvPath))
            using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
            {
                // Mapping the CSV data to the corresponding model
                var records = csv.GetRecords<YourModel>();

                using (var sqlBulkCopy = new SqlBulkCopy("your_connection_string"))
                {
                    sqlBulkCopy.DestinationTableName = "YourTableName";
                    sqlBulkCopy.WriteToServer(records.AsDataReader());
                }

                Console.WriteLine("Data imported successfully!");
            }
        }
    }

    // Define your model that maps to the CSV columns
    public class YourModel
    {
        // Define properties here representing the CSV columns
    }
}

using System;
using System.Data;
using System.Data.SqlClient; // For .NET Core/.NET 5+, use Microsoft.Data.SqlClient instead
using System.Globalization;
using System.IO;
using CsvHelper;

namespace CsvReader
{
    class Program
    {
        static void Main(string[] args)
        {
            string csvPath = @"path\to\your\csv\file.csv";

            using (var reader = new StreamReader(csvPath))
            using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
            {
                // Mapping the CSV data to the corresponding model
                var records = csv.GetRecords<YourModel>();

                using (var sqlBulkCopy = new SqlBulkCopy("your_connection_string"))
                {
                    sqlBulkCopy.DestinationTableName = "YourTableName";
                    sqlBulkCopy.WriteToServer(records.AsDataReader());
                }

                Console.WriteLine("Data imported successfully!");
            }
        }
    }

    // Define your model that maps to the CSV columns
    public class YourModel
    {
        // Define properties here representing the CSV columns
    }
}

Imports System
Imports System.Data
Imports System.Data.SqlClient ' For .NET Core/.NET 5+, use Microsoft.Data.SqlClient instead
Imports System.Globalization
Imports System.IO
Imports CsvHelper

Namespace CsvReader
    Class Program
        Shared Sub Main(args As String())
            Dim csvPath As String = "path\to\your\csv\file.csv"

            Using reader As New StreamReader(csvPath)
                Using csv As New CsvReader(reader, CultureInfo.InvariantCulture)
                    ' Mapping the CSV data to the corresponding model
                    Dim records = csv.GetRecords(Of YourModel)()

                    Using sqlBulkCopy As New SqlBulkCopy("your_connection_string")
                        sqlBulkCopy.DestinationTableName = "YourTableName"
                        sqlBulkCopy.WriteToServer(records.AsDataReader())
                    End Using

                    Console.WriteLine("Data imported successfully!")
                End Using
            End Using
        End Sub
    End Class

    ' Define your model that maps to the CSV columns
    Public Class YourModel
        ' Define properties here representing the CSV columns
    End Class
End Namespace

Imports System
Imports System.Data
Imports System.Data.SqlClient ' For .NET Core/.NET 5+, use Microsoft.Data.SqlClient instead
Imports System.Globalization
Imports System.IO
Imports CsvHelper

Namespace CsvReader
    Class Program
        Shared Sub Main(args As String())
            Dim csvPath As String = "path\to\your\csv\file.csv"

            Using reader As New StreamReader(csvPath)
                Using csv As New CsvReader(reader, CultureInfo.InvariantCulture)
                    ' Mapping the CSV data to the corresponding model
                    Dim records = csv.GetRecords(Of YourModel)()

                    Using sqlBulkCopy As New SqlBulkCopy("your_connection_string")
                        sqlBulkCopy.DestinationTableName = "YourTableName"
                        sqlBulkCopy.WriteToServer(records.AsDataReader())
                    End Using

                    Console.WriteLine("Data imported successfully!")
                End Using
            End Using
        End Sub
    End Class

    ' Define your model that maps to the CSV columns
    Public Class YourModel
        ' Define properties here representing the CSV columns
    End Class
End Namespace

Stellen Sie sicher, dass Sie "path\to\your\csv\file.csv" durch den tatsächlichen Pfad zu Ihrer CSV-Datei, YourModel durch das Modell, das Ihre CSV-Daten repräsentiert, "your_connection_string" durch Ihren Datenbankverbindungsstring und "YourTableName" durch den Namen Ihrer Datenbanktabelle ersetzen.

Einrichten der Umgebung

Voraussetzungen

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

dotnet add package IronXL.Excel

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,
    ...
);

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

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

Schritt-für-Schritt-Anleitung zum Importieren von CSV-Daten

1. Stellen Sie zunächst sicher, dass Sie eine CSV-Datei haben, die die zu importierenden Daten enthält.

2. Erstellen Sie ein neues C#-Konsolenanwendungsprojekt in Visual Studio.

3. Installieren Sie das CsvHelper NuGet-Paket zum Lesen von CSV-Dateien. Dies können Sie tun, indem Sie die NuGet-Paketverwaltungskonsole in Visual Studio öffnen und den folgenden Befehl ausführen:

   Install-Package CsvHelper

   SHELL

4. Fügen Sie die erforderlichen using-Anweisungen oben in Ihrer C#-Code-Datei hinzu:

   using System;
   using System.IO;
   using System.Globalization;
   using CsvHelper;
   using System.Data.SqlClient; // For .NET Core/.NET 5+, use Microsoft.Data.SqlClient instead

   Imports System
   Imports System.IO
   Imports System.Globalization
   Imports CsvHelper
   Imports System.Data.SqlClient ' For .NET Core/.NET 5+, use Microsoft.Data.SqlClient instead

   C#VB

5. Geben Sie in Ihrem Code den Pfad zu Ihrer CSV-Datei an. Zum Beispiel:

   string csvFilePath = @"C:\path\to\your\csv\file.csv";

   Dim csvFilePath As String = "C:\path\to\your\csv\file.csv"

   C#VB

   Stellen Sie sicher, dass Sie C:\path\to\your\csv\file.csv durch den tatsächlichen Pfad zu Ihrer CSV-Datei ersetzen.

6. Erstellen Sie eine neue Instanz der StreamReader-Klasse, um die CSV-Datei zu lesen:

   using (var reader = new StreamReader(csvFilePath))
   {
       // code goes here
   }

   Using reader = New StreamReader(csvFilePath)
   	' code goes here
   End Using

   C#VB

7. Erstellen Sie eine neue Instanz der CsvReader-Klasse und übergeben Sie das StreamReader-Objekt:

   using (var reader = new StreamReader(csvFilePath))
   using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
   {
       // code goes here
   }

   Using reader = New StreamReader(csvFilePath)
   Using csv = New CsvReader(reader, CultureInfo.InvariantCulture)
   	' code goes here
   End Using
   End Using

   C#VB

8. Optional: Konfigurieren Sie die CsvReader mit den notwendigen Einstellungen, indem Sie ein CsvConfiguration-Objekt an ihren Konstruktor übergeben. Zum Beispiel:

   var config = new CsvConfiguration(CultureInfo.InvariantCulture)
   {
       HasHeaderRecord = true,
   };
   using var csv = new CsvReader(reader, config);

   Imports System.Globalization
   Imports CsvHelper
   
   Dim config As New CsvConfiguration(CultureInfo.InvariantCulture) With {
       .HasHeaderRecord = True
   }
   
   Using csv As New CsvReader(reader, config)
       ' Use csv here
   End Using

   C#VB

9. Verwenden Sie die GetRecords<t>()-Methode des CsvReader-Objekts, um die CSV-Daten in eine Sammlung von Objekten zu lesen. Ersetzen Sie <t> durch den Objekttyp, der jeden Eintrag in der CSV-Datei repräsentiert. Zum Beispiel:

   var records = csv.GetRecords<YourModel>();

   Dim records = csv.GetRecords(Of YourModel)()

   C#VB

   Stellen Sie sicher, dass Sie YourModel durch den tatsächlichen Namen Ihrer Modellklasse ersetzen.

10. Iterieren Sie über die Datensätze und führen Sie alle erforderlichen Verarbeitungen oder Validierungen durch:

    foreach (var record in records)
    {
        // Process each record as needed
    }

    For Each record In records
    	' Process each record as needed
    Next record

    C#VB

11. Stellen Sie optional eine Verbindung zu Ihrer SQL Server-Datenbank mit ADO.NET oder einem ORM-Tool wie Entity Framework her.

12. Fügen Sie jeden Datensatz mit Ihrem gewählten Datenbankzugangsmechanismus in die Datenbank ein. Wenn Sie beispielsweise ADO.NET verwenden, können Sie die SqlBulkCopy-Klasse nutzen, um die Daten effizient massenweise einzufügen.

13. Behandeln Sie alle während des Importprozesses auftretenden Ausnahmen und bieten Sie geeignete Fehlermeldungen oder Protokollierungen.

14. Testen Sie Ihre Anwendung, indem Sie sie ausführen und überprüfen, ob die CSV-Daten erfolgreich in Ihre Datenbank importiert wurden.

Das war's! Sie haben nun erfolgreich CSV-Daten in Ihre SQL Server-Datenbank mit C# importiert.

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 bearbeiten. Um die CSV-Datei mit IronXL zu lesen, verwenden Sie die WorkBook- und WorkSheet-Klassen. Die WorkBook-Klasse repräsentiert ein gesamtes Tabellenblatt, das eine Excel-Datei oder in unserem Fall eine CSV-Datei sein könnte. Wenn Sie den Pfad der CSV-Datei in ein WorkBook-Objekt laden, betrachtet IronXL die CSV-Datei als Tabellenblatt/Datenbanktabelle.

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

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; // For .NET Core/.NET 5+, use Microsoft.Data.SqlClient instead

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; // For .NET Core/.NET 5+, use Microsoft.Data.SqlClient instead

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 ' For .NET Core/.NET 5+, use Microsoft.Data.SqlClient instead

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

Imports System.Data.SqlClient ' For .NET Core/.NET 5+, use Microsoft.Data.SqlClient instead

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 sich mit Ihrem SQL-Server zu verbinden. 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; // For .NET Core/.NET 5+, use Microsoft.Data.SqlClient instead

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; // For .NET Core/.NET 5+, use Microsoft.Data.SqlClient instead

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 ' For .NET Core/.NET 5+, use Microsoft.Data.SqlClient instead

Public Class DataImporter
    Public Sub ImportData(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
            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

Imports System
Imports System.Data
Imports System.Data.SqlClient ' For .NET Core/.NET 5+, use Microsoft.Data.SqlClient instead

Public Class DataImporter
    Public Sub ImportData(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
            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 mit dem Öffnen einer Verbindung zur SQL-Server-Datenbank unter Verwendung der DatabaseConnector-Klasse, um einen Pfad für den Datentransfer 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 DataTable-Schema erstellt, das an die Methode übergeben wird, wobei alle Spalten auf NVARCHAR(MAX) gesetzt sind, um jegliche 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 Daten von der 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, wo alles zusammenkommt, um die tatsächliche Ausführung des Datenimports 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

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 mit dem 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!

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.

Abschluss

Dieses Tutorial hat Sie durch den Prozess geführt, Daten aus einer CSV-Datei zu lesen und in einer SQL Server-Datenbank mit C# zu speichern. Indem Sie diese Schritte befolgen und die IronXL-Bibliothek nutzen, können Sie CSV-Daten effizient in Ihren C#-Anwendungen verwalten.

IronXL bietet eine kostenlose Testversion für Benutzer, um die Funktionen zu erleben, bevor sie sich für einen Kauf entscheiden. Diese voll funktionsfähige Testversion erlaubt potenziellen Benutzern, das Produkt in einer Live-Umgebung zu testen und zu bewerten, ohne Wasserzeichen in der Produktion. Nach der Testperiode, falls Sie sich entscheiden, IronXL weiterhin für Ihre Projekte zu verwenden, beginnt die Lizenzierung des Produkts ab $999.