Wie man eine CSV-Datei in C# in eine DataTable liest

Warum ist die CSV-zu-DataTable-Umwandlung essenziell?

CSV-zu-DataTable-Umwandlung ermöglicht es Entwicklern, durch Kommas getrennte Werte (CSV-Daten) in strukturierte Objekte wie eine DataTable zur weiteren Verarbeitung zu transformieren. Egal, ob Sie Bestandsdaten, Kundendaten oder Transaktionsprotokolle verarbeiten, die Fähigkeit, CSV effizient in eine neue DataTable umzuwandeln, ist entscheidend. Indem Sie die erste Zeile als Spaltenüberschriften verwenden, können Sie sicherstellen, dass die Spalten der DataTable mit dem Schema Ihrer Datenbanktabelle übereinstimmen.

Traditionelle Ansätze kämpfen oft mit großen Dateien, unterschiedlichen Trennzeichen oder Speicherverwaltung. IronXL beseitigt diese Herausforderungen und handhabt unterschiedliche Trennzeichen, zitierte Felder und eingebettete Kommas nahtlos. Die CSV-Lesefähigkeiten von IronXL beseitigen diese häufigen Schwachstellen.

Wie installiert man IronXL?

Der Einstieg mit IronXL erfordert nur eine einfache NuGet-Paketinstallation. Öffnen Sie die NuGet Paketmanager-Konsole in Visual Studio und führen Sie aus:

Install-Package IronXL.Excel

Nach der Installation fügen Sie das IronXL-Namespace zu Ihrem Projekt hinzu:

using IronXL;
using System.Data;

using IronXL;
using System.Data;

Imports IronXL
Imports System.Data

Dies ermöglicht den Zugriff auf alle leistungsstarken CSV-Verarbeitungsfunktionen ohne Abhängigkeiten von Excel. Für weitere Details zur umfangreichen API von IronXL, schauen Sie sich die API-Referenzdokumentation an.

Mit NuGet installieren

PM >  Install-Package IronXL.Excel

Schauen Sie sich IronXL auf NuGet für eine schnelle Installation an. Mit über 10 Millionen Downloads transformiert es die PDF-Entwicklung mit C#. Sie können auch das DLL herunterladen.

Wie konvertiert man CSV in DataTable?

Die Schönheit von IronXL liegt in seiner Einfachheit. Hier ist, wie man eine CSV-Datei liest und in eine DataTable umwandelt:

// Load CSV file into a WorkBook object
WorkBook workbook = WorkBook.LoadCSV("sales_data.csv", 
    fileFormat: ExcelFileFormat.XLSX);
// Access the default worksheet
WorkSheet worksheet = workbook.DefaultWorkSheet;
// Convert to DataTable with headers
DataTable dataTable = worksheet.ToDataTable(true);
// Display the data
foreach (DataRow row in dataTable.Rows)
{
    foreach (var item in row.ItemArray)
    {
        Console.Write($"{item}\t");
    }
    Console.WriteLine();
}

// Load CSV file into a WorkBook object
WorkBook workbook = WorkBook.LoadCSV("sales_data.csv", 
    fileFormat: ExcelFileFormat.XLSX);
