Nachrichtensymbol
Zum Fußzeileninhalt springen
  1. IronXL
  2. IronXL Blog
  3. IronXL verwenden
  4. C# Csv File Reader Blog
IRONXL VERWENDEN

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

Jordi Bardia
Jordi Bardia
Aktualisiert:

CSV-Dateien (Komma Separated Values) sind in Geschäftsanwendungen allgegenwärtig, von Finanzberichten bis hin zu Kundendatenexporten. Das CSV-Format wirkt auf den ersten Blick trügerisch einfach, doch die Verarbeitung im Produktivcode kann schnell schwierig werden, wenn es um Felder in Anführungszeichen, verschiedene Trennzeichentypen, eingebettete Zeilenumbrüche und die Notwendigkeit geht, Rohdaten in stark typisierte .NET Objekte umzuwandeln. IronXL ist eine .NET Bibliothek, die eine unternehmensgerechte CSV-Verarbeitung bietet und es Entwicklern ermöglicht, CSV-Daten mit minimalem Code in Excel-, XML- oder andere Formate zu konvertieren.

Dieser Leitfaden erklärt Ihnen, wie IronXL als C# CSV-Dateileser funktioniert und wie Sie ihn in Ihre .NET 10-Anwendungen implementieren können. Testen Sie IronXL selbst mit einer kostenlosen Testlizenz und lernen Sie anhand der Anleitung, wie es CSV- und Excel-Aufgaben bewältigt.

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
SHELL

Weitere Details 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);
    }
}
$vbLabelText   $csharpLabel

Die Methode WorkBook.LoadCSV übernimmt die Header-Identifizierung, erstellt eine interne Datenstruktur und führt ein speichereffizientes Parsen durch – wodurch Ihre Datenverwaltung von der ersten Codezeile an vereinfacht wird.

C# CSV-Datei-Reader-Tutorial: CSV-Daten mit IronXL parsen und konvertieren: Bild 1 – IronXL NuGet Installation

Wie liest man CSV-Dateien mit benutzerdefinierten Trennzeichen?

In realen CSV-Dateien werden nicht immer Kommas verwendet. Strichpunkte, Rohrs und Tabs 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}");
$vbLabelText   $csharpLabel

Der Parameter listTrennzeichen akzeptiert beliebige Zeichenketten und gibt Ihnen somit die volle Kontrolle über das Parsing-Verhalten. IronXL erhält Spaltenwerte und Datentypen während des Parsens - numerische Werte bleiben Zahlen, Datumsangaben bleiben DateTime Objekte, 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.

C# CSV-Datei-Reader-Tutorial: CSV-Daten mit IronXL parsen und konvertieren: Bild 2 – Erste Schritte, Beispielausgabe

Unterstützte Dateiformate und Trennzeichen

IronXL unterstützt beim Lesen von CSV-Dateien die folgenden Trennzeichentypen:

Gängige Trennzeichentypen, die von der LoadCSV-Methode von IronXL unterstützt werden
Trennzeichen Charakter Häufiger Anwendungsfall
Komma `,` Standard-CSV-Datei, Export für US-Gebietssprachen
Semikolon `;` Exporte in europäische Ländereinstellungen (wobei das Komma als Dezimaltrennzeichen dient)
Tab `\t` Tabulatorgetrennte Werte (TSV), Datenbankexporte
Rohr `|` Protokolldateien, Systemexporte
Benutzerdefinierte Zeichenfolge Beliebig Proprietäre Datenformate, mehrstellige Trennzeichen

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 vereinfacht diese Zuordnung durch seine Zellzugriffsmethoden . 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}");
$vbLabelText   $csharpLabel

Die typisierten Werteigenschaften von IronXL -- StringValue, DecimalValue, IntValue, DateTimeValue -- verarbeiten Konvertierungen sicher und geben Standardwerte für ungültige Daten zurück, anstatt Ausnahmen auszulösen. 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.

C# CSV-Datei-Reader-Tutorial: CSV-Daten mit IronXL parsen und konvertieren: Bild 3 – Ausgabe beim Lesen verschiedener Trennzeichen

Wie filtert und fragt man CSV-Daten mit LINQ ab?

Sobald die CSV-Daten in ein WorkSheet geladen sind, können Sie sie mithilfe von Bereichsselektoren bearbeiten oder in Objekte für LINQ-Abfragen konvertieren. Für einfache Spaltenoperationen ist der bereichsbasierte Zugriff der direkteste Weg:

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}");
$vbLabelText   $csharpLabel

