Jak używać .NET Core CSV Reader z IronXL: Praktyczne przykłady

Dłączego warto wybrać IronXL jako czytnik plików CSV dla .NET Core?

Przy wyborze czytnika plików CSV dla platformy .NET Core, IronXL oferuje kilka istotnych zalet w porównaniu z tradycyjnymi bibliotekami do parsowania plików CSV. IronXL integruje się z nowoczesną architekturą .NET Core, zachowując jednocześnie kompatybilność wsteczną z projektami .NET Framework. To rozwiązanie eliminuje typowe problemy, z którymi borykają się programiści podczas pracy z plikami CSV, w tym:

• Automatyczne wykrywanie kodowania dla międzynarodowych zestawów znaków
• Inteligentne rozpoznawanie separatorów bez ręcznej konfiguracji
• Oszczędne przetwarzanie plików o rozmiarze od kilobajtów do gigabajtów
• Wbudowane wnioskowanie o typach danych i konwersja
• Obsługa znaków powrotu karetki i przesunięcia wiersza na różnych platformach
• Obsługa formuł programu Excel nawet podczas pracy z danymi CSV
• Niezawodność na różnych platformach: Windows, Linux i macOS

W przeciwieństwie do podstawowych czytników CSV, które wymagają rozbudowanej konfiguracji i ręcznego parsowania, IronXL automatycznie obsługuje skrajne przypadki — takie jak pola w cudzysłowie zawierające separatory, wielowierszowe wartości komórek i znaki specjalne. Architektura biblioteki zapewnia optymalną wydajność dzięki funkcjom lazy loading i strumieniowania, dzięki czemu nadaje się zarówno do małych plików konfiguracyjnych, jak i do zadań przetwarzania danych na dużą skalę. IronXL może w razie potrzeby pomijać wiersze nagłówkowe i efektywnie dzielić złożone struktury danych. Dowiedz się więcej w przeglądzie funkcji IronXL.

Dla programistów przechodzących z systemów starszego typu IronXL zapewnia znane API, które skraca czas nauki, oferując jednocześnie nowoczesne wzorce async/await dla responsywnych aplikacji. To sprawia, że jest to idealny wybór dla zespołów modernizujących swoją infrastrukturę przetwarzania danych. Pełną dokumentację IronXL zawierającą informacje o dokumentacji API i opcjach konfiguracyjnych można znaleźć tutaj.

Jak zainstalować IronXL do odczytu plików CSV?

Zainstalowanie IronXL w projekcie .NET Core zajmuje zaledwie kilka sekund, niezależnie od tego, czy tworzysz aplikację konsolową, aplikację internetową ASP.NET Core, czy aplikację Windows Forms. Aby efektywnie analizować pliki CSV w .NET Core i rozpocząć odczytywanie danych CSV, otwórz konsolę menedżera pakietów w Visual Studio i uruchom:

Install-Package IronXl.Excel

Install-Package IronXl.Excel

Lub użyj interfejsu CLI platformy .NET:

dotnet add package IronXl.Excel

dotnet add package IronXl.Excel

Alternatywnie można skorzystać z interfejsu użytkownika menedżera pakietów NuGet, wyszukując "IronXl.Excel" i klikając przycisk instalacji. Biblioteka ta integruje się z istniejącymi projektami .NET Framework podczas migracji do .NET Core. Można również odwołać się do niego bezpośrednio ze strony IronXL NuGet.

Po zainstalowaniu dodaj przestrzeń nazw do swojego kodu:

using IronXL;

using IronXL;

Imports IronXL

Takie rozwiązanie zapewnia dostęp do zaawansowanych funkcji odczytu plików CSV bez konieczności korzystania z pakietu Microsoft Office lub zależności Interop, co czyni je idealnym rozwiązaniem do wdrożeń w chmurze i kontenerach Docker. Szczegółowe instrukcje instalacji i ustawienia konfiguracyjne można znaleźć w dokumentacji przewodnika instalacji IronXL.

Jak odczytywać pliki CSV za pomocą metody LoadCSV biblioteki IronXL?

