Lesen von CSV-Dateien in C# mit IronXL

Was ist der einfachste Weg, CSV-Dateien in .NET zu lesen?

Der einfachste Ansatz verwendet WorkBook.LoadCSV , um CSV-Daten direkt in eine Arbeitsmappenstruktur zu importieren. Diese einzelne Methode übernimmt das Parsen, die Trennzeichenerkennung und die Datenorganisation automatisch – es ist nicht erforderlich, ein StreamReader zu erstellen oder jede Zeichenfolgenzeile manuell zu verarbeiten.

Installieren Sie IronXL über die NuGet-Paketmanager-Konsole in Visual Studio. Öffnen Sie Ihr .NET-Projekt und führen Sie es aus:

Install-Package IronXL.Excel

using IronXL;

// Load CSV file into a workbook with one method call
WorkBook workbook = WorkBook.LoadCSV("sales_data.csv", fileFormat: ExcelFileFormat.XLSX, listDelimiter: ",");
// Access the default worksheet containing CSV data
WorkSheet sheet = workbook.DefaultWorkSheet;
// Display all rows and CSV columns
foreach (var row in sheet.Rows)
{
    foreach (var cell in row)
    {
        Console.Write(cell.Value + "\t");
    }
    Console.WriteLine();
}

using IronXL;

// Load CSV file into a workbook with one method call
WorkBook workbook = WorkBook.LoadCSV("sales_data.csv", fileFormat: ExcelFileFormat.XLSX, listDelimiter: ",");
// Access the default worksheet containing CSV data
WorkSheet sheet = workbook.DefaultWorkSheet;
// Display all rows and CSV columns
foreach (var row in sheet.Rows)
{
    foreach (var cell in row)
    {
        Console.Write(cell.Value + "\t");
    }
    Console.WriteLine();
}

Imports IronXL

' Load CSV file into a workbook with one method call
Dim workbook As WorkBook = WorkBook.LoadCSV("sales_data.csv", fileFormat:=ExcelFileFormat.XLSX, listDelimiter:=",")
' Access the default worksheet containing CSV data
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
' Display all rows and CSV columns
For Each row In sheet.Rows
    For Each cell In row
        Console.Write(cell.Value & vbTab)
    Next
    Console.WriteLine()
Next

Wie lässt sich manuelles CSV-Parsing mit der Verwendung einer Bibliothek vergleichen?

Das Verständnis der Komplexität, die IronXL beseitigt, trägt dazu bei, seinen Wert zu verdeutlichen. Das manuelle CSV-Parsing erfordert den Umgang mit mehreren Randfällen, die einfach erscheinen, aber in jedem Projekt schnell problematisch werden.

using System.IO;

// Manual approach -- requires extensive code for basic functionality
string path = "data.csv";
string[] lines = File.ReadAllLines(path);
foreach (string line in lines)
{
    // This breaks when CSV fields contain commas inside quotes
    string[] fields = line.Split(',');
    foreach (string field in fields)
    {
        Console.Write(field.Trim() + "\t");
    }
    Console.WriteLine();
}

using System.IO;

// Manual approach -- requires extensive code for basic functionality
string path = "data.csv";
string[] lines = File.ReadAllLines(path);
foreach (string line in lines)
{
    // This breaks when CSV fields contain commas inside quotes
    string[] fields = line.Split(',');
    foreach (string field in fields)
    {
        Console.Write(field.Trim() + "\t");
    }
    Console.WriteLine();
}

Imports System.IO

' Manual approach -- requires extensive code for basic functionality
Dim path As String = "data.csv"
Dim lines As String() = File.ReadAllLines(path)
For Each line As String In lines
    ' This breaks when CSV fields contain commas inside quotes
    Dim fields As String() = line.Split(","c)
    For Each field As String In fields
        Console.Write(field.Trim() & vbTab)
    Next
    Console.WriteLine()
Next

using IronXL;

// IronXL approach -- handles all edge cases automatically
WorkBook workbook = WorkBook.LoadCSV("data.csv", fileFormat: ExcelFileFormat.XLSX, listDelimiter: ",");
var records = workbook.DefaultWorkSheet.Rows;
foreach (var row in records)
{
    foreach (var cell in row)
    {
        Console.Write(cell.Value + "\t");
    }
    Console.WriteLine();
}

