W dzisiejszym cyfrowym świecie, efektywne zarządzanie danymi jest ważnym zadaniem. Częstym wymaganiem w rozwoju oprogramowania jest czytanie danych z pliku CSV i ich przechowywanie w bazie danych. Ten samouczek obejmuje kroki do czytania danych z pliku CSV i przechowywania ich w bazie danych SQL Server przy użyciu C#, szczególnie wykorzystując bibliotekę IronXL. Ten przewodnik jest zaprojektowany dla początkujących i będzie wyjaśniony w prosty, angażujący sposób.

Zrozumienie podstaw

Czym jest plik CSV?

Plik CSV (Comma-Separated Values) to plik tekstowy zawierający dane oddzielone przecinkami. To popularny format do przesyłania danych z powodu swojej prostoty i kompatybilności z różnymi aplikacjami, jak Excel.

Rola SQL Server i baz danych

SQL Server to system zarządzania bazami danych opracowany przez Microsoft. Służy do przechowywania i zarządzania danymi w sposób ustrukturyzowany. W naszym przypadku przechowamy dane CSV w tabeli SQL Server.

Wprowadzenie do IronXL

IronXL to biblioteka Excela dostosowana do aplikacji .NET, specjalnie zaprojektowana do umożliwienia programistom czytania, generowania i edytowania plików Excela bez potrzeby stosowania Microsoft Office Interop. Ta biblioteka wyróżnia się kompatybilnością z różnymi wersjami i platformami .NET, w tym .NET Core, .NET Standard i .NET Framework, jak również wsparciem dla różnych systemów operacyjnych jak Windows, Linux i macOS. To potężna biblioteka do importowania danych, szczególnie do obsługi plików CSV.

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

1. Utwórz program konsolowy C# w Visual Studio.
2. Zainstaluj bibliotekę CSV używając Menedżera Pakietów NuGet.
3. Załaduj plik CSV w programie używając biblioteki.
4. Utwórz połączenie z bazą danych.
5. Czytaj zawartość z pliku CSV za pomocą biblioteki.
6. Skopiuj tę zawartość do bazy danych za pomocą metody SqlBulkCopy.

Oto przykład fragmentu kodu:

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

Upewnij się, że zastąpiłeś "path\to\your\csv\file.csv" rzeczywistą ścieżką do pliku CSV, YourModel modelem reprezentującym dane CSV, "your_connection_string" łańcuchem połączenia z bazą danych, a "YourTableName" nazwą swojej tabeli w bazie danych.

Konfiguracja środowiska

Wymagania wstępne

1. Visual Studio: Upewnij się, że masz zainstalowany Visual Studio.
2. SQL Server: Powinieneś mieć zainstalowany i dostępny SQL Server.
3. Instalacja IronXL: Zainstaluj IronXL uruchamiając następujące polecenie NuGet:

dotnet add package IronXL.Excel

Upewnij się, że uruchamiasz te polecenia w katalogu projektu, gdzie chcesz zainstalować IronXL.

Tworzenie tabeli SQL Server

Przed importowaniem danych utwórz tabelę docelową w swojej bazie danych SQL Server. Ta tabela będzie przechowywać dane CSV.

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

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

Zastąp YourTableName, Column1, Column2 i DataType swoimi szczegółowymi danymi.

Krok po kroku przewodnik po importowaniu danych CSV

1. Najpierw upewnij się, że masz plik CSV zawierający dane, które chcesz zaimportować.

2. Utwórz nowy projekt aplikacji konsolowej C# w Visual Studio.

3. Zainstaluj pakiet NuGet CsvHelper do czytania plików CSV. Możesz to zrobić, otwierając Konsolę Menedżera Pakietów NuGet w Visual Studio i uruchamiając następujące polecenie:

   Install-Package CsvHelper

   SHELL