IronXL ułatwia przetwarzanie plików CSV dzięki metodzie LoadCSV, która efektywnie obsługuje nagłówki, kolumny i wiersze CSV, jak pokazano w poniższym przykładzie:

// Load CSV file into a WorkBook object for .NET Core CSV reading
var workbook = WorkBook.LoadCSV("Budget.csv",
    fileFormat: ExcelFileFormat.XLSX,
    listDelimiter: ",");
// Access the default worksheet containing parsed CSV data
WorkSheet worksheet = workbook.DefaultWorkSheet;
// Read specific cell values with type-safe methods
string cellValue = worksheet["A1"].StringValue;
// Iterate through a range for bulk CSV data processing
foreach (var cell in worksheet["A1:C10"])
{
    Console.WriteLine($"Cell {cell.AddressString}: {cell.Text}");
}

// Load CSV file into a WorkBook object for .NET Core CSV reading
var workbook = WorkBook.LoadCSV("Budget.csv",
    fileFormat: ExcelFileFormat.XLSX,
    listDelimiter: ",");
// Access the default worksheet containing parsed CSV data
WorkSheet worksheet = workbook.DefaultWorkSheet;
// Read specific cell values with type-safe methods
string cellValue = worksheet["A1"].StringValue;
// Iterate through a range for bulk CSV data processing
foreach (var cell in worksheet["A1:C10"])
{
    Console.WriteLine($"Cell {cell.AddressString}: {cell.Text}");
}

Imports IronXL

' Load CSV file into a WorkBook object for .NET Core CSV reading
Dim workbook = WorkBook.LoadCSV("Budget.csv", fileFormat:=ExcelFileFormat.XLSX, listDelimiter:=",")

' Access the default worksheet containing parsed CSV data
Dim worksheet As WorkSheet = workbook.DefaultWorkSheet

' Read specific cell values with type-safe methods
Dim cellValue As String = worksheet("A1").StringValue

' Iterate through a range for bulk CSV data processing
For Each cell In worksheet("A1:C10")
    Console.WriteLine($"Cell {cell.AddressString}: {cell.Text}")
Next

Metoda LoadCSV tworzy obiekt WorkBook, który reprezentuje strukturę danych CSV w pamięci przy użyciu zoptymalizowanej obsługi strumienia pamięci. Parametr fileFormat określa wewnętrzny format przetwarzania, natomiast listDelimiter definiuje znak separatora CSV używany w pliku CSV — obsługuje pliki rozdzielane tabulatorami oraz formaty rozdzielane znakami pipe.

public record Customer(string Name, int Age, string City)
{
    public bool IsValid() => !string.IsNullOrEmpty(Name) && Age > 0;
}

// Parse CSV rows into typed objects
var customers = new List<Customer>();
for (int row = 2; row <= worksheet.RowCount; row++)
{
    var customer = new Customer(
        Name: worksheet[$"A{row}"].StringValue,
        Age:  worksheet[$"B{row}"].IntValue,
        City: worksheet[$"C{row}"].StringValue
    );
    if (customer.IsValid())
        customers.Add(customer);
}
// Output the records
foreach (var record in customers)
{
    Console.WriteLine($"Customer: {record.Name}, Age: {record.Age}, City: {record.City}");
}

public record Customer(string Name, int Age, string City)
{
    public bool IsValid() => !string.IsNullOrEmpty(Name) && Age > 0;
}

// Parse CSV rows into typed objects
var customers = new List<Customer>();
for (int row = 2; row <= worksheet.RowCount; row++)
{
    var customer = new Customer(
        Name: worksheet[$"A{row}"].StringValue,
        Age:  worksheet[$"B{row}"].IntValue,
        City: worksheet[$"C{row}"].StringValue
    );
    if (customer.IsValid())
        customers.Add(customer);
}
// Output the records
foreach (var record in customers)
{
    Console.WriteLine($"Customer: {record.Name}, Age: {record.Age}, City: {record.City}");
}