using IronXL;

// IronXL approach -- handles all edge cases automatically
WorkBook workbook = WorkBook.LoadCSV("data.csv", fileFormat: ExcelFileFormat.XLSX, listDelimiter: ",");
var records = workbook.DefaultWorkSheet.Rows;
foreach (var row in records)
{
    foreach (var cell in row)
    {
        Console.Write(cell.Value + "\t");
    }
    Console.WriteLine();
}

Imports IronXL

' IronXL approach -- handles all edge cases automatically
Dim workbook As WorkBook = WorkBook.LoadCSV("data.csv", fileFormat:=ExcelFileFormat.XLSX, listDelimiter:=",")
Dim records = workbook.DefaultWorkSheet.Rows
For Each row In records
    For Each cell In row
        Console.Write(cell.Value & vbTab)
    Next
    Console.WriteLine()
Next

Wie geht man mit unterschiedlichen CSV-Trennzeichen um?

CSV-Dateien verwenden nicht immer Kommas als Trennzeichen. Bei Exporten aus dem europäischen Zahlensystem werden häufig Semikolons verwendet, da Kommas in Dezimalzahlen vorkommen. Tabulatorgetrennte Werte (TSV) und durch Pipes getrennte Dateien kommen regelmäßig bei Datenexporten aus verschiedenen Anwendungen und Altsystemen vor.

using IronXL;

// Reading a semicolon-delimited file (common in European exports)
WorkBook euroData = WorkBook.LoadCSV("german_report.csv", fileFormat: ExcelFileFormat.XLSX, listDelimiter: ";");
// Reading a tab-separated file
WorkBook tsvData = WorkBook.LoadCSV("exported_data.tsv", fileFormat: ExcelFileFormat.XLSX, listDelimiter: "\t");
// Reading a pipe-delimited file
WorkBook pipeData = WorkBook.LoadCSV("legacy_system.csv", fileFormat: ExcelFileFormat.XLSX, listDelimiter: "|");
// Access data identically regardless of original delimiter
WorkSheet sheet = euroData.DefaultWorkSheet;
int rowsCount = sheet.RowCount;
Console.WriteLine($"Loaded {rowsCount} rows with {sheet.ColumnCount} CSV columns");

using IronXL;

// Reading a semicolon-delimited file (common in European exports)
WorkBook euroData = WorkBook.LoadCSV("german_report.csv", fileFormat: ExcelFileFormat.XLSX, listDelimiter: ";");
// Reading a tab-separated file
WorkBook tsvData = WorkBook.LoadCSV("exported_data.tsv", fileFormat: ExcelFileFormat.XLSX, listDelimiter: "\t");
// Reading a pipe-delimited file
WorkBook pipeData = WorkBook.LoadCSV("legacy_system.csv", fileFormat: ExcelFileFormat.XLSX, listDelimiter: "|");
// Access data identically regardless of original delimiter
WorkSheet sheet = euroData.DefaultWorkSheet;
int rowsCount = sheet.RowCount;
Console.WriteLine($"Loaded {rowsCount} rows with {sheet.ColumnCount} CSV columns");

Imports IronXL

' Reading a semicolon-delimited file (common in European exports)
Dim euroData As WorkBook = WorkBook.LoadCSV("german_report.csv", fileFormat:=ExcelFileFormat.XLSX, listDelimiter:=";")
' Reading a tab-separated file
Dim tsvData As WorkBook = WorkBook.LoadCSV("exported_data.tsv", fileFormat:=ExcelFileFormat.XLSX, listDelimiter:=vbTab)
' Reading a pipe-delimited file
Dim pipeData As WorkBook = WorkBook.LoadCSV("legacy_system.csv", fileFormat:=ExcelFileFormat.XLSX, listDelimiter:="|")
' Access data identically regardless of original delimiter
Dim sheet As WorkSheet = euroData.DefaultWorkSheet
Dim rowsCount As Integer = sheet.RowCount
Console.WriteLine($"Loaded {rowsCount} rows with {sheet.ColumnCount} CSV columns")

