Lector de archivos CSV de C#: Analizar y procesar datos CSV con IronXL

¿Cómo instalas IronXL para la lectura de CSV?

Incorporar IronXL en tu proyecto lleva solo un momento. Puedes instalarlo a través del Administrador de Paquetes NuGet en Visual Studio, o mediante la línea de comandos usando el CLI de .NET o la Consola del Administrador de Paquetes NuGet en PowerShell. Ambos enfoques instalan el mismo paquete y funcionan con cualquier tipo de proyecto .NET 10.

# .NET CLI
dotnet add package IronXL.Excel

# NuGet Package Manager Console
Install-Package IronXL.Excel

# .NET CLI
dotnet add package IronXL.Excel

# NuGet Package Manager Console
Install-Package IronXL.Excel

Para obtener más detalles sobre las opciones de instalación y configuración, consulte la documentación de instalación de IronXL.

Una vez instalado, leer tu primer archivo CSV requiere muy poco código. El ejemplo a continuación utiliza declaraciones de nivel superior de .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

El método WorkBook.LoadCSV gestiona la identificación de cabeceras, crea una estructura de datos interna y realiza un análisis sintáctico eficiente en memoria, simplificando la gestión de datos desde la primera línea de código.

Tutorial de lectura de archivos CSV en C#: Analizar y convertir datos CSV con IronXL: Imagen 1 - Instalación de IronXL en NuGet

¿Cómo lees archivos CSV con delimitadores personalizados?

Los archivos CSV del mundo real no siempre usan comas. Punto y coma, tuberías y tabulaciones son alternativas comunes, especialmente en conjuntos de datos internacionales donde las comas se utilizan como separadores decimales. IronXL maneja cualquier delimitador a través de sus opciones de carga flexibles.

using IronXL;

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

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

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

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

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

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

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

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

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

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

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

El parámetro listDelimitador acepta cualquier cadena, lo que le da un control total sobre el comportamiento del análisis sintáctico. IronXL conserva los valores de las columnas y los tipos de datos durante el análisis: los valores numéricos siguen siendo números, las fechas permanecen como objetos DateTime y las fórmulas mantienen sus relaciones.

Para archivos con formato inconsistente, el manejo de errores de IronXL gestiona las filas malformadas sin bloquear la aplicación, por lo que los datos válidos continúan siendo procesados incluso cuando filas individuales son problemáticas.

Tutorial de lectura de archivos CSV en C#: Analizar y convertir datos CSV con IronXL: Imagen 2 - Ejemplo de salida para comenzar

¿Cómo analizas datos CSV en objetos C#?

Transformar filas CSV en objetos fuertemente tipados simplifica el procesamiento de datos y permite operaciones LINQ. IronXL simplifica esta asignación gracias a sus métodos de acceso a celdas. El siguiente código demuestra cómo mapear un archivo CSV en una lista de objetos tipados usando declaraciones de nivel superior de .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}")

Las propiedades de valores tipificados de IronXL -- StringValue, DecimalValue, IntValue, DateTimeValue -- manejan las conversiones de forma segura, devolviendo valores predeterminados para datos no válidos en lugar de lanzar excepciones. Este enfoque defensivo asegura que las aplicaciones manejen datos imperfectos sin interrupción. Se empareja naturalmente con tipos de registro en C#, que fueron introducidos en C# 9 y proporcionan un modelo de datos conciso e inmutable para las filas CSV mapeadas.

La página de características de IronXL proporciona un resumen completo de los tipos de acceso a valores disponibles para leer datos de celdas.

Tutorial de lectura de archivos CSV en C#: Analizar y convertir datos CSV con IronXL: Imagen 3 - Salida para leer diferentes delimitadores

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

¿Cómo conviertes CSV al formato Excel en C#?

Muchos flujos de trabajo empresariales requieren datos CSV en formato Excel para un análisis avanzado, formato o distribución. IronXL facilita esta conversión al tiempo que preserva toda la integridad de los datos.

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

La conversión preserva la precisión numérica, los formatos de fecha y los caracteres especiales que a menudo causan problemas con los métodos de conversión manual. IronXL optimiza automáticamente la estructura del archivo Excel resultante, creando archivos eficientes que se abren rápidamente incluso con grandes conjuntos de datos.