Imports System
Imports System.Collections.Generic

Public Class Customer
    Public Property Name As String
    Public Property Age As Integer
    Public Property City As String

    Public Sub New(name As String, age As Integer, city As String)
        Me.Name = name
        Me.Age = age
        Me.City = city
    End Sub

    Public Function IsValid() As Boolean
        Return Not String.IsNullOrEmpty(Name) AndAlso Age > 0
    End Function
End Class

' Parse CSV rows into typed objects
Dim customers As New List(Of Customer)()
For row As Integer = 2 To worksheet.RowCount
    Dim customer As New Customer(
        Name:=worksheet($"A{row}").StringValue,
        Age:=worksheet($"B{row}").IntValue,
        City:=worksheet($"C{row}").StringValue
    )
    If customer.IsValid() Then
        customers.Add(customer)
    End If
Next

' Output the records
For Each record In customers
    Console.WriteLine($"Customer: {record.Name}, Age: {record.Age}, City: {record.City}")
Next

Jak radzisz sobie z różnymi separatorami i konwersją do tabeli danych?

W rzeczywistych formatach plików CSV często stosuje się różne separatory poza przecinkami, co wymaga elastycznego podejścia. IronXL elegancko radzi sobie z tym dzięki automatycznemu wykrywaniu separatorów:

// Load CSV with semicolon delimiter
WorkBook workbook = WorkBook.LoadCSV("products.csv",
    fileFormat: ExcelFileFormat.XLSX,
    listDelimiter: ";");
WorkSheet worksheet = workbook.DefaultWorkSheet;
// Convert to DataTable for database operations
DataTable dataTable = worksheet.ToDataTable(true);
// Process the DataTable
foreach (DataRow row in dataTable.Rows)
{
    Console.WriteLine($"Product: {row["ProductName"]}, Price: {row["Price"]}");
}

// Load CSV with semicolon delimiter
WorkBook workbook = WorkBook.LoadCSV("products.csv",
    fileFormat: ExcelFileFormat.XLSX,
    listDelimiter: ";");
WorkSheet worksheet = workbook.DefaultWorkSheet;
// Convert to DataTable for database operations
DataTable dataTable = worksheet.ToDataTable(true);
// Process the DataTable
foreach (DataRow row in dataTable.Rows)
{
    Console.WriteLine($"Product: {row["ProductName"]}, Price: {row["Price"]}");
}

Imports IronXL
Imports System.Data

' Load CSV with semicolon delimiter
Dim workbook As WorkBook = WorkBook.LoadCSV("products.csv", fileFormat:=ExcelFileFormat.XLSX, listDelimiter:=";")
Dim worksheet As WorkSheet = workbook.DefaultWorkSheet
' Convert to DataTable for database operations
Dim dataTable As DataTable = worksheet.ToDataTable(True)
' Process the DataTable
For Each row As DataRow In dataTable.Rows
    Console.WriteLine($"Product: {row("ProductName")}, Price: {row("Price")}")
Next

Metoda ToDataTable konwertuje dane arkusza na format .NET DataTable, przy czym parametr logiczny wskazuje, czy pierwszy wiersz ma służyć jako nagłówki kolumn. Ta konwersja jest szczególnie przydatna w przypadku operacji na bazach danych, powiązania danych w aplikacjach .NET Core lub gdy konieczne jest zastosowanie istniejącej logiki przetwarzania DataTable w celu integracji z SQL Server. Powstały DataTable zachowuje typy danych i informacje o schemacie i może być bezpośrednio używany z SqlBulkCopy do wydajnych operacji wstawiania zbiorczego.

Dowiedz się więcej o importowaniu plików CSV do DataTable i integracji z bazami danych w szczegółowych przewodnikach.

// Load a DataTable from your data source
DataTable exportTable = GetProcessedData(); // your data source method

// Create a new workbook and populate it from the DataTable
WorkBook outputWorkbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet outputSheet = outputWorkbook.DefaultWorkSheet;

