C# Czytnik plików CSV: Parsuj i przetwarzaj dane CSV z IronXL

Jak zainstalować IronXL do odczytu plików CSV?

Włączenie IronXL do projektu zajmuje tylko chwilę. Można go zainstalować za pomocą menedżera pakietów NuGet w Visual Studio lub z wiersza poleceń, korzystając z interfejsu CLI .NET lub konsoli menedżera pakietów NuGet w PowerShell. Oba podejścia instalują ten sam pakiet i działają z każdym typem projektu .NET 10.

dotnet add package IronXL.Excel

Więcej szczegółów na temat opcji instalacji i konfiguracji można znaleźć w dokumentacji instalacyjnej IronXL.

Po zainstalowaniu odczytanie pierwszego pliku CSV wymaga bardzo niewielkiej ilości kodu. W poniższym przykładzie wykorzystano instrukcje najwyższego poziomu .NET 10:

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);
    }
}

Imports IronXL

' Load CSV file
Dim workbook As WorkBook = WorkBook.LoadCSV("data.csv")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet

' Read a specific cell
Dim cellValue As String = sheet("A1").StringValue

' Iterate through all rows and cells
For Each row In sheet.Rows
    For Each cell In row
        Console.WriteLine(cell.StringValue)
    Next
Next

Metoda WorkBook.LoadCSV zajmuje się identyfikacją nagłówków, tworzy wewnętrzną strukturę danych i wykonuje efektywne pod względem pamięci parsowanie -- upraszczając zarządzanie danymi od pierwszej linii kodu.

Jak odczytywać pliki CSV z niestandardowymi separatorami?

W rzeczywistych plikach CSV nie zawsze stosuje się przecinki. Średniki, pionowe kreski i tabulatory są powszechnie stosowanymi alternatywami, zwłaszcza w międzynarodowych zbiorach danych, gdzie przecinki służą jako separatory dziesiętne. IronXL obsługuje dowolne separatory dzięki elastycznym opcjom ładowania.

using IronXL;

// Load CSV with semicolon delimiter (common in European data exports)
WorkBook workbook = WorkBook.LoadCSV("european-data.csv",
    fileFormat: ExcelFileFormat.XLSX,
    listSeparator: ";");

// Load tab-separated values (TSV)
WorkBook tsvWorkbook = WorkBook.LoadCSV("export_data.tsv",
    fileFormat: ExcelFileFormat.XLSX,
    listSeparator: "\t");

// Load pipe-delimited file
WorkBook pipeWorkbook = WorkBook.LoadCSV("log_export.csv",
    fileFormat: ExcelFileFormat.XLSX,
    listSeparator: "|");

// 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,
    listSeparator: ";");

// Load tab-separated values (TSV)
WorkBook tsvWorkbook = WorkBook.LoadCSV("export_data.tsv",
    fileFormat: ExcelFileFormat.XLSX,
    listSeparator: "\t");

// Load pipe-delimited file
WorkBook pipeWorkbook = WorkBook.LoadCSV("log_export.csv",
    fileFormat: ExcelFileFormat.XLSX,
    listSeparator: "|");

// Access data normally after loading
WorkSheet sheet = workbook.DefaultWorkSheet;
decimal totalSales = sheet["B2:B10"].Sum();

Console.WriteLine($"Total sales: {totalSales}");

Imports IronXL

' Load CSV with semicolon delimiter (common in European data exports)
Dim workbook As WorkBook = WorkBook.LoadCSV("european-data.csv", fileFormat:=ExcelFileFormat.XLSX, listSeparator:=";")

' Load tab-separated values (TSV)
Dim tsvWorkbook As WorkBook = WorkBook.LoadCSV("export_data.tsv", fileFormat:=ExcelFileFormat.XLSX, listSeparator:=vbTab)

' Load pipe-delimited file
Dim pipeWorkbook As WorkBook = WorkBook.LoadCSV("log_export.csv", fileFormat:=ExcelFileFormat.XLSX, listSeparator:="|")

' Access data normally after loading
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
Dim totalSales As Decimal = sheet("B2:B10").Sum()

Console.WriteLine($"Total sales: {totalSales}")

Parametr listSeparator akceptuje dowolny ciąg znaków, dając pełną kontrolę nad zachowaniem parsowania. IronXL zachowuje wartości kolumn i typy danych podczas parsowania -- wartości numeryczne pozostają liczbami, daty pozostają jako obiekty DateTime, a formuły zachowują swoje relacje.

W przypadku plików o niespójnym formatowaniu mechanizm obsługi błędów IronXL radzi sobie z nieprawidłowymi wierszami bez powodowania awarii aplikacji, dzięki czemu prawidłowe dane są nadal przetwarzane, nawet jeśli poszczególne wiersze są problematyczne.

Jak analizować dane CSV na obiekty C#?

Przekształcanie wierszy CSV w obiekty silnie typowane upraszcza przetwarzanie danych i umożliwia operacje LINQ. IronXL ułatwia to mapowanie dzięki metodom dostępu do komórek. Poniższy kod pokazuje, jak zamapować plik CSV na listę obiektów typu za pomocą instrukcji najwyższego poziomu w .NET 10:

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