4. Dodaj niezbędne dyrektywy using na początku swojego pliku kodu C#:

   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. W swoim kodzie określ ścieżkę do swojego pliku CSV. Na przykład:

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

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

   C#VB

   Upewnij się, że zastąpiłeś C:\path\to\your\csv\file.csv rzeczywistą ścieżką do pliku CSV.

6. Utwórz nową instancję klasy StreamReader, aby odczytać plik CSV:

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

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

   C#VB

7. Utwórz nową instancję klasy CsvReader, przekazując obiekt StreamReader:

   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. Opcjonalnie skonfiguruj CsvReader za pomocą niezbędnych ustawień, przekazując obiekt CsvConfiguration do jego konstruktora. Na przykład:

   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. Użyj metody GetRecords<t>() obiektu CsvReader, aby odczytać dane CSV do kolekcji obiektów. Zastąp <t> typem obiektu, który reprezentuje każdy rekord w pliku CSV. Na przykład:

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

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

   C#VB

   Upewnij się, że zastąpiłeś YourModel rzeczywistą nazwą swojej klasy modelu.

10. Iteruj po rekordach i przeprowadź wszelkie wymagane przetwarzanie lub walidację.

    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. Opcjonalnie, ustanów połączenie z bazą danych SQL Server, używając ADO.NET lub narzędzi ORM jak Entity Framework.

12. Wstaw każdy rekord do bazy danych, używając wybranego mechanizmu dostępu do bazy danych. Na przykład, jeśli używasz ADO.NET, możesz wykorzystać klasę SqlBulkCopy do efektywnego wstawiania danych masowych.

13. Obsłuż wszelkie wyjątki, które mogą wystąpić podczas procesu importu i dostarcz odpowiednie komunikaty o błędach lub logowanie.

14. Przetestuj swoją aplikację, uruchamiając ją i weryfikując, że dane CSV zostały pomyślnie zaimportowane do bazy danych.

To wszystko! Pomyślnie zaimportowałeś dane CSV do bazy danych SQL Server używając C#.

Krok 1: Odczyt pliku CSV

Rozpoczynając zadanie importu danych z pliku CSV, pierwszym kluczowym krokiem jest dokładne odczytanie zawartych danych. Każdy wiersz w pliku CSV zazwyczaj reprezentuje rekord danych, a każdy rekord składa się z jednego lub wielu pól, oddzielonych przecinkami.

Następnie używamy biblioteki IronXL do obsługi pliku CSV. Aby odczytać plik CSV za pomocą IronXL, należy skorzystać z klas WorkBook i WorkSheet. Klasa WorkBook reprezentuje cały arkusz kalkulacyjny, którym może być plik Excel lub, jak w naszym przypadku, plik CSV. Gdy załadujesz ścieżkę pliku CSV do obiektu WorkBook, IronXL traktuje plik CSV jako arkusz / tabelę danych.

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

Krok 2: Ustanowienie połączenia z bazą danych

Ustanowienie połączenia z bazą danych SQL Server jest fundamentalnym krokiem w procesie przechowywania danych CSV. Ten krok polega na skonfigurowaniu drogi komunikacji między twoją aplikacją a serwerem bazy danych. Udane połączenie jest kluczowe, ponieważ bez niego transfer danych do bazy danych byłby niemożliwy.

Ten krok skupia się na stworzeniu i otwarciu połączenia za pomocą ciągu połączenia w C#. Ciąg połączenia jest niezbędnym komponentem, ponieważ zawiera informacje potrzebne do ustanowienia połączenia. To jak klucz, który otwiera drzwi do twojej bazy danych.

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

Zmienna connectionString zawiera wszystkie niezbędne szczegóły do połączenia z serwerem SQL. Zazwyczaj zawiera nazwę serwera, nazwę bazy danych, identyfikator użytkownika i hasło. Przykład łańcucha połączenia wygląda tak: Server=myServerAddress;Database=myDataBase;User Id=myUsername;Password=myPassword;. Ważne jest, aby zastąpić te zastępniki rzeczywistymi szczegółami swojego serwera.