// Write headers from DataTable columns
for (int col = 0; col < exportTable.Columns.Count; col++)
{
    outputSheet[0, col].Value = exportTable.Columns[col].ColumnName;
}

// Write rows
for (int row = 0; row < exportTable.Rows.Count; row++)
{
    for (int col = 0; col < exportTable.Columns.Count; col++)
    {
        outputSheet[row + 1, col].Value = exportTable.Rows[row][col]?.ToString();
    }
}

// Save as CSV
outputWorkbook.SaveAsCsv("output.csv", delimiter: ",");
Console.WriteLine("Export complete.");

// Load a DataTable from your data source
DataTable exportTable = GetProcessedData(); // your data source method

// Create a new workbook and populate it from the DataTable
WorkBook outputWorkbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet outputSheet = outputWorkbook.DefaultWorkSheet;

// Write headers from DataTable columns
for (int col = 0; col < exportTable.Columns.Count; col++)
{
    outputSheet[0, col].Value = exportTable.Columns[col].ColumnName;
}

// Write rows
for (int row = 0; row < exportTable.Rows.Count; row++)
{
    for (int col = 0; col < exportTable.Columns.Count; col++)
    {
        outputSheet[row + 1, col].Value = exportTable.Rows[row][col]?.ToString();
    }
}

// Save as CSV
outputWorkbook.SaveAsCsv("output.csv", delimiter: ",");
Console.WriteLine("Export complete.");

Imports System.Data

' Load a DataTable from your data source
Dim exportTable As DataTable = GetProcessedData() ' your data source method

' Create a new workbook and populate it from the DataTable
Dim outputWorkbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim outputSheet As WorkSheet = outputWorkbook.DefaultWorkSheet

' Write headers from DataTable columns
For col As Integer = 0 To exportTable.Columns.Count - 1
    outputSheet(0, col).Value = exportTable.Columns(col).ColumnName
Next

' Write rows
For row As Integer = 0 To exportTable.Rows.Count - 1
    For col As Integer = 0 To exportTable.Columns.Count - 1
        outputSheet(row + 1, col).Value = exportTable.Rows(row)(col)?.ToString()
    Next
Next

' Save as CSV
outputWorkbook.SaveAsCsv("output.csv", delimiter:=","c)
Console.WriteLine("Export complete.")

Jak konwertować pliki między formatami CSV i Excel?

Jedną z wyróżniających się funkcji IronXL jest konwersja plików CSV do formatu Excel oraz transformacja plików Excel do formatu CSV, niezbędna w projektach migracji danych. Poniższy przykład ilustruje tę możliwość:

// Load CSV and save as Excel
WorkBook csvWorkbook = WorkBook.LoadCSV("report.csv",
    fileFormat: ExcelFileFormat.XLSX,
    listDelimiter: ",");
// Save as Excel file
csvWorkbook.SaveAs("report.xlsx");
// Or load Excel and export to CSV
WorkBook excelWorkbook = WorkBook.Load("data.xlsx");
excelWorkbook.SaveAsCsv("exported_data.csv", delimiter: ",");

// Load CSV and save as Excel
WorkBook csvWorkbook = WorkBook.LoadCSV("report.csv",
    fileFormat: ExcelFileFormat.XLSX,
    listDelimiter: ",");
// Save as Excel file
csvWorkbook.SaveAs("report.xlsx");
// Or load Excel and export to CSV
WorkBook excelWorkbook = WorkBook.Load("data.xlsx");
excelWorkbook.SaveAsCsv("exported_data.csv", delimiter: ",");

Imports IronXL

' Load CSV and save as Excel
Dim csvWorkbook As WorkBook = WorkBook.LoadCSV("report.csv", fileFormat:=ExcelFileFormat.XLSX, listDelimiter:=",")

' Save as Excel file
csvWorkbook.SaveAs("report.xlsx")

' Or load Excel and export to CSV
Dim excelWorkbook As WorkBook = WorkBook.Load("data.xlsx")
excelWorkbook.SaveAsCsv("exported_data.csv", delimiter:=",")