Der listDelimiter-Parameter in LoadCSV akzeptiert jedes einzelne Zeichen oder jede Escape-Sequenz als Feldtrennzeichen. Tabulatorzeichen verwenden die \t-Escape-Sequenz. Nach dem Laden bleibt die Datenstruktur unabhängig vom Originalformat konsistent, was die Verarbeitung von CSV-Dateien aus verschiedenen Quellen mit unterschiedlichen Begrenzungszeichen erleichtert. Der Standardwert für die meisten CSV-Dateien ist ein Komma, aber diese Flexibilität ermöglicht es, jede im Projekt auftretende Variation zu bewältigen.

Welches sind die besten Methoden zur Konvertierung von CSV in DataTable?

Das Konvertieren von CSV-Daten in ein DataTable ermöglicht die Integration mit Datenbankoperationen, Datenbindung in UI-Anwendungen und LINQ-Abfragen. Die Methode ToDataTable führt diese Konvertierung mit einem einzigen Aufruf durch.

using IronXL;
using System.Data;

// Load CSV and convert to DataTable
WorkBook workbook = WorkBook.LoadCSV("customers.csv", ExcelFileFormat.XLSX, ",");
WorkSheet sheet = workbook.DefaultWorkSheet;
// Convert worksheet to DataTable -- true parameter uses CSV header as column names
DataTable dataTable = sheet.ToDataTable(true);
// DataTable is now ready for database operations, binding, or LINQ queries
Console.WriteLine($"DataTable created with {dataTable.Columns.Count} columns:");
foreach (DataColumn column in dataTable.Columns)
{
    // Property names from CSV header become column names
    Console.WriteLine($"  - {column.ColumnName}");
}
Console.WriteLine($"\nTotal records: {dataTable.Rows.Count}");
// Access data using standard DataTable syntax
foreach (DataRow row in dataTable.Rows)
{
    // Access by column index or name attribute
    string name = row["Name"].ToString();
    string email = row["Email"].ToString();
    Console.WriteLine($"Customer: {name}, Email: {email}");
}

using IronXL;
using System.Data;

// Load CSV and convert to DataTable
WorkBook workbook = WorkBook.LoadCSV("customers.csv", ExcelFileFormat.XLSX, ",");
WorkSheet sheet = workbook.DefaultWorkSheet;
// Convert worksheet to DataTable -- true parameter uses CSV header as column names
DataTable dataTable = sheet.ToDataTable(true);
// DataTable is now ready for database operations, binding, or LINQ queries
Console.WriteLine($"DataTable created with {dataTable.Columns.Count} columns:");
foreach (DataColumn column in dataTable.Columns)
{
    // Property names from CSV header become column names
    Console.WriteLine($"  - {column.ColumnName}");
}
Console.WriteLine($"\nTotal records: {dataTable.Rows.Count}");
// Access data using standard DataTable syntax
foreach (DataRow row in dataTable.Rows)
{
    // Access by column index or name attribute
    string name = row["Name"].ToString();
    string email = row["Email"].ToString();
    Console.WriteLine($"Customer: {name}, Email: {email}");
}

Imports IronXL
Imports System.Data

' Load CSV and convert to DataTable
Dim workbook As WorkBook = WorkBook.LoadCSV("customers.csv", ExcelFileFormat.XLSX, ",")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
' Convert worksheet to DataTable -- true parameter uses CSV header as column names
Dim dataTable As DataTable = sheet.ToDataTable(True)
' DataTable is now ready for database operations, binding, or LINQ queries
Console.WriteLine($"DataTable created with {dataTable.Columns.Count} columns:")
For Each column As DataColumn In dataTable.Columns
    ' Property names from CSV header become column names
    Console.WriteLine($"  - {column.ColumnName}")
Next
Console.WriteLine(vbCrLf & $"Total records: {dataTable.Rows.Count}")
' Access data using standard DataTable syntax
For Each row As DataRow In dataTable.Rows
    ' Access by column index or name attribute
    Dim name As String = row("Name").ToString()
    Dim email As String = row("Email").ToString()
    Console.WriteLine($"Customer: {name}, Email: {email}")