Krok 3: Przechowywanie danych w bazie danych

Po ustanowieniu połączenia z bazą danych SQL Server, następnym kluczowym krokiem jest przechowywanie danych CSV w bazie danych. Ten krok dotyczy przeniesienia danych, które odczytałeś i przetworzyłeś, do swojej tabeli SQL Server. To kluczowa część procesu zarządzania danymi, ponieważ dotyczy faktycznej migracji danych z lokalnego pliku do serwera bazy danych.

W tym kroku skupimy się na tym, jak dane CSV, teraz przechowywane w DataTable, są przesyłane do bazy danych SQL Server. Używamy kombinacji funkcji C# i SQL Server, aby wykonać to zadanie efektywnie.

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

Zaczyna się od otwarcia połączenia z bazą danych SQL Server za pomocą klasy DatabaseConnector, co zapewnia drogę do transakcji danych. Metoda sprawdza istnienie tabeli o nazwie "CSVData" w bazie danych.

Jeśli tabela nie zostanie znaleziona, następuje jej utworzenie. Schemat tabeli jest konstruowany na podstawie schematu DataTable przekazanego do metody, gdzie wszystkie kolumny są ustawione na NVARCHAR(MAX), aby pomieścić dowolne dane tekstowe. To ogólne podejście może wymagać dostosowania, aby dokładniej dopasować konkretne typy danych.

Następnie formułowane i wykonywane jest polecenie SQL, aby albo zweryfikować istnienie tabeli, albo ją utworzyć. To zapewnia, że następująca operacja kopiowania masowego ma gotową tabelę docelową do wstawiania danych. Gdy tabela jest gotowa, klasa SqlBulkCopy jest używana do przesyłania danych z DataTable bezpośrednio do tabeli SQL Server. Ta operacja jest zaprojektowana do wysokowydajnych masowych transferów danych, czyniąc ją odpowiednią do obsługi dużych ilości danych efektywnie.

Krok 4: Połączenie wszystkiego w całość

Po skrupulatnej pracy przez wcześniejsze kroki czytania danych CSV, ustanowienia połączenia z bazą danych i przygotowania do transferu danych, docieramy do końcowego i kluczowego etapu: zintegrowania tych poszczególnych komponentów w spójny proces.

Ta integracja jest przeprowadzana w metodzie Main aplikacji C#, gdzie wszystko się łączy, umożliwiając rzeczywiste wykonanie importu danych z pliku CSV do bazy danych SQL Server.

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

Zastąp path_to_your_csv_file.csv ścieżką do swojego pliku CSV.

Uruchamianie projektu

Kiedy uruchomisz projekt, zobaczysz następujący wynik. Komunikaty sukcesu oznaczają, że wszystkie operacje zostały wykonane pomyślnie, a dane zostały skopiowane do bazy danych.

Data imported successfully!

Data imported successfully!

Teraz możesz otworzyć SQL Server Management Studio (SSMS) i sprawdzić tabelę w bazie danych. Zobaczysz następujące dane w tabeli.

Wnioski

Ten samouczek przeprowadził cię przez proces czytania danych z pliku CSV i przechowywania ich w bazie danych SQL Server przy użyciu C#. Poprzez przestrzeganie tych kroków i wykorzystanie biblioteki IronXL, możesz efektywnie zarządzać danymi CSV w swoich aplikacjach C#.

IronXL oferuje wypróbować za darmo dla użytkowników, aby doświadczyć jego funkcji przed dokonaniem zakupu. Ten w pełni funkcjonalny okres próbny pozwala potencjalnym użytkownikom testować i oceniać produkt w rzeczywistym środowisku bez żadnych znaków wodnych w produkcji. Po okresie próbnym, jeśli zdecydujesz się kontynuować używanie IronXL w swoich projektach, licencjonowanie produktu zaczyna się od $999.