Ta dwukierunkowa konwersja zachowuje integralność danych, zapewniając jednocześnie elastyczność formatowania w różnych scenariuszach konwersji plików. Metoda SaveAs automatycznie wykrywa żądany format na podstawie rozszerzenia pliku, obsługując formaty XLSX, XLS i inne formaty Excel z zarządzaniem arkuszami. Podczas zapisywania do pliku CSV przy użyciu SaveAsCsv można określić niestandardowe separatory i kodowanie tekstu zgodnie z własnymi wymaganiami.

Ta funkcja jest nieoceniona podczas integracji z systemami, które wymagają określonych formatów plików do wymiany danych. Programiści, którzy chcą przejść z innych bibliotek lub rozważają alternatywne rozwiązania oparte na ręcznym parsowaniu, mogą zapoznać się z porównaniem IronXL z popularnymi alternatywami omawianymi na Stack Overflow oraz uwagami dotyczącymi wydajności w społeczności .NET. Aby uzyskać więcej wzorów konwersji formatów plików, odwiedź przewodnik dotyczący konwersji arkuszy kalkulacyjnych Excel.

WorkBook workbook = WorkBook.LoadCSV("large-dataset.csv",
    fileFormat: ExcelFileFormat.XLSX,
    listDelimiter: ",");
WorkSheet worksheet = workbook.DefaultWorkSheet;

int batchSize = 1000;
int totalRows = worksheet.RowCount;

for (int start = 1; start <= totalRows; start += batchSize)
{
    int end = Math.Min(start + batchSize - 1, totalRows);
    for (int row = start; row <= end; row++)
    {
        string id   = worksheet[$"A{row}"].StringValue;
        string name = worksheet[$"B{row}"].StringValue;
        // Process each record here
        Console.WriteLine($"Row {row}: {id} - {name}");
    }
    Console.WriteLine($"Processed batch {start}-{end}");
}

WorkBook workbook = WorkBook.LoadCSV("large-dataset.csv",
    fileFormat: ExcelFileFormat.XLSX,
    listDelimiter: ",");
WorkSheet worksheet = workbook.DefaultWorkSheet;

int batchSize = 1000;
int totalRows = worksheet.RowCount;

for (int start = 1; start <= totalRows; start += batchSize)
{
    int end = Math.Min(start + batchSize - 1, totalRows);
    for (int row = start; row <= end; row++)
    {
        string id   = worksheet[$"A{row}"].StringValue;
        string name = worksheet[$"B{row}"].StringValue;
        // Process each record here
        Console.WriteLine($"Row {row}: {id} - {name}");
    }
    Console.WriteLine($"Processed batch {start}-{end}");
}

Imports System

Dim workbook As WorkBook = WorkBook.LoadCSV("large-dataset.csv", fileFormat:=ExcelFileFormat.XLSX, listDelimiter:=",")
Dim worksheet As WorkSheet = workbook.DefaultWorkSheet

Dim batchSize As Integer = 1000
Dim totalRows As Integer = worksheet.RowCount

For start As Integer = 1 To totalRows Step batchSize
    Dim [end] As Integer = Math.Min(start + batchSize - 1, totalRows)
    For row As Integer = start To [end]
        Dim id As String = worksheet($"A{row}").StringValue
        Dim name As String = worksheet($"B{row}").StringValue
        ' Process each record here
        Console.WriteLine($"Row {row}: {id} - {name}")
    Next
    Console.WriteLine($"Processed batch {start}-{end}")
Next

Jakie zaawansowane funkcje oferuje IronXL do przetwarzania plików CSV w Enterprise?

IronXL oferuje funkcje klasy Enterprise, które wyróżniają go spośród podstawowych parserów CSV, w tym obsługę testów jednostkowych i narzędzia do debugowania. Biblioteka oferuje kompatybilność międzyplatformową, działając na systemach Windows, Linux, macOS oraz w kontenerach Docker — co jest niezbędne dla nowoczesnych wdrożeń .NET Core i architektury mikrousług. Zgodnie z dokumentacją firmy Microsoft obsługa wielu platform ma kluczowe znaczenie dla aplikacji natywnych dla chmury i wdrażania w Azure.