Next

Der boolesche Parameter in ToDataTable bestimmt, ob die erste Zeile zu Spaltenüberschriften (true) oder Daten (false) werden soll. Wenn auf true gesetzt, tragen die Spalten des resultierenden DataTable die Überschriftennamen aus der CSV-Datei, was einen intuitiven Datenzugriff mit Spaltennamen wie row["Name"] ermöglicht.

Wie konvertiert man CSV-Dateien in das Excel-Format?

Eine der herausragenden Fähigkeiten von IronXL ist die Konvertierung von CSV-Daten in geeignete Excel-Formate. Dies ermöglicht das Hinzufügen von Formeln, Formatierungen, Diagrammen und mehreren Arbeitsblättern zu ursprünglich flachen CSV-Daten – etwas, das mit der CSV-Ausgabe allein nicht möglich ist.

using IronXL;

// Load CSV data from file path
string path = "quarterly_sales.csv";
WorkBook workbook = WorkBook.LoadCSV(path, ExcelFileFormat.XLSX, ",");
// Save as Excel XLSX format -- creates a new Excel file
workbook.SaveAs("quarterly_sales.xlsx");
// Alternative: Save as legacy XLS format for older Excel versions
workbook.SaveAs("quarterly_sales.xls");
Console.WriteLine("CSV successfully converted to Excel format");

using IronXL;

// Load CSV data from file path
string path = "quarterly_sales.csv";
WorkBook workbook = WorkBook.LoadCSV(path, ExcelFileFormat.XLSX, ",");
// Save as Excel XLSX format -- creates a new Excel file
workbook.SaveAs("quarterly_sales.xlsx");
// Alternative: Save as legacy XLS format for older Excel versions
workbook.SaveAs("quarterly_sales.xls");
Console.WriteLine("CSV successfully converted to Excel format");

Imports IronXL

' Load CSV data from file path
Dim path As String = "quarterly_sales.csv"
Dim workbook As WorkBook = WorkBook.LoadCSV(path, ExcelFileFormat.XLSX, ","c)
' Save as Excel XLSX format -- creates a new Excel file
workbook.SaveAs("quarterly_sales.xlsx")
' Alternative: Save as legacy XLS format for older Excel versions
workbook.SaveAs("quarterly_sales.xls")
Console.WriteLine("CSV successfully converted to Excel format")

Die SaveAs-Methode bestimmt automatisch das Ausgabeformat basierend auf der Dateiendung. XLSX erstellt moderne Office Open XML-Dateien, die mit Excel 2007 und später kompatibel sind, während XLS ältere Binärdateiformat-Dokumente für ältere Anwendungen erzeugt.

Wie greift man auf bestimmte Zellwerte in CSV-Daten zu?

IronXL kann nicht nur durch alle Datensätze iterieren, sondern bietet auch direkten Zellzugriff über die vertraute Adressierung im Excel-Stil. Dies ermöglicht eine gezielte Datenextraktion und einen typsicheren Abruf von Werten über verschiedene Datentypen hinweg.

using IronXL;

WorkBook workbook = WorkBook.LoadCSV("inventory.csv", ExcelFileFormat.XLSX, ",");
WorkSheet sheet = workbook.DefaultWorkSheet;
// Access specific cells using Excel-style addresses by index
string productName = sheet["A2"].StringValue;
int quantity = sheet["B2"].IntValue;
decimal price = sheet["C2"].DecimalValue;
Console.WriteLine($"Product: {productName}");
Console.WriteLine($"Quantity: {quantity}");
Console.WriteLine($"Price: ${price:F2}");
// Access a range of cells -- return records from column A
var productRange = sheet["A2:A10"];
Console.WriteLine("\nAll products:");
foreach (var cell in productRange)
{
    Console.WriteLine($"  - {cell.StringValue}");
}

using IronXL;

