Cómo leer archivos CSV en C# usando IronXL

¿Cuál es la forma más sencilla de leer archivos CSV en .NET?

El enfoque más sencillo utiliza WorkBook.LoadCSV para importar datos CSV directamente a una estructura de libro de trabajo. Este único método maneja el análisis, la detección de delimitadores y la organización de datos automáticamente -- no es necesario crear un StreamReader o procesar manualmente cada línea de cadena.

Instale IronXL a través de la consola del gestor de paquetes NuGet en Visual Studio. Abra su proyecto .NET y ejecútelo:

Install-Package IronXL.Excel

using IronXL;

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

using IronXL;

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

Imports IronXL

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

¿Cómo se compara el análisis manual de CSV con el uso de una biblioteca?

Comprender la complejidad que IronXL elimina ayuda a aclarar su valor. El análisis sintáctico manual de CSV requiere manejar múltiples casos extremos que parecen sencillos pero que rápidamente se convierten en problemáticos en cualquier proyecto.

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

¿Cómo se manejan diferentes delimitadores de CSV?

Los archivos CSV no siempre utilizan comas como separadores. En las exportaciones de sistemas europeos se utilizan con frecuencia puntos y comas, ya que las comas aparecen en los números decimales. Los archivos de valores separados por tabulaciones (TSV) y delimitados por barras verticales aparecen habitualmente en las exportaciones de datos de diversas aplicaciones y sistemas heredados.

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

El parámetro listDelimiter en LoadCSV acepta cualquier carácter único o secuencia de escape como separador de campo. Los caracteres de tabulación utilizan la secuencia de escape \t. Tras la carga, la estructura de datos se mantiene coherente independientemente del formato original, lo que facilita el procesamiento de archivos CSV de múltiples fuentes con delimitadores variables. El valor predeterminado para la mayoría de los archivos CSV es una coma, pero esta flexibilidad permite gestionar cualquier variación que se presente en un proyecto.

¿Cuáles son los mejores métodos para convertir CSV a DataTable?

Convertir datos CSV a un DataTable permite la integración con operaciones de base de datos, vinculación de datos en aplicaciones de interfaz de usuario y consultas LINQ. El método ToDataTable realiza esta conversión con una sola llamada.

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

El parámetro booleano en ToDataTable determina si la primera fila debe convertirse en encabezados de columna (true) o en datos (false). Cuando se establece en true, las columnas del DataTable resultante llevan los nombres de los encabezados del archivo CSV, lo que permite un acceso intuitivo a los datos usando nombres de columna como row["Name"].

¿Cómo se convierten archivos CSV a formato Excel?

Una de las capacidades más destacadas de IronXL es la conversión de datos CSV a formatos Excel adecuados. Esto permite añadir fórmulas, formato, gráficos y varias hojas de cálculo a datos CSV originalmente planos, algo que no se puede lograr solo con la salida 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")

El método SaveAs determina automáticamente el formato de salida basado en la extensión del archivo. XLSX crea archivos modernos de Office Open XML compatibles con Excel 2007 y versiones posteriores, mientras que XLS produce documentos en formato de intercambio binario heredado para aplicaciones más antiguas.

¿Cómo se accede a valores de celdas específicos en datos CSV?

Además de iterar a través de todos los registros, IronXL proporciona acceso directo a las celdas mediante un direccionamiento familiar al estilo Excel. Esto permite la extracción selectiva de datos y la recuperación de valores seguros en diferentes tipos de datos.

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

El direccionamiento de las celdas sigue las convenciones de Excel, donde las letras representan columnas CSV (A, B, C) y los números representan posiciones de índice de fila (1, 2, 3). La clase Cell proporciona accesores específicos de tipo, incluyendo StringValue, IntValue, DecimalValue, BoolValue y DateTimeValue. Estos accesores gestionan el análisis y la conversión automáticamente, lo que elimina la conversión de tipos manual en comparación con el almacenamiento de todo como valores de cadena.

La selección de rangos usando una notación como A2:A10 devuelve un objeto Range que admite iteración, funciones agregadas y operaciones masivas. Esto resulta valioso a la hora de extraer columnas específicas o regiones de datos rectangulares de archivos CSV de gran tamaño. Por ejemplo, se puede crear una lista de valores a partir de una columna específica o escribir datos filtrados en otro archivo. Consulte la guía de la gama IronXL para ver más ejemplos.

¿Cómo se gestionan los errores al leer archivos CSV?

Las aplicaciones de producción requieren código defensivo en torno a las operaciones con archivos. La lectura de CSV puede fallar por varias razones: el archivo no existe, se deniega el acceso, los datos están mal formados o la memoria es insuficiente para archivos muy grandes. Envolver las llamadas de IronXL en bloques try/catch y validar las rutas antes de cargar asegura un comportamiento fiable en todos los entornos.

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

¿Cómo se leen archivos CSV de gran tamaño sin problemas de memoria?

En el caso de archivos con cientos de miles de filas, cargar todo el conjunto de datos en la memoria de una sola vez puede resultar poco práctico. IronXL lee todo el archivo en un objeto WorkBook, que mantiene todos los datos en memoria. Para escenarios de ETL (Extracción, Transformación, Carga) a gran escala, una estrategia práctica es procesar el CSV por lotes dividiendo el archivo fuente antes de cargar o transmitiendo filas desde un StreamReader y escribiendo trozos en libros de trabajo separados.

La documentación de IronXL sobre la lectura de archivos Excel aborda consideraciones de rendimiento para grandes cargas de trabajo. Para CSV específicamente, la estructura línea por línea del formato CSV significa que un simple File.ReadAllLines con agrupamiento manual proporciona un impacto predecible en la memoria cuando el conjunto de datos es demasiado grande para una carga completa en memoria.

¿Cuales son tus próximos pasos?

La lectura de archivos CSV en .NET requiere un esfuerzo mínimo si se utiliza el enfoque adecuado. El método LoadCSV de IronXL maneja la complejidad del análisis automáticamente, admite varios delimitadores, proporciona acceso inmediato a datos estructurados y convierte a Excel o DataTable con llamadas a métodos únicos. Tanto si está creando una aplicación ASP.NET Core, una API web .NET Core o un proyecto de consola, la biblioteca simplifica el procesamiento de CSV de principio a fin.

Explora más capacidades de IronXL para ampliar lo que has aprendido aquí:

• Página del producto IronXL: lista completa de características y licencias
• Cómo leer archivos Excel en C#: ampliar los conocimientos de CSV a XLSX/XLS
• Cómo escribir archivos Excel en C#: crear y exportar hojas de cálculo mediante programación
• Exportación de DataTable y DataSet: conexión con flujos de trabajo de ADO.NET
• Licencias de IronXL: opciones de licencia para la implementación

Inicie una prueba gratuita para experimentar cómo IronXL simplifica la lectura de archivos CSV en sus proyectos .NET. Para la implementación en producción, las opciones de licencia incluyen derechos de uso perpetuos y un año de soporte técnico.