Oprócz możliwości technicznych, IronXL zapewnia profesjonalne wsparcie i regularne aktualizacje dla wszystkich licencji, gwarantując zgodność z najnowszymi wersjami .NET i poprawkami bezpieczeństwa. To wsparcie komercyjne zapewnia niezawodność w przypadku aplikacji o znaczeniu krytycznym, gdzie biblioteki open source mogą nie spełniać wymagań w środowiskach produkcyjnych. Biblioteka efektywnie obsługuje duże zbiory danych dzięki zoptymalizowanemu zarządzaniu pamięcią i obsługuje zaawansowane scenariusze, takie jak:

W przypadku wdrożeń produkcyjnych wymagających skalowalności i równoważenia obciążenia model licencyjny IronXL oferuje elastyczność dzięki opcjom dla pojedynczych projektów, zespołów i użytkowania w całym przedsiębiorstwie — wszystkie one obejmują dostęp do kodu źródłowego i prawa do redystrybucji bez opłat licencyjnych. Kup licencję, aby odblokować pełną funkcjonalność bez znaków wodnych.

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

// Then proceed with CSV reading as normal
WorkBook workbook = WorkBook.LoadCSV("data.csv",
    fileFormat: ExcelFileFormat.XLSX,
    listDelimiter: ",");
WorkSheet worksheet = workbook.DefaultWorkSheet;
Console.WriteLine($"Loaded {worksheet.RowCount} rows from CSV.");

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

// Then proceed with CSV reading as normal
WorkBook workbook = WorkBook.LoadCSV("data.csv",
    fileFormat: ExcelFileFormat.XLSX,
    listDelimiter: ",");
WorkSheet worksheet = workbook.DefaultWorkSheet;
Console.WriteLine($"Loaded {worksheet.RowCount} rows from CSV.");

Imports IronXl

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

' Then proceed with CSV reading as normal
Dim workbook As WorkBook = WorkBook.LoadCSV("data.csv", fileFormat:=ExcelFileFormat.XLSX, listDelimiter:=",")
Dim worksheet As WorkSheet = workbook.DefaultWorkSheet
Console.WriteLine($"Loaded {worksheet.RowCount} rows from CSV.")

Jak rozpocząć korzystanie z bezpłatnej wersji próbnej?

IronXL upraszcza operacje odczytu i zapisu plików CSV w aplikacjach .NET Core, zapewniając jednocześnie elastyczność w obsłudze złożonych scenariuszy, w tym analizy danych, raportowania i zadań automatyzacji. Intuicyjny interfejs API w połączeniu z obsługą formatu Excel i funkcjami Enterprise sprawia, że jest to niezawodny wybór dla programistów, którzy potrzebują sprawdzonych możliwości przetwarzania plików CSV z zabezpieczeniem wątków i obsługą dostępu współbieżnego. Możliwość konwersji formatów, obsługi różnych separatorów, czyszczenia danych oraz integracji z istniejącymi strukturami danych .NET znacznie skraca czas programowania, a jednocześnie pozwala na łatwą konserwację kodu.

Gotowy do rozpoczęcia przetwarzania plików CSV? Pobierz bezpłatną wersję próbną IronXL już dziś i przekonaj się, jak biblioteka ta zmienia procesy przetwarzania danych dzięki profesjonalnym funkcjom analizy plików CSV. W przypadku zastosowań produkcyjnych warto zapoznać się z opcjami licencyjnymi, które obejmują profesjonalne wsparcie, dokumentację i bieżące aktualizacje dla projektów .NET.

Dodatkowe materiały do dalszej lektury:

• Jak odczytywać pliki Excel w aplikacji konsolowej C#
• Samouczek tworzenia pliku CSV w języku C#
• Eksportowanie tabeli danych do programu Excel w języku C#
• Interfejs API obiektów IronXL
• Rozpocznij pracę na systemach Linux, macOS, Docker i AWS