Imports IronXL

' Define a typed model matching your CSV structure
Public Class Product
    Public Property Name As String
    Public Property Price As Decimal
    Public Property Stock As Integer
    Public Property LastUpdated As DateTime?

    Public Sub New(name As String, price As Decimal, stock As Integer, lastUpdated As DateTime?)
        Me.Name = name
        Me.Price = price
        Me.Stock = stock
        Me.LastUpdated = lastUpdated
    End Sub
End Class

' Load and parse CSV file
Dim workbook As WorkBook = WorkBook.LoadCSV("inventory.csv")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet

Dim products As New List(Of Product)()

' Start from row 2 to skip the header row
For row As Integer = 2 To sheet.RowCount
    products.Add(New Product(
        Name:=sheet($"A{row}").StringValue,
        Price:=sheet($"B{row}").DecimalValue,
        Stock:=sheet($"C{row}").IntValue,
        LastUpdated:=sheet($"D{row}").DateTimeValue
    ))
Next

' Use LINQ for analysis after loading
Dim lowStock = products.Where(Function(p) p.Stock < 10).ToList()
Dim highValue = products.Where(Function(p) p.Price > 100D).OrderByDescending(Function(p) p.Price).ToList()

Console.WriteLine($"Products with low stock: {lowStock.Count}")
Console.WriteLine($"High-value products: {highValue.Count}")

Właściwości wartości typizowanych w IronXL -- StringValue, DecimalValue, IntValue, DateTimeValue -- bezpiecznie obsługują konwersje, zwracając wartości domyślne dla nieprawidłowych danych zamiast wyrzucać wyjątki. To defensywne podejście gwarantuje, że aplikacje obsługują niedoskonałe dane bez zakłóceń. Naturalnie współgra z typami rekordów C#, które zostały wprowadzone w C# 9 i zapewniają zwięzły, niezmienny model danych dla mapowanych wierszy CSV.

Strona funkcji IronXL zawiera pełny przegląd typów akcesorów wartości dostępnych do odczytu danych komórek.

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

Imports IronXL

Dim workbook As WorkBook = WorkBook.LoadCSV("sales-data.csv")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet

' Read entire columns using range notation
Dim productNames = sheet("A2:A100") _
    .Select(Function(cell) cell.StringValue) _
    .Where(Function(name) Not String.IsNullOrEmpty(name)) _
    .ToList()

' Aggregate numeric columns directly
Dim totalRevenue As Decimal = sheet("C2:C100").Sum()
Dim averageOrder As Decimal = sheet("C2:C100").Avg()

Console.WriteLine($"Products loaded: {productNames.Count}")
Console.WriteLine($"Total revenue: {totalRevenue:C}")
Console.WriteLine($"Average order value: {averageOrder:C}")

Jak konwertować CSV na format Excel w C#?

Wiele procesów biznesowych wymaga danych CSV w formacie Excel do zaawansowanej analizy, formatowania lub dystrybucji. IronXL sprawia, że konwersja ta jest prosta, przy jednoczesnym zachowaniu integralności wszystkich danych.

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

Imports IronXL

' Load CSV file
Dim csvWorkbook As WorkBook = WorkBook.LoadCSV("monthly-report.csv")
Dim sheet As WorkSheet = 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")

Konwersja zachowuje precyzję liczbową, formaty dat oraz znaki specjalne, które często powodują problemy przy ręcznych metodach konwersji. IronXL automatycznie optymalizuje strukturę wynikowego pliku Excel, tworząc wydajne pliki, które otwierają się szybko nawet w przypadku dużych zbiorów danych.

Aby uzyskać dodatkową kontrolę nad formatem wyjściowym, przewodnik dotyczący eksportu obejmuje opcje eksportu do formatów XLSX, XLS, CSV i PDF. Możesz również dowiedzieć się, jak pisać pliki Excel i tworzyć je od podstaw.

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

Imports IronXL
Imports System.Data

Dim workbook As WorkBook = WorkBook.LoadCSV("customer-export.csv")

' Convert entire workbook to DataSet
Dim dataSet As DataSet = workbook.ToDataSet()

' The first sheet becomes the first DataTable
Dim customerTable As DataTable = dataSet.Tables(0)

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

' Process with standard ADO.NET
For Each row As DataRow In customerTable.Rows
    Dim name As String = If(row("Name")?.ToString(), String.Empty)
    Dim email As String = If(row("Email")?.ToString(), String.Empty)
    Console.WriteLine($"Customer: {name} <{email}>")
Next

Jak radzisz sobie z dużymi plikami CSV i optymalizacją wydajności?

Przetwarzanie dużych plików CSV — zawierających dziesiątki tysięcy wierszy lub więcej — wymaga zwrócenia uwagi na sposób uzyskiwania dostępu do danych oraz zarządzanie pamięcią. IronXL zawiera funkcje, które pomagają w pracy z dużymi plikami.

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;
}

Imports IronXL

Dim workbook As WorkBook = WorkBook.LoadCSV("large-dataset.csv")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet

Dim rowCount As Integer = sheet.RowCount
Dim colCount As Integer = sheet.ColumnCount

