Jak czytać pliki CSV w C# używając IronXL

Jaki jest najprostszy sposób odczytu plików CSV w .NET?

Najprostszym podejściem jest użycie metody WorkBook.LoadCSV do bezpośredniego importowania danych CSV do struktury skoroszytu. Ta pojedyncza metoda automatycznie obsluguje parsowanie, wykrywanie separatorow i organizacje danych — nie ma potrzeby tworzenia StreamReader ani recznego przetwarzania kazdej linii tekstu.

Zainstaluj IronXL za pomocą konsoli menedżera pakietów NuGet w Visual Studio. Otwórz swój projekt .NET i uruchom:

Install-Package IronXL.Excel

using IronXL;

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

using IronXL;

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

Imports IronXL

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

Jak ręczne parsowanie plików CSV wypada w porównaniu z użyciem biblioteki?

Zrozumienie złożoności, którą eliminuje IronXL, pomaga wyjaśnić jego wartość. Ręczne parsowanie plików CSV wymaga obsługi wielu skrajnych przypadków, które wydają się proste, ale szybko stają się problematyczne w każdym projekcie.

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

Jak radzisz sobie z różnymi separatorami w plikach CSV?

Pliki CSV nie zawsze używają przecinków jako separatorów. W europejskich systemach eksportu często stosuje się średniki, ponieważ przecinki występują w liczbach dziesiętnych. Pliki z wartościami rozdzielonymi tabulatorami (TSV) i pliki rozdzielone znakami pipe pojawiają się regularnie w eksportach danych z różnych aplikacji i starszych systemów.

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")

Parametr listDelimiter w LoadCSV akceptuje dowolny pojedynczy znak lub sekwencje ucieczki jako separator pola. Znaki tabulacji uzywaja sekwencji ucieczki \t. Po załadowaniu struktura danych pozostaje spójna niezależnie od oryginalnego formatu, co ułatwia przetwarzanie plików CSV z wielu źródeł z różnymi separatorami. Domyślną wartością dla większości plików CSV jest przecinek, ale ta elastyczność pozwala obsłużyć każdą odmianę, z jaką projekt może się spotkać.

Jakie są najlepsze metody konwersji plików CSV do tabeli danych?

Konwersja danych CSV do DataTable umozliwia integracje z operacjami bazodanowymi, wiazanie danych w aplikacjach interfejsu uzytkownika i zapytaniami LINQ. Metoda ToDataTable wykonuje tę konwersję za pomocą jednego wywołania.

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

Parametr boolean w ToDataTable okresla, czy pierwszy wiersz powinien stac sie naglowkami kolumn (true) czy danymi (false). Gdy ustawiony na true, kolumny wynikowego DataTable przenosza nazwy naglowkow z pliku CSV, umozliwiajac intuicyjny dostep do danych przy uzyciu nazw kolumn, takich jak row["Name"].

Jak przekonwertować pliki CSV do formatu Excel?

Jedną z wyróżniających się funkcji IronXL jest konwersja danych CSV do odpowiednich formatów Excel. Umożliwia to dodawanie formuł, formatowania, wykresów i wielu arkuszy do pierwotnie płaskich danych CSV — czego nie da się osiągnąć przy użyciu samego formatu CSV.

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")

Metoda SaveAs automatycznie okresla format wyjsciowy w oparciu o rozszerzenie pliku. XLSX tworzy nowoczesne pliki Office Open XML kompatybilne z Excel 2007 i pozniejszymi wersjami, podczas gdy XLS produkuje dokumenty starszego formatu Binary Interchange File Format dla starszych aplikacji.

Jak uzyskać dostęp do konkretnych wartości komórek w danych CSV?

Oprócz iteracji przez wszystkie rekordy, IronXL zapewnia bezpośredni dostęp do komórek przy użyciu znanego adresowania w stylu Excela. Umożliwia to ukierunkowane pozyskiwanie danych i pobieranie wartości z zachowaniem bezpieczeństwa typów w różnych typach danych.

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

