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 einzige Methode übernimmt das Parsen, die Erkennung von Begrenzungszeichen und die Datenorganisation automatisch - ohne die Neintwendigkeit, einen StreamReader zu erstellen oder jede Zeile manuell zu bearbeiten.

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
dotnet add package IronXL

Install-Package IronXL
dotnet add package IronXL

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 Parameter listDelimiter in LoadCSV akzeptiert jedes einzelne Zeichen oder eine Escape-Sequenz als Feldtrenner. Für Tabulatorzeichen wird die Escape-Sequenz \t verwendet. 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?

Die Konvertierung 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 Spaltenüberschriften (true) oder Daten (false) werden soll. Bei der Einstellung true übernehmen die Spalten des resultierenden DataTable die Kopfzeilennamen 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 Methode SaveAs bestimmt automatisch das Ausgabeformat anhand der Dateierweiterung. XLSX erstellt moderne Office Open XML-Dateien, die mit Excel 2007 und höher kompatibel sind, während XLS Legacy Binary Interchange File Format-Dokumente für ältere Anwendungen erstellt.

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 Klasse Cell bietet typspezifische Accessoren, darunter 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 Bereichsauswahl mit einer Neintation wie A2:A10 gibt ein Bereich-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. Die Einbettung von IronXL-Aufrufen in try/catch-Blöcke und die Validierung von Pfaden vor dem Laden sorgen für ein zuverlässiges Verhalten in verschiedenen 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 umfangreiche ETL-Szenarien (Extrahieren, Transformieren, Laden) besteht eine praktische Strategie darin, die CSV-Datei in Stapeln zu verarbeiten, indem die Quelldatei vor dem Laden aufgeteilt wird, oder indem Zeilen aus einem StreamReader gestreamt und Teile davon in separate Arbeitsmappen geschrieben werden.

Die IronXL-Dokumentation zum Lesen von Excel-Dateien behandelt Leistungsaspekte bei großen Datenmengen. Speziell für CSV bedeutet die zeilenweise Struktur des CSV-Formats, dass ein einfaches File.ReadAllLines mit manuellem Stapeln zu einem vorhersehbaren Speicherbedarf führt, wenn der Datensatz zu groß für ein einzelnes Laden in den Speicher 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 bewältigt die Komplexität des Parsings automatisch, unterstützt verschiedene Begrenzungszeichen, bietet sofortigen Zugriff auf strukturierte Daten und konvertiert mit einem einzigen Methodenaufruf in Excel oder DataTable. 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 und erleben Sie selbst, 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.