Test in einer Live-Umgebung
Test in der Produktion ohne Wasserzeichen.
Funktioniert überall, wo Sie es brauchen.
In der digitalen Welt von heute ist der effiziente Umgang mit Daten eine wichtige Aufgabe. Eine häufige Anforderung bei der Softwareentwicklung ist das Lesen von Daten aus einer CSV-Datei und deren Speicherung in einer Datenbank. Dieses Tutorial behandelt die Schritte zum Lesen von Daten aus einer CSV-Datei und zum Speichern in einer SQL Server-Datenbank mit C#, insbesondere unter Verwendung derIronXL-Bibliothek. Dieser Leitfaden richtet sich an Anfänger und wird auf einfache, ansprechende Weise erklärt.
A CSV(Komma-getrennte Werte) datei ist eine reine Textdatei, die durch Kommas getrennte Daten enthält. Aufgrund seiner Einfachheit und Kompatibilität mit verschiedenen Anwendungen, wie z. B. Excel, ist es ein beliebtes Format für die Übertragung von Daten.
SQL Server ist ein Datenbankmanagementsystem von Microsoft. Sie dient der strukturierten Speicherung und Verwaltung von Daten. In unserem Fall werden wir die CSV-Daten in einer SQL Server-Tabelle speichern.
IronXL ist eine auf .NET-Anwendungen zugeschnittene Excel-Bibliothek, die es Entwicklern ermöglicht, Excel-Dateien zu lesen, zu generieren und zu bearbeiten, ohne dass sie die Microsoft Office Interop benötigen. Diese Bibliothek zeichnet sich durch ihre Kompatibilität mit verschiedenen .NET-Versionen und -Plattformen aus, einschließlich .NET Core, .NET-Standard und .NET-Framework, sowie durch ihre Unterstützung für verschiedene Betriebssysteme wie Windows, Linux und macOS. Es ist eine leistungsstarke Bibliothek für den Datenimport, insbesondere für die Bearbeitung von CSV-Dateien.
Erstellen Sie ein C#-Konsolenprogramm in Visual Studio.
Installieren Sie die CSV-Bibliothek mit NuGet Package Manager.
Laden Sie die CSV-Datei mit Hilfe der Bibliothek in das Programm.
Erstellen Sie eine Verbindung mit der Datenbank.
Lesen Sie den Inhalt der CSV-Datei mit Hilfe der Bibliothek.
Kopieren Sie diesen Inhalt mit der Methode SqlBulkCopy in die Datenbank.
Hier ist ein Beispiel-Codeausschnitt:
using System;
using System.Data;
using System.Data.SqlClient;
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))
{
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!");
}
}
}
}
using System;
using System.Data;
using System.Data.SqlClient;
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))
{
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!");
}
}
}
}
Imports System
Imports System.Data
Imports System.Data.SqlClient
Imports CsvHelper
Namespace CsvReader
Friend Class Program
Shared Sub Main(ByVal args() As String)
Dim csvPath As String = "path\to\your\csv\file.csv"
Using reader = New StreamReader(csvPath)
Using csv = New CsvReader(reader, CultureInfo.InvariantCulture)
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
End Namespace
Ersetzen Sie "path\to\your\csv\file.csv" durch den tatsächlichen Pfad zu Ihrer CSV-Datei, "YourModel" durch das Modell, das Ihre CSV-Daten darstellt, "your_connection_string" durch Ihre Datenbankverbindungszeichenfolge und "YourTableName" durch den Namen Ihrer Datenbanktabelle.
Visual Studio: Stellen Sie sicher, dass Sie Visual Studio installiert haben.
SQL Server: Sie sollten SQL Server installiert und zugänglich haben.
Install-Package IronXL.Excel
oder
dotnet add package IronXL
Stellen Sie sicher, dass Sie diese Befehle in dem Projektverzeichnis ausführen, in dem Sie IronXL installieren möchten.
Bevor Sie Daten importieren, erstellen Sie eine Zieltabelle in Ihrer SQL Server-Datenbank. In dieser Tabelle werden die CSV-Daten gespeichert.
CREATE TABLE YourTableName (
Column1 DataType,
Column2 DataType,
...
);
Ersetzen Sie IhrTabellenname, Spalte1, Spalte2 und Datentyp durch Ihre spezifischen Angaben.
Stellen Sie zunächst sicher, dass Sie eine CSV-Datei mit den Daten haben, die Sie importieren möchten.
Erstellen Sie ein neues C#-Konsolenanwendungsprojekt in Visual Studio.
:installCmd Install-Package CsvHelper
using System;
using System.IO;
using CsvHelper;
using System;
using System.IO;
using CsvHelper;
Imports System
Imports System.IO
Imports CsvHelper
string csvFilePath = @"C:\path\to\your\csv\file.csv";
string csvFilePath = @"C:\path\to\your\csv\file.csv";
Dim csvFilePath As String = "C:\path\to\your\csv\file.csv"
Stellen Sie sicher, dass Sie "C:\path\to\your\csv\file.csv" durch den tatsächlichen Pfad zu Ihrer CSV-Datei ersetzen.
StreamReader
, um die CSV-Datei zu lesen: using (var reader = new StreamReader(csvFilePath))
{
// code goes here
}
using (var reader = new StreamReader(csvFilePath))
{
// code goes here
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
using (var reader = new StreamReader(csvFilePath))
using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
{
// code goes here
}
using (var reader = new StreamReader(csvFilePath))
using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
{
// code goes here
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
csv.Configuration.HasHeaderRecord = true;
csv.Configuration.HasHeaderRecord = true;
csv.Configuration.HasHeaderRecord = True
GetRecords<T>()methode des "CsvReader"-Objekts, um die CSV-Daten in eine Sammlung von Objekten zu lesen. Ersetzen
var records = csv.GetRecords<YourModel>();
var records = csv.GetRecords<YourModel>();
Dim records = csv.GetRecords(Of YourModel)()
Stellen Sie sicher, dass Sie "IhrModell" durch den tatsächlichen Namen Ihrer Modellklasse ersetzen.
foreach (var record in records)
{
// code goes here
}
foreach (var record in records)
{
// code goes here
}
IRON VB CONVERTER ERROR developers@ironsoftware.com
Optional können Sie eine Verbindung zu Ihrer SQL Server-Datenbank mit ADO.NET oder einem ORM-Tool wie Entity Framework herstellen.
Fügen Sie jeden Datensatz mit dem von Ihnen gewählten Datenbankzugriffsmechanismus in die Datenbank ein. Wenn Sie z. B. ADO.NET verwenden, können Sie die Klasse "SqlBulkCopy" nutzen, um die Daten effizient in großen Mengen einzufügen.
Behandeln Sie alle Ausnahmen, die während des Importvorgangs auftreten können, und geben Sie entsprechende Fehlermeldungen oder Protokolle aus.
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 mit C# in Ihre SQL Server-Datenbank importiert.
Wenn Sie mit dem Importieren von Daten aus einer CSV-Datei beginnen, besteht der erste wichtige Schritt darin, die Daten in der Datei genau zu lesen. Jede Zeile in einer CSV-Datei stellt normalerweise einen Datensatz dar, und jeder Datensatz besteht aus einem oder mehreren Feldern, die durch Kommas getrennt sind.
Wir verwenden dann die IronXL-Bibliothek, um die CSV-Datei zu verarbeiten. Um die CSV-Datei mit IronXL zu lesen, verwenden Sie die Klassen WorkBook und WorkSheet. Die Klasse WorkBook repräsentiert ein komplettes Tabellenblatt, das eine Excel-Datei oder, in unserem Fall, eine CSV-Datei sein kann. Wenn Sie den Pfad der CSV-Datei in ein WorkBook-Objekt laden, behandelt IronXL die CSV-Datei als eine Tabellenkalkulation/Datentabelle.
using IronXL;
public class CSVReader
{
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;
public class CSVReader
{
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
Public Class CSVReader
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
Das Herstellen einer Verbindung zu Ihrer SQL Server-Datenbank ist ein grundlegender Schritt im Prozess der Speicherung Ihrer CSV-Daten. In diesem Schritt wird eine Kommunikationsverbindung zwischen Ihrer Anwendung und dem Datenbankserver hergestellt. Eine erfolgreiche Verbindung ist von entscheidender Bedeutung, denn ohne sie wäre die Übertragung von Daten in die Datenbank unmöglich.
In diesem Schritt geht es um das Erstellen und Öffnen einer Verbindung mithilfe einer Verbindungszeichenfolge in C#. Die Verbindungszeichenfolge ist eine wichtige Komponente, da sie die für den Verbindungsaufbau erforderlichen Informationen enthält. Er ist wie ein Schlüssel, der die Tür zu Ihrer Datenbank öffnet.
public class DatabaseConnector
{
private string connectionString = "your_connection_string_here";
public SqlConnection ConnectToDatabase()
{
SqlConnection connection = new SqlConnection(connectionString);
connection.Open();
return connection;
}
}
public class DatabaseConnector
{
private string connectionString = "your_connection_string_here";
public SqlConnection ConnectToDatabase()
{
SqlConnection connection = new SqlConnection(connectionString);
connection.Open();
return connection;
}
}
Public Class DatabaseConnector
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 Variable connectionString
enthält alle notwendigen Details für die Verbindung zu Ihrem SQL Server. Sie enthält in der Regel den Servernamen, den Datenbanknamen, die Benutzer-ID und das Passwort. Ein Beispiel für einen Verbindungsstring sieht wie folgt aus: server=MeineServerAdresse;Datenbank=MeineDatenbank;Benutzerkennung=MeinBenutzername;Passwort=MeinKennwort;`. Ersetzen Sie diese Platzhalter unbedingt durch Ihre tatsächlichen Serverdaten.
Nachdem eine Verbindung mit der SQL Server-Datenbank hergestellt wurde, besteht der nächste wichtige Schritt darin, die CSV-Daten in der Datenbank zu speichern. In diesem Schritt werden die gelesenen und verarbeiteten Daten in Ihre SQL Server-Tabelle übertragen. Sie ist ein entscheidender Teil des Datenverarbeitungsprozesses, da sie die tatsächliche Datenmigration von einer lokalen Datei zu einem Datenbankserver beinhaltet.
In diesem Schritt konzentrieren wir uns darauf, wie die CSV-Daten, die nun in einer 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 bewältigen.
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);
}
}
}
}
}
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);
}
}
}
}
}
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
Zunächst wird mit Hilfe der Klasse DatabaseConnector eine Verbindung zur SQL Server-Datenbank hergestellt, um einen Weg für Datentransaktionen zu gewährleisten. Die Methode prüft, ob die Tabelle "CSVData" in der Datenbank vorhanden ist.
Wenn die Tabelle nicht gefunden wird, wird sie erstellt. Das Tabellenschema wird auf der Grundlage des an die Methode übergebenen DataTable-Schemas erstellt, wobei alle Spalten auf NVARCHAR gesetzt werden(MAX)** zur Aufnahme beliebiger Textdaten. Dies ist ein allgemeiner Ansatz, der möglicherweise verfeinert werden muss, um bestimmte Datentypen besser abzubilden.
Danach wird ein SQL-Befehl formuliert und ausgeführt, um entweder die Existenz der Tabelle zu überprüfen oder sie zu erstellen. Dadurch wird sichergestellt, dass der nachfolgende Massenkopiervorgang eine Zieltabelle hat, die zum Einfügen der Daten bereit ist. Wenn die Tabelle fertig ist, wird die Klasse SqlBulkCopy verwendet, um Daten aus der DataTable direkt in die SQL Server-Tabelle zu übertragen. Dieser Vorgang ist für leistungsstarke Massendatenübertragungen ausgelegt und eignet sich daher für die effiziente Verarbeitung großer Datenmengen.
Nachdem wir die vorangegangenen Schritte des Einlesens von CSV-Daten, des Aufbaus einer Datenbankverbindung und der Vorbereitung der Datenübertragung gewissenhaft durchgeführt haben, kommen wir zum letzten und entscheidenden Schritt: der Integration dieser einzelnen Komponenten in einen zusammenhängenden Prozess.
Diese Integration erfolgt in der Main
-Methode Ihrer C#-Anwendung, wo alles zusammenkommt und die tatsächliche Ausführung des Datenimports aus der CSV-Datei in die SQL Server-Datenbank ermöglicht.
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 Pfad_zu_Ihrer_csv-Datei.csv
durch den Pfad zu Ihrer CSV-Datei.
Wenn Sie das Projekt ausführen, sehen Sie die folgende Ausgabe. Die Erfolgsmeldungen zeigen an, dass alle Operationen erfolgreich ausgeführt wurden und die Daten in die Datenbank kopiert wurden.
Data imported successfully!
Nun können Sie SQL Server Management Studio öffnen(SSMS) und prüfen Sie die Tabelle unter der Datenbank. In der Tabelle sehen Sie die folgenden Daten.
Dieses Lernprogramm hat Sie durch den Prozess des Lesens von Daten aus einer CSV-Datei und deren Speicherung in einer SQL Server-Datenbank mit C# geführt. Wenn Sie diese Schritte befolgen und die IronXL-Bibliothek verwenden, können Sie CSV-Daten in Ihren C#-Anwendungen effizient verwalten.
IronXL bietet einekostenloser Test damit die Nutzer die Funktionen kennenlernen können, bevor sie sich zum Kauf verpflichten. Diese voll funktionsfähige Testversion ermöglicht es potenziellen Benutzern, das Produkt in einer Live-Umgebung ohne Wasserzeichen in der Produktion zu testen und zu bewerten. Wenn Sie sich nach der Testphase entscheiden, IronXL weiterhin für Ihre Projekte zu verwenden, beginnt die Lizenzierung für das Produkt mit $749.
9 .NET API-Produkte für Ihre Bürodokumente