Dieser bereichsbasierte Ansatz vermeidet die zeilenweise Iteration bei einfachen Aggregationen, was die Leistung bei größeren Dateien verbessert. Die vollständige Liste der unterstützten Bereichsoperationen finden Sie in der IronXL -Dokumentation .

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 unkompliziert und erhält dabei die gesamte 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");
$vbLabelText   $csharpLabel

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 eine noch präzisere Steuerung des Ausgabeformats bietet die Exportanleitung Optionen wie XLSX, XLS, CSV und PDF-Export. Sie können auch lernen, wie man Excel-Dateien schreibt und Excel-Dateien von Grund auf neu erstellt .

C# CSV-Datei-Reader-Tutorial: CSV-Daten mit IronXL parsen und konvertieren: Bild 4 - Ausgabe der CSV-Datenanalyse

Konvertierung von CSV in DataSet für Datenbankoperationen

Wenn Sie CSV-Daten in ein DataSet-Format laden müssen, um sie weiterzuverarbeiten oder in eine Datenbank einzufügen, bietet IronXL direkte Konvertierungsunterstützung. Die Anleitung zur Konvertierung von Excel in DataSets erklärt dies im Detail:

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 DataTable
DataTable customerTable = dataSet.Tables[0];

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

// Process with standard ADO.NET
foreach (DataRow row in customerTable.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 DataTable
DataTable customerTable = dataSet.Tables[0];

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

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

Dieser Ansatz lässt sich direkt in ADO .NET Workflows integrieren und ist nützlich, wenn CSV-Daten über Standard-Datenadapter in SQL Server, SQLite oder andere relationale Datenbanken übertragen werden. Da es sich bei DataSet und DataTable um .NET Kerntypen handelt, benötigt dieser Pfad keine zusätzlichen Abhängigkeiten über IronXL hinaus.

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.

Nutzung von Range Operations zur Leistungsoptimierung

Für eine optimale Leistung bei großen Datensätzen sollten Sie Bereichsoperationen verwenden, anstatt einzelne Zellen nacheinander abzurufen. Bereichsoperationen werden von der internen Engine von IronXL effizienter verarbeitet.

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;
}
$vbLabelText   $csharpLabel

IronXL verarbeitet automatisch unterschiedliche Textkodierungen ( UTF-8, UTF-16, ASCII ) beim Laden von CSV-Dateien und stellt so sicher, dass internationale Zeichen in den Spaltenwerten ohne zusätzliche Konfiguration korrekt angezeigt werden. Dies ist besonders wichtig für Dateien, die aus Systemen in Regionen exportiert werden, in denen UTF-8 BOM oder alternative Kodierungen üblich sind.

Fehlerbehandlung für nicht vertrauenswürdige CSV-Quellen

Bei der Verarbeitung von CSV-Dateien aus nicht vertrauenswürdigen oder variablen Quellen bietet das Einschließen von Operationen in try-catch-Blöcke eine zusätzliche Sicherheitsebene:

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}");
}
$vbLabelText   $csharpLabel

Die IronXL -Anleitungen behandeln Datenimportmuster für verschiedene Quellen, darunter Dateien, Datenströme und Byte-Arrays.

C# CSV-Datei-Reader-Tutorial: CSV-Daten mit IronXL parsen und konvertieren: Bild 5 – Konvertierung von CSV in das Excel-Format

Plattformübergreifende Bereitstellung

IronXL funktioniert unabhängig von Microsoft Office und eignet sich daher für Serverumgebungen und Cloud-Bereitstellungen. Egal ob Bereitstellung unter Windows, Linux, macOS, Docker-Containern oder Cloud-Funktionen auf Azure oder AWS – IronXL liefert auf allen Plattformen konsistente Ergebnisse ohne Konfigurationsänderungen.

Diese plattformübergreifende Funktionalität ist wertvoll für Microservices-Architekturen, bei denen schlanke Container die Datenverarbeitung übernehmen. Die IronXL Funktionsübersicht enthält die vollständige Liste der unterstützten Umgebungen und Laufzeitziele.

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.");
$vbLabelText   $csharpLabel

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.

Die manuelle CSV-Analyse mit string.Split oder StreamReader schlägt schnell fehl, wenn in Anführungszeichen gesetzte Felder das Trennzeichen 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 Trennzeichen : Über den Parameter listTrennzeichen werden beliebige Trennzeichen oder -zeichenfolgen unterstützt.
  • Typsicherer Zellenzugriff : Die Zugriffsmethoden StringValue, DecimalValue, IntValue und DateTimeValue geben sichere Standardwerte zurück, anstatt bei fehlerhaften Daten eine Ausnahme auszulösen.
  • 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 : Konvertierung geladener Arbeitsmappen in DataSet / DataTable für ADO .NET und Datenbankoperationen
  • Plattformübergreifend : Läuft ohne Änderungen unter Windows, Linux, macOS, Docker und in Cloud-Umgebungen.