WorkBook workbook = WorkBook.LoadCSV("inventory.csv", ExcelFileFormat.XLSX, ",");
WorkSheet sheet = workbook.DefaultWorkSheet;
// Access specific cells using Excel-style addresses by index
string productName = sheet["A2"].StringValue;
int quantity = sheet["B2"].IntValue;
decimal price = sheet["C2"].DecimalValue;
Console.WriteLine($"Product: {productName}");
Console.WriteLine($"Quantity: {quantity}");
Console.WriteLine($"Price: ${price:F2}");
// Access a range of cells -- return records from column A
var productRange = sheet["A2:A10"];
Console.WriteLine("\nAll products:");
foreach (var cell in productRange)
{
    Console.WriteLine($"  - {cell.StringValue}");
}

Imports IronXL

Dim workbook As WorkBook = WorkBook.LoadCSV("inventory.csv", ExcelFileFormat.XLSX, ",")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
' Access specific cells using Excel-style addresses by index
Dim productName As String = sheet("A2").StringValue
Dim quantity As Integer = sheet("B2").IntValue
Dim price As Decimal = sheet("C2").DecimalValue
Console.WriteLine($"Product: {productName}")
Console.WriteLine($"Quantity: {quantity}")
Console.WriteLine($"Price: ${price:F2}")
' Access a range of cells -- return records from column A
Dim productRange = sheet("A2:A10")
Console.WriteLine(vbCrLf & "All products:")
For Each cell In productRange
    Console.WriteLine($"  - {cell.StringValue}")
Next

Die Adressierung der Zellen folgt den Konventionen von Excel, wobei Buchstaben für CSV-Spalten (A, B, C) und Zahlen für Zeilenindexpositionen (1, 2, 3) stehen. Die Cell-Klasse bietet typenspezifische Zugriffe, einschließlich StringValue, IntValue, DecimalValue, BoolValue und DateTimeValue. Diese Zugriffsmethoden übernehmen das Parsen und die Konvertierung automatisch, wodurch die manuelle Typumwandlung im Vergleich zur Speicherung aller Werte als Zeichenketten entfällt.

Die Auswahl eines Bereichs mit Neintationen wie A2:A10 gibt ein Range-Objekt zurück, das Iteration, Aggregatfunktionen und Massenoperationen unterstützt. Dies erweist sich beim Extrahieren bestimmter Spalten oder rechteckiger Datenbereiche aus großen CSV-Dateien als nützlich. Sie können beispielsweise eine Liste von Werten aus einer bestimmten Spalte erstellen oder gefilterte Daten in eine andere Datei schreiben. Weitere Beispiele finden Sie im IronXL Bereichsleitfaden .

Wie geht man mit Fehlern beim Lesen von CSV-Dateien um?

Produktionsanwendungen benötigen defensiven Code für Dateivorgänge. Das Einlesen von CSV-Dateien kann aus verschiedenen Gründen fehlschlagen: Die Datei existiert nicht, der Zugriff wird verweigert, die Daten sind fehlerhaft oder der Speicherplatz reicht für sehr große Dateien nicht aus. Das Einpacken von IronXL-Aufrufen in try/catch-Blöcke und das Validieren von Pfaden vor dem Laden gewährleistet zuverlässiges Verhalten in allen Umgebungen.

using IronXL;
using System.IO;

string filePath = "customers.csv";
if (!File.Exists(filePath))
{
    Console.WriteLine($"File not found: {filePath}");
    return;
}
try
{
    WorkBook workbook = WorkBook.LoadCSV(filePath, ExcelFileFormat.XLSX, ",");
    WorkSheet sheet = workbook.DefaultWorkSheet;
    DataTable dataTable = sheet.ToDataTable(true);
    Console.WriteLine($"Loaded {dataTable.Rows.Count} records successfully.");
}
catch (IronXL.Exceptions.IronXLException ex)
{
    Console.WriteLine($"IronXL parsing error: {ex.Message}");
}
catch (IOException ex)
{
    Console.WriteLine($"File access error: {ex.Message}");
}
catch (Exception ex)
{
    Console.WriteLine($"Unexpected error: {ex.Message}");
}

using IronXL;
using System.IO;