Adresowanie komórek jest zgodne z konwencjami programu Excel, gdzie litery oznaczają kolumny CSV (A, B, C), a cyfry oznaczają pozycje indeksu wiersza (1, 2, 3). Klasa Cell zapewnia akcesory typowo-specyficzne, w tym StringValue, IntValue, DecimalValue, BoolValue i DateTimeValue. Te akcesory automatycznie obsługują parsowanie i konwersję, eliminując ręczne rzutowanie typów w porównaniu z przechowywaniem wszystkiego jako wartości łańcuchowych.

Wybor zakresu przy uzyciu notacji, takiej jak A2:A10, zwraca obiekt Range, ktory obsluguje iteracje, funkcje agregujace i operacje masowe. Jest to przydatne podczas wyodrębniania określonych kolumn lub prostokątnych obszarów danych z dużych plików CSV. Na przykład można utworzyć listę wartości z określonej kolumny lub zapisać przefiltrowane dane do innego pliku. Więcej wzorów można znaleźć w przewodniku po serii IronXL.

Jak radzisz sobie z błędami podczas odczytu plików CSV?

Aplikacje produkcyjne wymagają kodu zabezpieczającego operacje na plikach. Odczyt pliku CSV może się nie powieść z kilku powodów: plik nie istnieje, dostęp jest zablokowany, dane są nieprawidłowe lub brakuje pamięci w przypadku bardzo dużych plików. Opakowanie wywolan do IronXL w blokach try/catch i weryfikacja sciezek przed zaladowaniem zapewnia niezawodne dzialanie w roznych srodowiskach.

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

Jak odczytywać duże pliki CSV bez problemów z pamięcią?

W przypadku plików zawierających setki tysięcy wierszy jednorazowe załadowanie całego zbioru danych do pamięci może być niepraktyczne. IronXL wczytuje caly plik do obiektu WorkBook, ktory przechowuje wszystkie dane w pamieci. Dla scenariuszy ETL na duza skale (Extract, Transform, Load), praktyczna strategia to przetwarzanie CSV w partiach przez podzial zrodla przed zaladowaniem lub przez przesylanie wierszy z StreamReader i zapisywanie fragmentow do osobnych skoroszytow.

Dokumentacja IronXL dotycząca odczytu plików Excel obejmuje kwestie związane z wydajnością w przypadku dużych obciążeń. W szczegolnosci dla CSV, struktura liniowa formatu CSV oznacza, ze prosty File.ReadAllLines z recznym podzialem daje przewidywalne zuzycie pamieci, gdy zbior danych jest zbyt duzy na jednorazowe zaladowanie do pamieci.

Jakie są Twoje kolejne kroki?

Odczytywanie plików CSV w .NET wymaga minimalnego wysiłku, jeśli zastosuje się właściwe podejście. Metoda LoadCSV w IronXL automatycznie obsluguje zlozonosc parsowania, obsluguje rozne separatory, zapewnia natychmiastowy dostep do zestrukturowanych danych i konwertuje do Excela lub DataTable za pomoca pojedynczych wywolan metod. Niezależnie od tego, czy tworzysz aplikację ASP.NET Core, interfejs API .NET Core Web API, czy projekt konsolowy, biblioteka ta upraszcza przetwarzanie plików CSV od początku do końca.

Poznaj więcej możliwości IronXL, aby poszerzyć swoją wiedzę:

• Strona produktu IronXL — pełna lista funkcji i licencjonowanie
• Jak odczytywać pliki Excel w języku C# — rozszerzenie umiejętności pracy z plikami CSV na formaty XLSX/XLS
• Jak zapisywać pliki Excel w języku C# — programowe tworzenie i eksportowanie arkuszy kalkulacyjnych
• Eksport DataTable i DataSet — połączenie z procesami ADO.NET
• Licencjonowanie IronXL — opcje licencyjne dotyczące wdrażania

Rozpocznij darmowy okres próbny, aby zobaczyć, jak IronXL upraszcza czytanie plików CSV w twoich projektach .NET. W przypadku wdrożenia produkcyjnego opcje licencyjne obejmują prawa użytkowania wieczyste oraz roczną pomoc techniczną.