Weitere Details zu Formatierung, Formelunterstützung und erweiterten Arbeitsmappenfunktionen finden Sie in der IronXL -Dokumentation und im Leitfaden zur Zellformatierung .

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

Häufig gestellte Fragen

Was ist eine CSV-Datei und warum wird sie häufig verwendet?

Eine CSV-Datei (Comma-Separated Values) ist ein einfaches Textformat zum Speichern tabellarischer Daten. Aufgrund ihrer Einfachheit und Benutzerfreundlichkeit wird sie häufig in Geschäftsanwendungen zum Exportieren und Importieren von Daten zwischen verschiedenen Systemen verwendet.

Wie unterstützt IronXL das Parsen von CSV-Dateien in C#?

IronXL vereinfacht das Parsen von CSV-Dateien in C# durch die Bereitstellung robuster Werkzeuge zur Verarbeitung komplexer CSV-Strukturen, einschließlich verschiedener Spaltentrennzeichen, Felder in Anführungszeichen und Datentypkonvertierungen.

Kann IronXL CSV-Daten in andere Formate konvertieren?

Ja, IronXL ermöglicht es Entwicklern, CSV-Daten in verschiedene Formate wie XML und Excel zu konvertieren, wodurch es vielseitig für unterschiedliche Datenverarbeitungsanforderungen einsetzbar ist.

Welche häufigen Herausforderungen treten beim Parsen von CSV-Dateien auf?

Zu den häufigsten Herausforderungen gehören der Umgang mit unterschiedlichen Spaltentrennzeichen, die Verwaltung von Feldern in Anführungszeichen und die Durchführung präziser Datentypkonvertierungen. IronXL trägt mit seinen fortschrittlichen Parsing-Funktionen dazu bei, diese Probleme zu minimieren.

Ist IronXL für die CSV-Verarbeitung im Unternehmensbereich geeignet?

Ja, IronXL ist für den Unternehmenseinsatz konzipiert und bietet robuste und skalierbare Lösungen zur Verarbeitung von CSV-Dateien for .NET Anwendungen.

Unterstützt IronXL die effiziente Verarbeitung großer CSV-Dateien?

IronXL ist auf Leistung optimiert und ermöglicht so die effiziente Verarbeitung großer CSV-Dateien ohne Kompromisse bei Geschwindigkeit oder Genauigkeit.

Kann IronXL CSV-Dateien mit benutzerdefinierten Trennzeichen verarbeiten?

Ja, IronXL unterstützt CSV-Dateien mit benutzerdefinierten Trennzeichen und bietet Entwicklern somit Flexibilität im Umgang mit nicht standardmäßigen CSV-Formaten.

Wie geht IronXL mit zitierten Feldern in CSV-Dateien um?

IronXL analysiert in CSV-Dateien korrekt gesetzte Felder und gewährleistet so die Datenintegrität und die korrekte Konvertierung während des Lesevorgangs.

Welche Programmiersprachen können mit IronXL zum Parsen von CSV-Dateien verwendet werden?

IronXL ist eine .NET Bibliothek und kann daher mit Sprachen verwendet werden, die vom .NET Framework unterstützt werden, wie z. B. C# und VB .NET.

Gibt es Codebeispiele für die Verwendung von IronXL mit CSV-Dateien?

Ja, die IronXL Dokumentation enthält vollständige Codebeispiele zum Lesen, Parsen und Verarbeiten von CSV-Dateien in C#-Anwendungen.

Jordi Bardia
Jordi Bardia
  Jetzt mit dem Ingenieurteam chatten
Software Ingenieur
Jordi ist am besten in Python, C# und C++ versiert. Wenn er nicht bei Iron Software seine Fähigkeiten einsetzt, programmiert er Spiele. Mit Verantwortung für Produkttests, Produktentwicklung und -forschung trägt Jordi mit immensem Wert zur kontinuierlichen Produktverbesserung bei. Die abwechslungsreiche Erfahrung hält ihn gefordert und engagiert, ...
Weiterlesen

Verwandte Artikel

30-Tage-Testversion → Volles Produkt. Keine Grenzen. Keine Karte. Gratis testen

Iron Support Team

We're online 24 hours, 5 days a week.
Chat
Email
Call Me