Mit IronXL wird das Lesen von CSV-Dateien in C# .NET trivial – ein einziger Methodenaufruf lädt kommagetrennte Daten in eine strukturierte Arbeitsmappe, ohne dass benutzerdefinierter Parsing-Code erforderlich ist. Dieser Leitfaden führt Sie durch alle notwendigen Techniken: grundlegendes Laden, benutzerdefinierte Trennzeichen, DataTable-Konvertierung, Zugriff auf Zellenebene, Fehlerbehandlung und Export in das Excel-Format.
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:
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
Die LoadCSV-Methode akzeptiert drei Parameter: den Dateipfad, das Ziel-Excel-Format für die interne Darstellung und das Trennzeichen. Nach dem Laden ist der CSV-Inhalt über die Eigenschaft DefaultWorkSheet zugänglich, die das primäre Arbeitsblatt mit allen importierten Datensätzen bereitstellt.
Die geschachtelte Schleifenstruktur durchläuft jede Row im Arbeitsblatt und dann jede Cell in dieser Zeile. Die Value-Eigenschaft gibt den Zellinhalt als Objekt zurück, während das Tabulatorzeichen in der Konsolenausgabe für eine lesbare Spaltentrennung sorgt. Dieses Muster funktioniert in gleicher Weise, egal ob die Quelldatei 10 Zeilen oder große CSV-Dateien mit Tausenden von Datensätzen enthält.
IronXL funktioniert unter .NET Framework, .NET Core und .NET 5+ ohne Installation von Microsoft Office – und ist damit ideal für ASP.NET Core und .NET Core Web API-Projekte. Die Bibliothek ist auf NuGet verfügbar und lässt sich nahtlos in jeden Projekttyp integrieren. Wenn Sie lieber verstehen möchten, was eine Bibliothek für Sie erledigt, behandelt der nächste Abschnitt das manuelle Parsen.
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();
}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
Die manuelle Vorgehensweise schlägt fehl, wenn CSV-Felder eingebettete Kommas innerhalb von Anführungszeichen enthalten – ein häufiges Szenario bei Adressfeldern oder Beschreibungen. Das korrekte Lesen von Dateien erfordert den Umgang mit in Anführungszeichen gesetzten Feldern, maskierten Anführungszeichen, mehrzeiligen Werten und unterschiedlichen Kodierungen. Einen eigenen Parser zu erstellen bedeutet, ein StreamReader zu schaffen, Maschinenzustandslogik zu implementieren und den gesamten Leseprozess selbst zu verwalten. Das ist ein beträchtlicher Standardsatz für etwas, das eigentlich nur ein Satz sein sollte.
Die IronXL Alternative behandelt alle Sonderfälle automatisch:
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()
NextDie WorkBook-Klasse verwaltet die Parsing-Komplexität intern, sodass Sie sich darauf konzentrieren können, mit den Daten zu arbeiten, anstatt sie zu extrahieren. Mehr über die vollständigen Funktionen von IronXL erfahren Sie in der IronXL -Funktionsübersicht .
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");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.
Die RowCount und ColumnCount-Eigenschaften bieten eine schnelle Überprüfung, dass die Datei korrekt geladen wurde – besonders nützlich beim Arbeiten mit unbekannten Datenquellen oder zur Validierung von Benutzer-Uploads in einer ASP.NET Core-Anwendung.
Beim Lesen von Dateien mit Nicht-ASCII-Zeichen, wie z. B. Akzentbuchstaben in französischen oder deutschen Daten, liest IronXL die Kodierung automatisch aus der Byte Order Mark (BOM) der Datei. Bei Dateien ohne Byte Order Mark (BOM) müssen Sie möglicherweise die Kodierung an der Quelle überprüfen. Die Dokumentation von Microsoft zur Dateikodierung bietet eine umfassende Referenz für Kodierungstypen in .NET.
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}");
}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}")
NextDer 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.
Diese Konvertierung erweist sich als wertvoll für Szenarien, die Datenbank-Masseninserts mit SqlBulkCopy, das Befüllen von DataGridView-Steuerelementen in Windows Forms-Anwendungen oder das Durchführen komplexer Datenumwandlungen mit LINQ-Ausdrücken erfordern. Das DataTable-Format integriert sich auch natürlich mit Entity Framework und anderen ORM-Tools in Ihrem .NET Core Web API-Projekt. Mehr über DataTable-Exportmuster erfahren Sie im IronXL DataTable-Leitfaden .
Weitere Beispiele für die Arbeit mit tabellarischen Daten in .NET finden Sie in der ADO .NET Übersicht von Microsoft .
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");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.
Dieser Workflow erweist sich als besonders nützlich, wenn CSV-Exporte aus Datenbanken oder APIs vor der Verteilung an die Benutzer noch optimiert werden müssen. Nach der Konvertierung kann die Excel-Datei mit zusätzlichen Formatierungen und Formeln versehen oder mit anderen Arbeitsblättern kombiniert werden – alles programmatisch über die Bearbeitungsfunktionen von IronXL. Der Prozess ist vollständig skriptfähig und eignet sich daher für automatisierte Berichtspipelines oder geplante Aufgaben.
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}");
}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}")
NextDie 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 .
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}");
}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 TryNeben dem Abfangen von Ausnahmen hilft die Überprüfung der Zeilen- und Spaltenanzahl nach dem Laden dabei, abgeschnittene Dateien oder unerwartete Schemaänderungen zu erkennen. Das Überprüfen von sheet.RowCount gegen ein erwartetes Minimum oder ob bestimmte Spaltenüberschriften in der ersten Zeile vorhanden sind, erkennt Datenprobleme frühzeitig in der Pipeline, bevor sie weiterverbreitet werden. Die Richtlinien von Microsoft zur Ausnahmebehandlung umfassen Best Practices für eine strukturierte Fehlerbehandlung in .NET.
Bei Anwendungen, die vom Benutzer hochgeladene CSV-Dateien verarbeiten, sollte vor dem Laden stets die Dateigröße überprüft, die Dateinamen bereinigt und die zulässigen Inhaltstypen am Upload-Endpunkt eingeschränkt werden. Diese Vorkehrungen verhindern eine Ressourcenerschöpfung durch zu große Dateien und schützen vor Path-Traversal-Angriffen.
IronXL enthält einen eigenen Ausnahmetyp IronXL.Exceptions.IronXLException für bibliotheksspezifische Fehler, was es einfach macht, Parsing-Fehler von allgemeinen Ein-/Ausgabeproblemen zu unterscheiden. Weitere Details finden Sie in der IronXL API-Referenz .
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.
IronXL ist nicht die einzige CSV-Bibliothek für .NET. CsvHelper ist eine weit verbreitete Open-Source-Alternative, die sich auf Streaming, Datensatzzuordnung und attributbasierte Konfiguration spezialisiert hat. Der entscheidende Unterschied liegt im Umfang: CsvHelper konzentriert sich ausschließlich auf CSV, während IronXL das gesamte Tabellenkalkulations-Ökosystem abdeckt – Lesen, Schreiben und Konvertieren von XLSX, XLS, CSV und anderen Formaten über eine einheitliche API. Wenn Ihre Anwendung bereits IronXL für Excel-Operationen verwendet, vermeidet die Verarbeitung von CSV-Dateien mit derselben Bibliothek eine zusätzliche Abhängigkeit. Wenn Sie ausschließlich mit dem CSV-Format arbeiten und Streaming-Unterstützung benötigen, ist eine Streaming-CSV-Bibliothek möglicherweise besser für Sie geeignet.
| Merkmal | IronXL | CsvHelper |
|---|---|---|
| CSV-Lesen | Ja | Ja |
| Excel-Unterstützung (XLSX/XLS) | Ja | Nein |
| Streaming großer Dateien | Nur im Arbeitsspeicher | Ja (Streaming) |
| Benutzerdefinierte Trennzeichen | Ja (Listentrennzeichen) | Ja (Konfiguration) |
| DataTable-Konvertierung | Eingebaut (ToDataTable) | Manuelle Kartierung |
| License | Kommerziell | Open Source (MS-PL) |
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:
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.
Curtis Chau hat einen Bachelor-Abschluss in Informatik von der Carleton University und ist spezialisiert auf Frontend-Entwicklung mit Expertise in Node.js, TypeScript, JavaScript und React. Leidenschaftlich widmet er sich der Erstellung intuitiver und ästhetisch ansprechender Benutzerschnittstellen und arbeitet gerne mit modernen Frameworks sowie der Erstellung gut strukturierter, optisch ansprechender Handbücher.
IronXL ist ein Teil der IRONSUITE
10 .NET-API-Produkte für Ihre Bürodokumente
Das Excel-API, das Sie brauchen, ohne den Office Interop Aufwand.