Para un mayor control sobre el formato de salida, la guía práctica de exportación incluye opciones como la exportación a XLSX, XLS, CSV y PDF. También puedes aprender a escribir archivos de Excel y a crear archivos de Excel desde cero.

Tutorial de lectura de archivos CSV en C#: Analizar y convertir datos CSV con IronXL: Imagen 4 - Análisis de la salida de datos CSV

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 DataTabulaciónle
DataTabulaciónle customerTabulaciónle = dataSet.Tabulaciónles[0];

Console.WriteLine($"Rows loaded: {customerTabulaciónle.Rows.Count}");
Console.WriteLine($"Columns: {customerTabulaciónle.Columns.Count}");

// Process with standard ADO.NET
foreach (DataRow row in customerTabulaciónle.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 DataTabulaciónle
DataTabulaciónle customerTabulaciónle = dataSet.Tabulaciónles[0];

Console.WriteLine($"Rows loaded: {customerTabulaciónle.Rows.Count}");
Console.WriteLine($"Columns: {customerTabulaciónle.Columns.Count}");

// Process with standard ADO.NET
foreach (DataRow row in customerTabulaciónle.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

¿Cómo manejas archivos CSV grandes y optimizas el rendimiento?

Procesar archivos CSV grandes, con decenas de miles de filas o más, requiere atención a cómo se accede a los datos y cómo se maneja la memoria. IronXL incluye características que ayudan con escenarios de archivos grandes.

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

¿Cómo obtienes una licencia para IronXL?

IronXL requiere una clave de licencia para su uso en entornos de producción. Una licencia de prueba gratuita está disponible para evaluación, y las licencias comerciales están disponibles para desarrolladores individuales, equipos y organizaciones.

Aplica la clave de licencia en tu aplicación antes de realizar cualquier llamada 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.")

Para opciones de prueba y licencias, visita la página de licencias de IronXL.

¿Qué hace de IronXL la elección correcta para el procesamiento de CSV?

IronXL convierte la lectura de archivos CSV en C# de una tarea tediosa de análisis a una operación sencilla. La biblioteca maneja los casos marginales comunes que el análisis manual no puede resolver correctamente: comas incrustadas, saltos de línea dentro de campos entrecomillados, delimitadores inconsistentes, variaciones de codificación y filas mal formadas, sin requerir código personalizado para cada escenario. Ya sea que necesites una importación de datos rápida y única o una tubería de producción procesando miles de archivos por día, la misma API funciona en ambos contextos.

El análisis sintáctico manual de CSV con string.Split o StreamReader se rompe rápidamente cuando los campos entrecomillados contienen el carácter delimitador, o cuando aparecen saltos de línea dentro de los valores de campo. IronXL maneja estos casos correctamente por defecto, siguiendo la especificación CSV para el manejo de campos entrecomillados y secuencias de escape.

Las ventajas clave que destacan a IronXL para el trabajo con CSV en .NET 10:

• Sin dependencia de Office: Los despliegues en servidor y en la nube funcionan sin instalar Microsoft Office o cualquier interop COM
• Delimitadores personalizados: Se admite cualquier carácter o cadena delimitadora a través del parámetro listDelimitador
• Acceso a celdas seguro: los accesores StringValue, DecimalValue, IntValue, y DateTimeValue devuelven valores por defecto seguros en lugar de arrojar datos erróneos
• Operaciones de rango: Agrega y consulta datos a través de rangos sin iteración fila por fila
• Conversión de formato: Carga CSV y guarda como XLSX, XLS, PDF u otros formatos en un solo flujo de trabajo
• Integración de DataSet: Convierta los libros de trabajo cargados en DataSet / DataTabulaciónle para ADO.NET y operaciones de base de datos
• Multiplataforma: Funciona en Windows, Linux, macOS, Docker y entornos de nube sin cambios

La documentación de IronXL y la guía de formato de celdas proporcionan más detalles sobre el formato, la compatibilidad con fórmulas y las operaciones avanzadas de los libros de trabajo.

¿Listo para manejar archivos CSV con confianza? Comienza con una prueba gratuita y explora el conjunto completo de características de IronXL.