C# CSV-Datei-Reader: CSV-Daten mit IronXL parsen und verarbeiten

Wie installiert man IronXL zum Einlesen von CSV-Dateien?

Die Integration von IronXL in Ihr Projekt dauert nur einen Augenblick. Sie können es über den NuGet -Paket-Manager in Visual Studio oder über die Befehlszeile mit der .NET CLI oder der NuGet -Paket-Manager-Konsole in PowerShell installieren. Beide Ansätze installieren dasselbe Paket und funktionieren mit jedem .NET 10-Projekttyp.

# .NET CLI
dotnet add package IronXL.Excel

# NuGet Package Manager Console
Install-Package IronXL.Excel

# .NET CLI
dotnet add package IronXL.Excel

# NuGet Package Manager Console
Install-Package IronXL.Excel

Weitere Informationen zu Installationsoptionen und Konfiguration finden Sie in der IronXL-Installationsdokumentation.

Nach der Installation ist zum Einlesen der ersten CSV-Datei nur sehr wenig Code erforderlich. Das folgende Beispiel verwendet .NET 10 Top-Level-Anweisungen:

using IronXL;

// Load CSV file
WorkBook workbook = WorkBook.LoadCSV("data.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;

// Read a specific cell
string cellValue = sheet["A1"].StringValue;

// Iterate through all rows and cells
foreach (var row in sheet.Rows)
{
    foreach (var cell in row)
    {
        Console.WriteLine(cell.StringValue);
    }
}

using IronXL;

// Load CSV file
WorkBook workbook = WorkBook.LoadCSV("data.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;

// Read a specific cell
string cellValue = sheet["A1"].StringValue;

// Iterate through all rows and cells
foreach (var row in sheet.Rows)
{
    foreach (var cell in row)
    {
        Console.WriteLine(cell.StringValue);
    }
}

Imports IronXL

' Load CSV file
Dim workbook As WorkBook = WorkBook.LoadCSV("data.csv")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet

' Read a specific cell
Dim cellValue As String = sheet("A1").StringValue

' Iterate through all rows and cells
For Each row In sheet.Rows
    For Each cell In row
        Console.WriteLine(cell.StringValue)
    Next
Next

Die WorkBook.LoadCSV-Methode übernimmt die Header-Identifikation, erstellt eine interne Datenstruktur und führt ein speichereffizientes Parsing durch, was die Datenverwaltung von der ersten Codezeile an vereinfacht.

Wie liest man CSV-Dateien mit benutzerdefinierten Trennzeichen?

In realen CSV-Dateien werden nicht immer Kommas verwendet. Strichpunkte, Rohrs und Registerkartes sind häufige Alternativen, insbesondere in internationalen Datensätzen, in denen Kommas als Dezimaltrenner dienen. IronXL kann dank seiner flexiblen Ladeoptionen jedes Trennzeichen verarbeiten.

using IronXL;

// Load CSV with semicolon delimiter (common in European data exports)
WorkBook workbook = WorkBook.LoadCSV("european-data.csv",
    fileFormat: ExcelFileFormat.XLSX,
    listTrennzeichen: ";");

// Load tab-separated values (TSV)
WorkBook tsvWorkbook = WorkBook.LoadCSV("export_data.tsv",
    fileFormat: ExcelFileFormat.XLSX,
    listTrennzeichen: "\t");

// Load pipe-delimited file
WorkBook pipeWorkbook = WorkBook.LoadCSV("log_export.csv",
    fileFormat: ExcelFileFormat.XLSX,
    listTrennzeichen: "|");

// Access data normally after loading
WorkSheet sheet = workbook.DefaultWorkSheet;
decimal totalSales = sheet["B2:B10"].Sum();

Console.WriteLine($"Total sales: {totalSales}");

using IronXL;

// Load CSV with semicolon delimiter (common in European data exports)
WorkBook workbook = WorkBook.LoadCSV("european-data.csv",
    fileFormat: ExcelFileFormat.XLSX,
    listTrennzeichen: ";");

// Load tab-separated values (TSV)
WorkBook tsvWorkbook = WorkBook.LoadCSV("export_data.tsv",
    fileFormat: ExcelFileFormat.XLSX,
    listTrennzeichen: "\t");

// Load pipe-delimited file
WorkBook pipeWorkbook = WorkBook.LoadCSV("log_export.csv",
    fileFormat: ExcelFileFormat.XLSX,
    listTrennzeichen: "|");

// Access data normally after loading
WorkSheet sheet = workbook.DefaultWorkSheet;
decimal totalSales = sheet["B2:B10"].Sum();

Console.WriteLine($"Total sales: {totalSales}");

Imports IronXL

' Load CSV with semicolon delimiter (common in European data exports)
Dim workbook As WorkBook = WorkBook.LoadCSV("european-data.csv", fileFormat:=ExcelFileFormat.XLSX, listTrennzeichen:=";")

' Load tab-separated values (TSV)
Dim tsvWorkbook As WorkBook = WorkBook.LoadCSV("export_data.tsv", fileFormat:=ExcelFileFormat.XLSX, listTrennzeichen:=vbTab)

' Load pipe-delimited file
Dim pipeWorkbook As WorkBook = WorkBook.LoadCSV("log_export.csv", fileFormat:=ExcelFileFormat.XLSX, listTrennzeichen:="|")

' Access data normally after loading
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
Dim totalSales As Decimal = sheet("B2:B10").Sum()

Console.WriteLine($"Total sales: {totalSales}")

Der Parameter listTrennzeichen akzeptiert eine beliebige Zeichenkette und gibt Ihnen die vollständige Kontrolle über das Parsing-Verhalten. IronXL behält Spaltenwerte und Datentypen während des Parsens bei - numerische Werte bleiben Zahlen, Datumsangaben bleiben als DateTime-Objekte erhalten, und Formeln behalten ihre Beziehungen bei.

Bei Dateien mit inkonsistenter Formatierung behebt die Fehlerbehandlung von IronXL fehlerhafte Zeilen, ohne die Anwendung zum Absturz zu bringen, sodass gültige Daten weiterhin verarbeitet werden, selbst wenn einzelne Zeilen problematisch sind.

Wie parst man CSV-Daten in C#-Objekte?

Die Umwandlung von CSV-Zeilen in stark typisierte Objekte vereinfacht die Datenverarbeitung und ermöglicht LINQ-Operationen. IronXL macht diese Zuordnung durch seine Zellzugriffsmethoden einfach. Der folgende Code veranschaulicht, wie man eine CSV-Datei mithilfe von .NET 10-Anweisungen auf oberster Ebene in eine Liste typisierter Objekte abbildet:

using IronXL;

// Define a typed model matching your CSV structure
public record Product(string Name, decimal Price, int Stock, DateTime? LastUpdated);

// Load and parse CSV file
WorkBook workbook = WorkBook.LoadCSV("inventory.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;

var products = new List<Product>();

// Start from row 2 to skip the header row
for (int row = 2; row <= sheet.RowCount; row++)
{
    products.Add(new Product(
        Name: sheet[$"A{row}"].StringValue,
        Price: sheet[$"B{row}"].DecimalValue,
        Stock: sheet[$"C{row}"].IntValue,
        LastUpdated: sheet[$"D{row}"].DateTimeValue
    ));
}

// Use LINQ for analysis after loading
var lowStock = products.Where(p => p.Stock < 10).ToList();
var highValue = products.Where(p => p.Price > 100m).OrderByDescending(p => p.Price).ToList();

Console.WriteLine($"Products with low stock: {lowStock.Count}");
Console.WriteLine($"High-value products: {highValue.Count}");

using IronXL;

// Define a typed model matching your CSV structure
public record Product(string Name, decimal Price, int Stock, DateTime? LastUpdated);

// Load and parse CSV file
WorkBook workbook = WorkBook.LoadCSV("inventory.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;

var products = new List<Product>();

// Start from row 2 to skip the header row
for (int row = 2; row <= sheet.RowCount; row++)
{
    products.Add(new Product(
        Name: sheet[$"A{row}"].StringValue,
        Price: sheet[$"B{row}"].DecimalValue,
        Stock: sheet[$"C{row}"].IntValue,
        LastUpdated: sheet[$"D{row}"].DateTimeValue
    ));
}

// Use LINQ for analysis after loading
var lowStock = products.Where(p => p.Stock < 10).ToList();
var highValue = products.Where(p => p.Price > 100m).OrderByDescending(p => p.Price).ToList();

Console.WriteLine($"Products with low stock: {lowStock.Count}");
Console.WriteLine($"High-value products: {highValue.Count}");

Imports IronXL

' Define a typed model matching your CSV structure
Public Class Product
    Public Property Name As String
    Public Property Price As Decimal
    Public Property Stock As Integer
    Public Property LastUpdated As DateTime?

    Public Sub New(name As String, price As Decimal, stock As Integer, lastUpdated As DateTime?)
        Me.Name = name
        Me.Price = price
        Me.Stock = stock
        Me.LastUpdated = lastUpdated
    End Sub
End Class

' Load and parse CSV file
Dim workbook As WorkBook = WorkBook.LoadCSV("inventory.csv")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet

Dim products As New List(Of Product)()

' Start from row 2 to skip the header row
For row As Integer = 2 To sheet.RowCount
    products.Add(New Product(
        Name:=sheet($"A{row}").StringValue,
        Price:=sheet($"B{row}").DecimalValue,
        Stock:=sheet($"C{row}").IntValue,
        LastUpdated:=sheet($"D{row}").DateTimeValue
    ))
Next

' Use LINQ for analysis after loading
Dim lowStock = products.Where(Function(p) p.Stock < 10).ToList()
Dim highValue = products.Where(Function(p) p.Price > 100D).OrderByDescending(Function(p) p.Price).ToList()

Console.WriteLine($"Products with low stock: {lowStock.Count}")
Console.WriteLine($"High-value products: {highValue.Count}")

Die typisierten Werteigenschaften von IronXL - StringValue, DecimalValue, IntValue, DateTimeValue - verarbeiten Konvertierungen sicher und geben bei ungültigen Daten Standardwerte zurück, anstatt Ausnahmen zu erzeugen. Dieser defensive Ansatz stellt sicher, dass Anwendungen fehlerhafte Daten ohne Unterbrechung verarbeiten können. Es harmoniert hervorragend mit den C#-Datensatztypen , die in C# 9 eingeführt wurden und ein prägnantes, unveränderliches Datenmodell für zugeordnete CSV-Zeilen bieten.

Die IronXL -Funktionsseite bietet einen vollständigen Überblick über die verfügbaren Wertzugriffstypen zum Lesen von Zelldaten.

using IronXL;

WorkBook workbook = WorkBook.LoadCSV("sales-data.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;

// Read entire columns using range notation
var productNames = sheet["A2:A100"]
    .Select(cell => cell.StringValue)
    .Where(name => !string.IsNullOrEmpty(name))
    .ToList();

// Aggregate numeric columns directly
decimal totalRevenue = sheet["C2:C100"].Sum();
decimal averageOrder = sheet["C2:C100"].Avg();

Console.WriteLine($"Products loaded: {productNames.Count}");
Console.WriteLine($"Total revenue: {totalRevenue:C}");
Console.WriteLine($"Average order value: {averageOrder:C}");

using IronXL;

WorkBook workbook = WorkBook.LoadCSV("sales-data.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;

// Read entire columns using range notation
var productNames = sheet["A2:A100"]
    .Select(cell => cell.StringValue)
    .Where(name => !string.IsNullOrEmpty(name))
    .ToList();

// Aggregate numeric columns directly
decimal totalRevenue = sheet["C2:C100"].Sum();
decimal averageOrder = sheet["C2:C100"].Avg();

Console.WriteLine($"Products loaded: {productNames.Count}");
Console.WriteLine($"Total revenue: {totalRevenue:C}");
Console.WriteLine($"Average order value: {averageOrder:C}");

Imports IronXL

Dim workbook As WorkBook = WorkBook.LoadCSV("sales-data.csv")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet

' Read entire columns using range notation
Dim productNames = sheet("A2:A100") _
    .Select(Function(cell) cell.StringValue) _
    .Where(Function(name) Not String.IsNullOrEmpty(name)) _
    .ToList()

' Aggregate numeric columns directly
Dim totalRevenue As Decimal = sheet("C2:C100").Sum()
Dim averageOrder As Decimal = sheet("C2:C100").Avg()

Console.WriteLine($"Products loaded: {productNames.Count}")
Console.WriteLine($"Total revenue: {totalRevenue:C}")
Console.WriteLine($"Average order value: {averageOrder:C}")

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

Viele Geschäftsprozesse erfordern CSV-Daten im Excel-Format für weiterführende Analysen, Formatierungen oder die Verteilung. IronXL macht diese Konvertierung einfach und gewährleistet dabei die vollständige Datenintegrität.

using IronXL;

// Load CSV file
WorkBook csvWorkbook = WorkBook.LoadCSV("monthly-report.csv");
WorkSheet sheet = csvWorkbook.DefaultWorkSheet;

// Apply formatting before saving
sheet["A1:D1"].Style.Font.Bold = true;
sheet["A1:D1"].Style.BackgroundColor = "#4472C4";
sheet["A1:D1"].Style.Font.Color = "#FFFFFF";

// Apply currency format to price column
sheet["B2:B1000"].FormatString = "$#,##0.00";

// Apply date format to date column
sheet["D2:D1000"].FormatString = "yyyy-MM-dd";

// Save as Excel with a single method call
csvWorkbook.SaveAs("monthly-report.xlsx");

Console.WriteLine("Conversion complete: monthly-report.xlsx");

using IronXL;

// Load CSV file
WorkBook csvWorkbook = WorkBook.LoadCSV("monthly-report.csv");
WorkSheet sheet = csvWorkbook.DefaultWorkSheet;

// Apply formatting before saving
sheet["A1:D1"].Style.Font.Bold = true;
sheet["A1:D1"].Style.BackgroundColor = "#4472C4";
sheet["A1:D1"].Style.Font.Color = "#FFFFFF";

// Apply currency format to price column
sheet["B2:B1000"].FormatString = "$#,##0.00";

// Apply date format to date column
sheet["D2:D1000"].FormatString = "yyyy-MM-dd";

// Save as Excel with a single method call
csvWorkbook.SaveAs("monthly-report.xlsx");

Console.WriteLine("Conversion complete: monthly-report.xlsx");

Imports IronXL

' Load CSV file
Dim csvWorkbook As WorkBook = WorkBook.LoadCSV("monthly-report.csv")
Dim sheet As WorkSheet = csvWorkbook.DefaultWorkSheet

' Apply formatting before saving
sheet("A1:D1").Style.Font.Bold = True
sheet("A1:D1").Style.BackgroundColor = "#4472C4"
sheet("A1:D1").Style.Font.Color = "#FFFFFF"

' Apply currency format to price column
sheet("B2:B1000").FormatString = "$#,##0.00"

' Apply date format to date column
sheet("D2:D1000").FormatString = "yyyy-MM-dd"

' Save as Excel with a single method call
csvWorkbook.SaveAs("monthly-report.xlsx")

Console.WriteLine("Conversion complete: monthly-report.xlsx")

Die Konvertierung bewahrt numerische Genauigkeit, Datumsformate und Sonderzeichen, die oft Probleme bei manuellen Konvertierungsmethoden verursachen. IronXL optimiert automatisch die resultierende Excel-Dateistruktur und erstellt effiziente Dateien, die selbst bei großen Datensätzen schnell geöffnet werden.

Für zusätzliche Kontrolle über das Ausgabeformat behandelt die Export-Anleitung Optionen wie den Export in XLSX, XLS, CSV und PDF. Sie können auch lernen, wie man Excel-Dateien schreibt und Excel-Dateien von Grund auf neu erstellt.

using IronXL;
using System.Data;

WorkBook workbook = WorkBook.LoadCSV("customer-export.csv");

// Convert entire workbook to DataSet
DataSet dataSet = workbook.ToDataSet();

// The first sheet becomes the first DataRegisterkartele
DataRegisterkartele customerRegisterkartele = dataSet.Registerkarteles[0];

Console.WriteLine($"Rows loaded: {customerRegisterkartele.Rows.Count}");
Console.WriteLine($"Columns: {customerRegisterkartele.Columns.Count}");

// Process with standard ADO.NET
foreach (DataRow row in customerRegisterkartele.Rows)
{
    string name = row["Name"]?.ToString() ?? string.Empty;
    string email = row["Email"]?.ToString() ?? string.Empty;
    Console.WriteLine($"Customer: {name} <{email}>");
}

using IronXL;
using System.Data;

WorkBook workbook = WorkBook.LoadCSV("customer-export.csv");

// Convert entire workbook to DataSet
DataSet dataSet = workbook.ToDataSet();

// The first sheet becomes the first DataRegisterkartele
DataRegisterkartele customerRegisterkartele = dataSet.Registerkarteles[0];

Console.WriteLine($"Rows loaded: {customerRegisterkartele.Rows.Count}");
Console.WriteLine($"Columns: {customerRegisterkartele.Columns.Count}");

// Process with standard ADO.NET
foreach (DataRow row in customerRegisterkartele.Rows)
{
    string name = row["Name"]?.ToString() ?? string.Empty;
    string email = row["Email"]?.ToString() ?? string.Empty;
    Console.WriteLine($"Customer: {name} <{email}>");
}

Imports IronXL
Imports System.Data

Dim workbook As WorkBook = WorkBook.LoadCSV("customer-export.csv")

' Convert entire workbook to DataSet
Dim dataSet As DataSet = workbook.ToDataSet()

' The first sheet becomes the first DataTable
Dim customerTable As DataTable = dataSet.Tables(0)

Console.WriteLine($"Rows loaded: {customerTable.Rows.Count}")
Console.WriteLine($"Columns: {customerTable.Columns.Count}")

' Process with standard ADO.NET
For Each row As DataRow In customerTable.Rows
    Dim name As String = If(row("Name")?.ToString(), String.Empty)
    Dim email As String = If(row("Email")?.ToString(), String.Empty)
    Console.WriteLine($"Customer: {name} <{email}>")
Next

Wie geht man mit großen CSV-Dateien um und wie optimiert man die Performance?

Die Verarbeitung großer CSV-Dateien – zehntausender Zeilen oder mehr – erfordert besondere Aufmerksamkeit hinsichtlich des Datenzugriffs und der Speicherverwaltung. IronXL beinhaltet Funktionen, die bei der Verarbeitung großer Dateien hilfreich sind.

using IronXL;

WorkBook workbook = WorkBook.LoadCSV("large-dataset.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;

int rowCount = sheet.RowCount;
int colCount = sheet.ColumnCount;

Console.WriteLine($"Dataset dimensions: {rowCount} rows x {colCount} columns");

// Efficient: read entire range at once
var allData = sheet[$"A1:{GetColumnLetter(colCount)}{rowCount}"]
    .Select(cell => cell.StringValue)
    .ToList();

// Efficient: aggregate a column without row-by-row iteration
decimal columnSum = sheet[$"B2:B{rowCount}"].Sum();

Console.WriteLine($"Column B total: {columnSum}");

static string GetColumnLetter(int col)
{
    string result = string.Empty;
    while (col > 0)
    {
        col--;
        result = (char)('A' + col % 26) + result;
        col /= 26;
    }
    return result;
}

using IronXL;

WorkBook workbook = WorkBook.LoadCSV("large-dataset.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;

int rowCount = sheet.RowCount;
int colCount = sheet.ColumnCount;

Console.WriteLine($"Dataset dimensions: {rowCount} rows x {colCount} columns");

// Efficient: read entire range at once
var allData = sheet[$"A1:{GetColumnLetter(colCount)}{rowCount}"]
    .Select(cell => cell.StringValue)
    .ToList();

// Efficient: aggregate a column without row-by-row iteration
decimal columnSum = sheet[$"B2:B{rowCount}"].Sum();

Console.WriteLine($"Column B total: {columnSum}");

static string GetColumnLetter(int col)
{
    string result = string.Empty;
    while (col > 0)
    {
        col--;
        result = (char)('A' + col % 26) + result;
        col /= 26;
    }
    return result;
}

Imports IronXL

Dim workbook As WorkBook = WorkBook.LoadCSV("large-dataset.csv")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet

Dim rowCount As Integer = sheet.RowCount
Dim colCount As Integer = sheet.ColumnCount

Console.WriteLine($"Dataset dimensions: {rowCount} rows x {colCount} columns")

' Efficient: read entire range at once
Dim allData = sheet($"A1:{GetColumnLetter(colCount)}{rowCount}") _
    .Select(Function(cell) cell.StringValue) _
    .ToList()

' Efficient: aggregate a column without row-by-row iteration
Dim columnSum As Decimal = sheet($"B2:B{rowCount}").Sum()

Console.WriteLine($"Column B total: {columnSum}")

Private Shared Function GetColumnLetter(col As Integer) As String
    Dim result As String = String.Empty
    While col > 0
        col -= 1
        result = ChrW(AscW("A"c) + col Mod 26) & result
        col \= 26
    End While
    Return result
End Function

using IronXL;

string filePath = "user-uploaded-data.csv";

try
{
    WorkBook workbook = WorkBook.LoadCSV(filePath);
    WorkSheet sheet = workbook.DefaultWorkSheet;

    Console.WriteLine($"Loaded {sheet.RowCount} rows from {filePath}");

    for (int row = 2; row <= sheet.RowCount; row++)
    {
        string value = sheet[$"A{row}"].StringValue;
        if (!string.IsNullOrWhiteSpace(value))
        {
            Console.WriteLine(value);
        }
    }
}
catch (IronXL.Exceptions.IronXLException ex)
{
    Console.WriteLine($"IronXL error reading {filePath}: {ex.Message}");
}
catch (IOException ex)
{
    Console.WriteLine($"File access error: {ex.Message}");
}

using IronXL;

string filePath = "user-uploaded-data.csv";

try
{
    WorkBook workbook = WorkBook.LoadCSV(filePath);
    WorkSheet sheet = workbook.DefaultWorkSheet;

    Console.WriteLine($"Loaded {sheet.RowCount} rows from {filePath}");

    for (int row = 2; row <= sheet.RowCount; row++)
    {
        string value = sheet[$"A{row}"].StringValue;
        if (!string.IsNullOrWhiteSpace(value))
        {
            Console.WriteLine(value);
        }
    }
}
catch (IronXL.Exceptions.IronXLException ex)
{
    Console.WriteLine($"IronXL error reading {filePath}: {ex.Message}");
}
catch (IOException ex)
{
    Console.WriteLine($"File access error: {ex.Message}");
}

Imports IronXL

Module Module1
    Sub Main()
        Dim filePath As String = "user-uploaded-data.csv"

        Try
            Dim workbook As WorkBook = WorkBook.LoadCSV(filePath)
            Dim sheet As WorkSheet = workbook.DefaultWorkSheet

            Console.WriteLine($"Loaded {sheet.RowCount} rows from {filePath}")

            For row As Integer = 2 To sheet.RowCount
                Dim value As String = sheet($"A{row}").StringValue
                If Not String.IsNullOrWhiteSpace(value) Then
                    Console.WriteLine(value)
                End If
            Next
        Catch ex As IronXL.Exceptions.IronXLException
            Console.WriteLine($"IronXL error reading {filePath}: {ex.Message}")
        Catch ex As IOException
            Console.WriteLine($"File access error: {ex.Message}")
        End Try
    End Sub
End Module

Wie erhält man eine Lizenz für IronXL?

Für den Einsatz in Produktionsumgebungen benötigt IronXL einen Lizenzschlüssel . Für Evaluierungszwecke steht eine kostenlose Testlizenz zur Verfügung, und kommerzielle Lizenzen sind für einzelne Entwickler, Teams und Organisationen erhältlich.

Wenden Sie den Lizenzschlüssel in Ihrer Anwendung an, bevor Sie IronXL Aufrufe tätigen:

using IronXL;

// Apply license key at application startup
IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";

// Verify the license is active
if (IronXL.License.IsValidLicense("YOUR-LICENSE-KEY-HERE"))
{
    Console.WriteLine("IronXL license is active.");
}

// Now use IronXL normally
WorkBook workbook = WorkBook.LoadCSV("data.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;
Console.WriteLine($"Loaded {sheet.RowCount} rows.");

using IronXL;

// Apply license key at application startup
IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";

// Verify the license is active
if (IronXL.License.IsValidLicense("YOUR-LICENSE-KEY-HERE"))
{
    Console.WriteLine("IronXL license is active.");
}

// Now use IronXL normally
WorkBook workbook = WorkBook.LoadCSV("data.csv");
WorkSheet sheet = workbook.DefaultWorkSheet;
Console.WriteLine($"Loaded {sheet.RowCount} rows.");

Imports IronXL

' Apply license key at application startup
IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"

' Verify the license is active
If IronXL.License.IsValidLicense("YOUR-LICENSE-KEY-HERE") Then
    Console.WriteLine("IronXL license is active.")
End If

' Now use IronXL normally
Dim workbook As WorkBook = WorkBook.LoadCSV("data.csv")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
Console.WriteLine($"Loaded {sheet.RowCount} rows.")

Informationen zu Testversionen und Lizenzoptionen finden Sie auf der IronXL -Lizenzseite .

Warum ist IronXL die richtige Wahl für die CSV-Verarbeitung?

IronXL macht das Einlesen von C#-CSV-Dateien von einer mühsamen Parsing-Aufgabe zu einem unkomplizierten Vorgang. Die Bibliothek kümmert sich um die häufig auftretenden Sonderfälle, bei denen die manuelle Analyse Fehler macht – eingebettete Kommas, Zeilenumbrüche innerhalb von Anführungszeichen, inkonsistente Trennzeichen, Kodierungsvariationen und fehlerhafte Zeilen – ohne dass für jedes Szenario benutzerdefinierter Code erforderlich ist. Ob Sie einen schnellen, einmaligen Datenimport benötigen oder eine Produktionspipeline, die Tausende von Dateien pro Tag verarbeitet – die gleiche API funktioniert in beiden Kontexten.

Manuelles CSV-Parsing mit string.Split oder StreamReader bricht schnell zusammen, wenn Felder mit Anführungszeichen das Begrenzungszeichen enthalten oder wenn Zeilenumbrüche innerhalb von Feldwerten auftreten. IronXL behandelt diese Fälle standardmäßig korrekt, indem es die CSV-Spezifikation für die Behandlung von in Anführungszeichen gesetzten Feldern und Escape-Sequenzen befolgt.

Die wichtigsten Vorteile, die IronXL für die CSV-Bearbeitung in .NET 10 auszeichnen:

• Keine Office-Abhängigkeit : Server- und Cloud-Bereitstellungen funktionieren ohne Installation von Microsoft Office oder COM-Interoperabilität.
• Benutzerdefinierte Begrenzungszeichen: Jedes Begrenzungszeichen oder jede Zeichenkette wird durch den Parameter listTrennzeichen unterstützt
• Typsicherer Zellzugriff: StringValue, DecimalValue, IntValue und DateTimeValue Accessoren geben sichere Standardwerte zurück, anstatt bei fehlerhaften Daten zu verwerfen
• Bereichsoperationen : Daten über Bereiche hinweg aggregieren und abfragen, ohne zeilenweise Iteration.
• Formatkonvertierung : CSV laden und in einem Workflow als XLSX, XLS, PDF oder in anderen Formaten speichern.
• DataSet-Integration: Geladene Arbeitsmappen in DataSet / DataRegisterkartele für ADO.NET und Datenbankoperationen konvertieren
• Plattformübergreifend : Läuft ohne Änderungen unter Windows, Linux, macOS, Docker und in Cloud-Umgebungen.

Die IronXL-Dokumentation und der Leitfaden zur Zellenformatierung enthalten weitere Details zu Formatierung, Formelunterstützung und fortgeschrittenen Arbeitsmappenoperationen.

Sind Sie bereit, CSV-Dateien sicher zu verarbeiten? Starten Sie mit einer kostenlosen Testversion und entdecken Sie den vollen Funktionsumfang von IronXL .