// Access the default worksheet
WorkSheet worksheet = workbook.DefaultWorkSheet;
// Convert to DataTable with headers
DataTable dataTable = worksheet.ToDataTable(true);
// Display the data
foreach (DataRow row in dataTable.Rows)
{
    foreach (var item in row.ItemArray)
    {
        Console.Write($"{item}\t");
    }
    Console.WriteLine();
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Die LoadCSV-Methode analysiert intelligent Ihre CSV-Datei und handhabt automatisch gängige Fälle wie zitierte Felder und eingebettete Kommas. Der fileFormat-Parameter sagt IronXL, wie die CSV-Daten intern interpretiert werden sollen, und stellt sicher, dass sie als Excel-kompatible Struktur behandelt werden. Einmal geladen, konvertiert die Methode ToDataTable(true) das Arbeitsblatt in eine DataTable, wobei der Parameter true anzeigt, dass die erste Zeile als Spaltenüberschriften verwendet werden soll. Dies führt zu einer sauberen, strukturierten DataTable mit benannten Spalten, die zu Ihren CSV-Überschriften passen. Für weitergehende Manipulationsoptionen, erkunden Sie das komplette Excel-zu-DataTable-Tutorial.

Wie importiert man DataTable in SQL Server?

Sobald Sie Ihre DataTable haben, wird der Import in SQL Server unglaublich effizient mit SqlBulkCopy:

using System.Data;
using Microsoft.Data.SqlClient;
using IronXL;
class Program
{
    static void Main(string[] args)
    {
        // Create connection string
        string connectionString = @"Data Source=localhost;Initial Catalog=SalesDB;
                           Integrated Security=True;TrustServerCertificate=True;";
        // Read CSV into DataTable
        WorkBook workbook = WorkBook.LoadCSV("inventory_report.csv");
        DataTable dataTable = workbook.DefaultWorkSheet.ToDataTable(true);
        // Bulk insert into SQL Server
        using (SqlConnection connection = new SqlConnection(connectionString))
        {
            connection.Open();
            using (SqlBulkCopy bulkCopy = new SqlBulkCopy(connection))
            {
                // Set destination table name
                bulkCopy.DestinationTableName = "dbo.Inventory";
                // Map DataTable columns to SQL table columns
                bulkCopy.ColumnMappings.Add("ProductCode", "product_code");
                bulkCopy.ColumnMappings.Add("Quantity", "quantity");
                bulkCopy.ColumnMappings.Add("LastUpdated", "last_updated");
                // Set batch size for better performance
                bulkCopy.BatchSize = 1000;
                // Write data to SQL Server
                bulkCopy.WriteToServer(dataTable);
            }
        }
        Console.WriteLine($"Successfully imported {dataTable.Rows.Count} records");
    }
}

using System.Data;
using Microsoft.Data.SqlClient;
using IronXL;
class Program
{
    static void Main(string[] args)
    {
        // Create connection string
        string connectionString = @"Data Source=localhost;Initial Catalog=SalesDB;
                           Integrated Security=True;TrustServerCertificate=True;";
        // Read CSV into DataTable
        WorkBook workbook = WorkBook.LoadCSV("inventory_report.csv");
        DataTable dataTable = workbook.DefaultWorkSheet.ToDataTable(true);
        // Bulk insert into SQL Server
        using (SqlConnection connection = new SqlConnection(connectionString))
        {
            connection.Open();
            using (SqlBulkCopy bulkCopy = new SqlBulkCopy(connection))
            {
                // Set destination table name
                bulkCopy.DestinationTableName = "dbo.Inventory";
                // Map DataTable columns to SQL table columns
                bulkCopy.ColumnMappings.Add("ProductCode", "product_code");
                bulkCopy.ColumnMappings.Add("Quantity", "quantity");
                bulkCopy.ColumnMappings.Add("LastUpdated", "last_updated");
                // Set batch size for better performance
                bulkCopy.BatchSize = 1000;
                // Write data to SQL Server
                bulkCopy.WriteToServer(dataTable);
            }
        }
        Console.WriteLine($"Successfully imported {dataTable.Rows.Count} records");
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Die SqlBulkCopy-Klasse bietet außergewöhnliche Leistung für großformatige Datenimporte. Die ColumnMappings-Kollektion erlaubt es, die DataTable-Spalten auf Datenbankspalten mit unterschiedlichen Namen abzubilden, was Flexibilität in Ihrem Datenschema sicherstellt. Die BatchSize-Eigenschaft optimiert die Speichernutzung, indem sie Datensätze in Blöcken verarbeitet anstatt alles auf einmal zu laden. Dieser Ansatz kann Millionen von Datensätzen effizient verarbeiten und ist ideal für unternehmensweite Datenoperationen. Erfahren Sie mehr über die DataSet- und DataTable-Funktionen von IronXL.

Wie handhabt man verschiedene Trennzeichen?

Nicht alle CSV-Dateien verwenden Kommas. IronXL handhabt nahtlos verschiedene Trennzeichen:

using IronXL;
using System;
using System.Data;
using System.IO;
class Program
{
    static void Main()
    {
        // --- Tab-delimited file ---
        string tsvPath = @"export_data.tsv";
        WorkBook tsvWorkbook = WorkBook.LoadCSV(tsvPath, ExcelFileFormat.XLSX, "\t");
        // --- Semicolon-delimited file ---
        string semiPath = @"european_data.csv";
        string tempCsv = Path.Combine(Path.GetTempPath(), "european_data_comma.csv");
        // Replace semicolons with commas for proper parsing
        var lines = File.ReadAllLines(semiPath);
        for (int i = 0; i < lines.Length; i++)
        {
            lines[i] = lines[i].Replace(';', ',');
        }
        File.WriteAllLines(tempCsv, lines);
        WorkBook semiWorkbook = WorkBook.LoadCSV(tempCsv, ExcelFileFormat.XLSX);
        // Print both workbooks
        PrintWorkbook(tsvWorkbook, "Tab-delimited File");
        PrintWorkbook(semiWorkbook, "Semicolon-delimited File");
    }
    static void PrintWorkbook(WorkBook workbook, string name)
    {
        Console.WriteLine($"\n--- {name} ---\n");
        DataTable dt = workbook.DefaultWorkSheet.ToDataTable(true);
        // Print column headers
        foreach (DataColumn col in dt.Columns)
        {
            Console.Write($"{col.ColumnName}\t");
        }
        Console.WriteLine();
        // Print rows
        foreach (DataRow row in dt.Rows)
        {
            foreach (var item in row.ItemArray)
            {
                Console.Write($"{item}\t");
            }
            Console.WriteLine();
        }
    }
}

using IronXL;
using System;
using System.Data;
using System.IO;
class Program
{
    static void Main()
    {
        // --- Tab-delimited file ---
        string tsvPath = @"export_data.tsv";
        WorkBook tsvWorkbook = WorkBook.LoadCSV(tsvPath, ExcelFileFormat.XLSX, "\t");
        // --- Semicolon-delimited file ---
        string semiPath = @"european_data.csv";
        string tempCsv = Path.Combine(Path.GetTempPath(), "european_data_comma.csv");
        // Replace semicolons with commas for proper parsing
        var lines = File.ReadAllLines(semiPath);
        for (int i = 0; i < lines.Length; i++)
        {
            lines[i] = lines[i].Replace(';', ',');
        }
        File.WriteAllLines(tempCsv, lines);
        WorkBook semiWorkbook = WorkBook.LoadCSV(tempCsv, ExcelFileFormat.XLSX);
        // Print both workbooks
        PrintWorkbook(tsvWorkbook, "Tab-delimited File");
        PrintWorkbook(semiWorkbook, "Semicolon-delimited File");
    }
    static void PrintWorkbook(WorkBook workbook, string name)
    {
        Console.WriteLine($"\n--- {name} ---\n");
        DataTable dt = workbook.DefaultWorkSheet.ToDataTable(true);
        // Print column headers
        foreach (DataColumn col in dt.Columns)
        {
            Console.Write($"{col.ColumnName}\t");
        }
        Console.WriteLine();
        // Print rows
        foreach (DataRow row in dt.Rows)
        {
            foreach (var item in row.ItemArray)
            {
                Console.Write($"{item}\t");
            }
            Console.WriteLine();
        }
    }
}

IRON VB CONVERTER ERROR developers@ironsoftware.com

Dieser Code lädt CSV-Dateien mit unterschiedlichen Trennzeichen in IronXL WorkBook-Objekte. Tab-begrenzte Dateien werden mit "\t" als Separator gelesen, während semikolon-begrenzte Dateien vor dem Laden in das Standard-CSV-Format konvertiert werden. Das Standardarbeitsblatt jedes Workbooks wird in eine DataTable mit ToDataTable(true) umgewandelt, wobei die erste Zeile als Spaltenüberschriften verwendet wird.

Die PrintWorkbook-Methode durchläuft dann die DataTable und zeigt die Daten im Konsolenfenster an, einschließlich der Überschriften und aller Zeilen. Diese Flexibilität adressiert viele der häufigen CSV-Analyseherausforderungen, die von Entwicklern diskutiert werden.

Abschluss

IronXL verwandelt die komplexe Aufgabe der CSV-Datenbankimporte in einen einfachen, zuverlässigen Prozess. Mit nur wenigen Zeilen Code können Sie:

• CSV-Dateien aus jedem Dateipfad lesen
• CSV-Daten in eine neue DataTable umwandeln
• Spaltenüberschriften und DataTable-Spalten beibehalten
• Millionen von Zeilen effizient in eine Datenbanktabelle importieren

Die Bibliothek handhabt die Feinheiten der CSV-Analyse, Speicherverwaltung und Datentypumwandlungen automatisch, sodass Sie sich auf Ihre Geschäftslogik statt auf Dateiverarbeitungsdetails konzentrieren können.

Bereit, Ihren Datenimport-Workflow zu optimieren? Starten Sie Ihre kostenlose Testversion, um die perfekte Lösung für die Bedürfnisse Ihres Teams zu finden.