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 obsługuje parsowanie, wykrywanie separatorów i organizację danych — nie ma potrzeby tworzenia StreamReader ani ręcznego przetwarzania każdego wiersza ciągu znaków.

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

Install-Package IronXL
dotnet add package IronXL

Install-Package IronXL
dotnet add package IronXL

using IronXL;

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

using IronXL;

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

Imports IronXL

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

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 sekwencję escape jako separator pól. Znaki tabulacji używają sekwencji escape \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 formatu DataTable umożliwia integrację z operacjami bazodanowymi, powiązanie danych w aplikacjach UI oraz zapytania 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 boolowski w ToDataTable określa, czy pierwszy wiersz ma stać się nagłówkami kolumn (true) czy danymi (false). Po ustawieniu na true kolumny wynikowego pliku DataTable zawierają nazwy nagłówków z pliku CSV, co umożliwia intuicyjny dostęp do danych przy użyciu 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 określa format wyjściowy na podstawie rozszerzenia pliku. XLSX tworzy nowoczesne pliki Office Open XML zgodne z programem Excel 2007 i nowszymi wersjami, natomiast XLS generuje dokumenty w starszym formacie Binary Interchange File Format przeznaczone 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 udostępnia akcesory specyficzne dla typu, w tym StringValue, IntValue, DecimalValue, BoolValue oraz 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.

Wybór zakresu przy użyciu notacji takiej jak A2:A10 zwraca obiekt Range, który obsługuje iterację, funkcje agregujące i operacje zbiorcze. 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. Umieszczenie wywołań IronXL w blokach try/catch oraz sprawdzanie poprawności ścieżek przed załadowaniem zapewnia niezawodne działanie w różnych środowiskach.

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 cały plik do obiektu WorkBook, który przechowuje wszystkie dane w pamięci. W przypadku scenariuszy ETL (Extract, Transform, Load) na dużą skalę praktyczną strategią jest przetwarzanie plików CSV partiami poprzez podział pliku źródłowego przed załadowaniem lub poprzez strumieniowe przesyłanie wierszy z StreamReader i zapisywanie fragmentów do oddzielnych skoroszytów.

Dokumentacja IronXL dotycząca odczytu plików Excel obejmuje kwestie związane z wydajnością w przypadku dużych obciążeń. W przypadku formatu CSV jego struktura wiersz po wierszu oznacza, że proste File.ReadAllLines z ręcznym przetwarzaniem partiami zapewnia przewidywalne zużycie pamięci, gdy zbiór danych jest zbyt duży, aby zmieścić się w pamięci.

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 firmy IronXL automatycznie radzi sobie ze złożonością parsowania, obsługuje różne separatory, zapewnia natychmiastowy dostęp do danych strukturalnych oraz konwertuje je do formatu Excel lub DataTable za pomocą pojedynczych wywołań 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 bezpłatny okres próbny, aby przekonać się, jak IronXL ułatwia odczytywanie plików CSV w projektach .NET. W przypadku wdrożenia produkcyjnego opcje licencyjne obejmują prawa użytkowania wieczyste oraz roczną pomoc techniczną.