string filePath = "customers.csv";
if (!File.Exists(filePath))
{
    Console.WriteLine($"File not found: {filePath}");
    return;
}
try
{
    WorkBook workbook = WorkBook.LoadCSV(filePath, ExcelFileFormat.XLSX, ",");
    WorkSheet sheet = workbook.DefaultWorkSheet;
    DataTable dataTable = sheet.ToDataTable(true);
    Console.WriteLine($"Loaded {dataTable.Rows.Count} records successfully.");
}
catch (IronXL.Exceptions.IronXLException ex)
{
    Console.WriteLine($"IronXL parsing error: {ex.Message}");
}
catch (IOException ex)
{
    Console.WriteLine($"File access error: {ex.Message}");
}
catch (Exception ex)
{
    Console.WriteLine($"Unexpected error: {ex.Message}");
}

Imports IronXL
Imports System.IO

Dim filePath As String = "customers.csv"
If Not File.Exists(filePath) Then
    Console.WriteLine($"File not found: {filePath}")
    Return
End If

Try
    Dim workbook As WorkBook = WorkBook.LoadCSV(filePath, ExcelFileFormat.XLSX, ",")
    Dim sheet As WorkSheet = workbook.DefaultWorkSheet
    Dim dataTable As DataTable = sheet.ToDataTable(True)
    Console.WriteLine($"Loaded {dataTable.Rows.Count} records successfully.")
Catch ex As IronXL.Exceptions.IronXLException
    Console.WriteLine($"IronXL parsing error: {ex.Message}")
Catch ex As IOException
    Console.WriteLine($"File access error: {ex.Message}")
Catch ex As Exception
    Console.WriteLine($"Unexpected error: {ex.Message}")
End Try

Wie liest man große CSV-Dateien ohne Speicherprobleme?

Bei Dateien mit Hunderttausenden von Zeilen kann es unpraktisch sein, den gesamten Datensatz auf einmal in den Speicher zu laden. IronXL liest die gesamte Datei in ein WorkBook-Objekt, das alle Daten im Speicher hält. Für groß angelegte ETL-Szenarien (Extrahieren, Transformieren, Laden) ist es eine praktische Strategie, die CSV in Batches zu verarbeiten, indem die Quelldatei vor dem Laden aufgeteilt oder Zeilen aus einem StreamReader gestreamt und in separate Arbeitsmappen geschrieben werden.

Die IronXL-Dokumentation zum Lesen von Excel-Dateien behandelt Leistungsaspekte bei großen Datenmengen. Für CSV speziell bedeutet die zeilenweise Struktur des CSV-Formats, dass ein einfacher File.ReadAllLines mit manueller Batch-Verarbeitung eine vorhersehbare Speicherverwendung bietet, wenn der Datensatz zu groß für eine einzige In-Memory-Beladung ist.

Was sind Ihre nächsten Schritte?

Das Lesen von CSV-Dateien in .NET erfordert nur minimalen Aufwand, wenn der richtige Ansatz gewählt wird. Die LoadCSV-Methode von IronXL handhabt die Parsing-Komplexität automatisch, unterstützt verschiedene Trennzeichen, bietet sofortigen Zugriff auf strukturierte Daten und konvertiert in Excel oder DataTable mit einzelnen Methodenaufrufen. Egal ob Sie eine ASP.NET Core Anwendung, eine .NET Core Web-API oder ein Konsolenprojekt erstellen, die Bibliothek vereinfacht die CSV-Verarbeitung von Anfang bis Ende.

Entdecken Sie weitere Funktionen von IronXL , um Ihr hier erworbenes Wissen zu erweitern:

• IronXL -Produktseite – vollständige Funktionsliste und Lizenzinformationen
• Wie man Excel-Dateien in C# liest – Erweiterung der CSV-Kenntnisse auf XLSX/XLS
• Wie man Excel-Dateien in C# schreibt – Tabellenkalkulationen programmgesteuert erstellen und exportieren
• DataTable- und DataSet-Export – Verbindung zu ADO .NET -Workflows
• IronXL Lizenzierung – Lizenzierungsoptionen für die Bereitstellung

Starten Sie eine kostenlose Testversion, um zu erleben, wie IronXL das Lesen von CSV-Dateien in Ihren .NET-Projekten vereinfacht. Für den Produktionseinsatz beinhalten die Lizenzoptionen unbefristete Nutzungsrechte und ein Jahr Support.