Console.WriteLine($"Dataset dimensions: {rowCount} rows x {colCount} columns")

' Efficient: read entire range at once
Dim allData = sheet($"A1:{GetColumnLetter(colCount)}{rowCount}") _
    .Select(Function(cell) cell.StringValue) _
    .ToList()

' Efficient: aggregate a column without row-by-row iteration
Dim columnSum As Decimal = sheet($"B2:B{rowCount}").Sum()

Console.WriteLine($"Column B total: {columnSum}")

Private Shared Function GetColumnLetter(col As Integer) As String
    Dim result As String = String.Empty
    While col > 0
        col -= 1
        result = ChrW(AscW("A"c) + col Mod 26) & result
        col \= 26
    End While
    Return result
End Function

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

Imports IronXL

Module Module1
    Sub Main()
        Dim filePath As String = "user-uploaded-data.csv"

        Try
            Dim workbook As WorkBook = WorkBook.LoadCSV(filePath)
            Dim sheet As WorkSheet = workbook.DefaultWorkSheet

            Console.WriteLine($"Loaded {sheet.RowCount} rows from {filePath}")

            For row As Integer = 2 To sheet.RowCount
                Dim value As String = sheet($"A{row}").StringValue
                If Not String.IsNullOrWhiteSpace(value) Then
                    Console.WriteLine(value)
                End If
            Next
        Catch ex As IronXL.Exceptions.IronXLException
            Console.WriteLine($"IronXL error reading {filePath}: {ex.Message}")
        Catch ex As IOException
            Console.WriteLine($"File access error: {ex.Message}")
        End Try
    End Sub
End Module

Jak uzyskać licencję na IronXL?

IronXL wymaga klucza licencyjnego do użytkowania w środowiskach produkcyjnych. Dostępna jest bezpłatna licencja próbna do oceny, a licencje komercyjne są dostępne dla indywidualnych programistów, zespołów i organizacji.

Zastosuj klucz licencyjny w swojej aplikacji przed wykonaniem jakichkolwiek wywołań IronXL:

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

Imports 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") Then
    Console.WriteLine("IronXL license is active.")
End If

' Now use IronXL normally
Dim workbook As WorkBook = WorkBook.LoadCSV("data.csv")
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
Console.WriteLine($"Loaded {sheet.RowCount} rows.")

Aby zapoznać się z opcjami wersji próbnej i licencjonowania, odwiedź stronę licencyjną IronXL.

Dlaczego IronXL jest właściwym wyborem do przetwarzania plików CSV?

IronXL zmienia odczytywanie plików CSV w języku C# z żmudnego zadania parsowania w prostą operację. Biblioteka obsługuje typowe skrajne przypadki, w których ręczne parsowanie daje błędy — wbudowane przecinki, znaki nowej linii wewnątrz pól w cudzysłowie, niespójne separatory, różnice w kodowaniu i nieprawidłowo sformatowane wiersze — bez konieczności pisania niestandardowego kodu dla każdego scenariusza. Niezależnie od tego, czy potrzebujesz szybkiego, jednorazowego importu danych, czy też potoku produkcyjnego przetwarzającego tysiące plików dziennie, ten sam interfejs API działa w obu kontekstach.

Ręczne parsowanie CSV z string.Split lub StreamReader szybko się łamie, gdy pola w cudzysłowie zawierają znak separatora lub gdy w polach pojawiają się łamania linii. IronXL domyślnie obsługuje te przypadki poprawnie, zgodnie ze specyfikacją CSV dotyczącą obsługi pól w cudzysłowie i sekwencji escape.

Kluczowe zalety, które wyróżniają IronXL w pracy z plikami CSV w .NET 10:

• Brak zależności od pakietu Office: wdrożenia serwerowe i chmurowe działają bez konieczności instalowania pakietu Microsoft Office ani żadnej interoperacyjności COM
• Własne separatory: Każdy znak lub ciąg separatora jest obsługiwany za pomocą parametru listSeparator
• Bezpieczny typowo dostęp do komórek: Akcesory StringValue, DecimalValue, IntValue i DateTimeValue zwracają bezpieczne wartości domyślne zamiast wyrzucać błędy dla złych danych
• Operacje na zakresach: agreguj i wyszukuj dane w różnych zakresach bez iteracji wiersz po wierszu
• Konwersja formatów: wczytaj plik CSV i zapisz go jako XLSX, XLS, PDF lub w innym formacie w ramach jednego procesu
• Integracja z DataSet: Konwersja załadowanych skoroszytów do DataSet / DataTable do operacji z ADO.NET i bazami danych
• Wielopłatformowość: Działa na systemach Windows, Linux, macOS, w środowisku Docker oraz w chmurze bez konieczności wprowadzania zmian

Dokumentacja IronXL oraz przewodnik po formatowaniu komórek zawierają dalsze szczegóły dotyczące formatowania, obsługi formuł oraz zaawansowanych operacji w skoroszytach.

Gotowy do pewnego obchodzenia się z plikami CSV? Zacznij od bezpłatnej wersji próbnej i poznaj pełen zestaw funkcji IronXL.