Ícono de mensaje
Saltar al pie de página
  1. Iron Software
  2. Blog de IronXL
  3. Usando IronXL
  4. Leer Csv Net
USANDO IRONXL

Cómo leer archivos CSV en C# usando IronXL

Jordi Bardia
Jordi Bardia
Actualizado:

La lectura de archivos CSV en C# .NET se convierte en algo trivial con IronXL: una sola llamada a un método carga datos separados por comas en un libro de trabajo estructurado sin necesidad de código de análisis personalizado. Esta guía repasa todas las técnicas que necesitas: carga básica, delimitadores personalizados, conversión a DataTable, acceso a nivel de celda, gestión de errores y exportación a formato Excel.

¿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 se encarga automáticamente del análisis sintáctico, la detección de delimitadores y la organización de los datos; no es necesario crear un StreamReader ni 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
dotnet add package IronXL
Install-Package IronXL
dotnet add package IronXL
SHELL

Leer CSV .NET: El enfoque más sencillo en C# utilizando IronXL: Imagen 1 - Instalación

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
$vbLabelText   $csharpLabel

Entrada

Leer CSV en .NET: el enfoque más sencillo en C# utilizando IronXL: Imagen 2 - Ejemplo de entrada CSV

Resultado

Leer CSV .NET: El enfoque más sencillo en C# utilizando IronXL: Imagen 3 - Salida de la consola

El método LoadCSV acepta tres parámetros: la ruta del archivo, el formato Excel de destino para la representación interna y el carácter delimitador que separa los valores. Una vez cargado, se puede acceder al contenido del CSV a través de la propiedad DefaultWorkSheet, que proporciona la hoja de cálculo principal que contiene todos los registros importados.

La estructura de bucles anidados recorre cada Row de la hoja de cálculo y, a continuación, cada Cell de esa fila. La propiedad Value devuelve el contenido de la celda como un objeto, mientras que el carácter de tabulación crea una separación legible entre columnas en la salida de la consola. Este patrón funciona de forma idéntica tanto si el archivo de origen contiene 10 filas como si se trata de grandes archivos CSV con miles de registros.

IronXL funciona en .NET Framework, .NET Core y .NET 5+ sin necesidad de instalar Microsoft Office, lo que lo hace ideal para proyectos de ASP.NET Core y .NET Core Web API. La biblioteca está disponible en NuGet y se integra perfectamente en cualquier tipo de proyecto. Si prefieres comprender qué te ofrece una biblioteca, la siguiente sección explica en qué consiste el análisis sintáctico manual.

¿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
$vbLabelText   $csharpLabel

Entrada

Leer CSV en .NET: el enfoque más sencillo en C# utilizando IronXL: Imagen 4 - Entrada CSV

Resultado

Leer CSV en .NET: el enfoque más sencillo en C# utilizando IronXL: Imagen 5 - Resultado del análisis manual de CSV

El enfoque manual falla cuando los campos CSV contienen comas incrustadas dentro de cadenas entre comillas, una situación habitual en los campos de dirección o en las descripciones. Para leer los archivos correctamente es necesario gestionar campos entre comillas, comillas escapadas, valores multilínea y codificaciones variables. Crear tu propio analizador sintáctico implica crear un StreamReader, implementar la lógica de la máquina de estados y gestionar tú mismo todo el proceso de lectura. Es una cantidad considerable de texto repetitivo para algo que debería caber en una sola línea.

La alternativa IronXL gestiona todos los casos extremos automáticamente:

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
$vbLabelText   $csharpLabel

La clase WorkBook gestiona internamente la complejidad del análisis sintáctico, lo que le permite centrarse en trabajar con los datos en lugar de en extraerlos. Puede obtener más información sobre todas las capacidades de IronXL en la descripción general de las características de IronXL.

¿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")
$vbLabelText   $csharpLabel

El parámetro listDelimiter en LoadCSV acepta cualquier carácter único o secuencia de escape como separador de campos. 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.

Entrada

Leer CSV .NET: El enfoque más sencillo en C# utilizando IronXL: Imagen 6 - Entrada de archivo CSV delimitado por punto y coma

Resultado

Leer CSV .NET: el enfoque más sencillo en C# utilizando IronXL: Imagen 7 - Salida delimitada por punto y coma

Las propiedades RowCount y ColumnCount permiten verificar rápidamente que el archivo se ha cargado correctamente, lo que resulta especialmente útil cuando se trabaja con fuentes de datos desconocidas o se validan las cargas de los usuarios en una aplicación ASP.NET Core.

Consideraciones sobre la codificación

Al leer archivos con caracteres no ASCII, como letras acentuadas en datos en francés o alemán, IronXL lee automáticamente la codificación a partir de la marca de orden de bytes (BOM) del archivo. En el caso de los archivos sin tabla de caracteres (BOM), es posible que sea necesario verificar la codificación en el archivo original. La documentación de Microsoft sobre codificación de archivos ofrece una referencia exhaustiva sobre los tipos de codificación en .NET.

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

La conversión de datos CSV a DataTable permite la integración con operaciones de bases de datos, el enlace de datos en aplicaciones de interfaz de usuario y las 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
$vbLabelText   $csharpLabel

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 resultantes de DataTable contienen los nombres de los encabezados del archivo CSV, lo que permite un acceso intuitivo a los datos utilizando nombres de columna como row["Name"].

Uso de DataTable para la integración de bases de datos y la interfaz de usuario

Esta conversión resulta valiosa para escenarios que requieren inserciones masivas en bases de datos utilizando SqlBulkCopy, rellenar controles DataGridView en aplicaciones Windows Forms o realizar transformaciones de datos complejas con expresiones LINQ. El formato DataTable también se integra de forma natural con Entity Framework y otras herramientas ORM en su proyecto de API web de .NET Core. Puede obtener más información sobre los patrones de exportación de DataTable en la guía de IronXL DataTable.

Para conocer otros patrones relacionados con el trabajo con datos tabulares en .NET, la descripción general de ADO.NET de Microsoft es una referencia de autoridad.

¿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")
$vbLabelText   $csharpLabel

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

Entrada

Leer CSV en .NET: el enfoque más sencillo en C# utilizando IronXL: Imagen 8 - Datos CSV

Resultado

Leer CSV .NET: El enfoque más sencillo en C# utilizando IronXL: Imagen 9 - Salida en Excel

Leer CSV .NET: El enfoque más sencillo en C# utilizando IronXL: Imagen 10 - Salida de CSV a Excel

Este flujo de trabajo resulta especialmente útil cuando las exportaciones CSV desde bases de datos o API necesitan mejoras antes de su distribución a los usuarios. Tras la conversión, el archivo de Excel puede recibir formato adicional, fórmulas o combinarse con otras hojas de cálculo, todo ello mediante programación gracias a las capacidades de edición de IronXL. El proceso es totalmente programable, lo que lo hace adecuado para flujos de trabajo de generación de informes automatizados o tareas programadas.

¿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
$vbLabelText   $csharpLabel

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 para cada 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 mediante notación como A2:A10 devuelve un objeto Range que admite iteración, funciones de agregación 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 a IronXL en bloques try/catch y validar las rutas antes de cargarlas garantiza 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
$vbLabelText   $csharpLabel

Patrones de validación para datos CSV

Además de detectar excepciones, la validación del recuento de filas y columnas tras la carga ayuda a detectar archivos truncados o cambios inesperados en el esquema. Comprobar sheet.RowCount con respecto a un mínimo esperado, o verificar que los encabezados de columna específicos existan en la primera fila, permite detectar problemas de datos en una fase temprana del proceso antes de que se propaguen hacia abajo. La guía de gestión de excepciones de Microsoft abarca las prácticas recomendadas para la gestión estructurada de errores en .NET.

En el caso de aplicaciones que procesan archivos CSV subidos por los usuarios, compruebe siempre el tamaño del archivo antes de cargarlo, depure los nombres de los archivos y restrinja los tipos de contenido permitidos en el punto final de carga. Estas precauciones evitan el agotamiento de recursos debido a archivos de gran tamaño y protegen contra ataques de recorrido de rutas.

IronXL incluye su propio tipo de excepción IronXl.Exceptions.IronXLException para errores específicos de la biblioteca IronXL, lo que facilita distinguir los fallos de análisis sintáctico de los problemas generales de entrada/salida. Puede encontrar más detalles en la referencia de la API de IronXL.

¿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 (Extract, Transform, Load) a gran escala, una estrategia práctica consiste en procesar el CSV por lotes dividiendo el archivo de origen antes de cargarlo, o transmitiendo filas desde un StreamReader y escribiendo fragmentos 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. En el caso concreto del CSV, la estructura línea por línea del formato CSV implica que un simple File.ReadAllLines con procesamiento por lotes manual proporciona un consumo de memoria predecible cuando el conjunto de datos es demasiado grande para una única carga en memoria.

Comparación de IronXL con otras bibliotecas CSV

IronXL no es la única biblioteca CSV for .NET. CsvHelper es una alternativa de código abierto muy utilizada que se especializa en streaming, mapeo de registros y configuración basada en atributos. La diferencia clave es el alcance: CsvHelper se centra exclusivamente en CSV, mientras que IronXL gestiona todo el ecosistema de hojas de cálculo —leyendo, escribiendo y convirtiendo XLSX, XLS, CSV y otros formatos a través de una API unificada—. Si su aplicación ya utiliza IronXL para operaciones con Excel, gestionar archivos CSV con la misma biblioteca evita una dependencia adicional. Si el CSV es el único formato con el que trabajas y necesitas compatibilidad con streaming, una biblioteca CSV de streaming puede resultarte más útil.

IronXL frente a CsvHelper: diferencias clave para la lectura de CSV en .NET
Función IronXL CsvHelper
lectura de CSV Sí Sí
Compatibilidad con Excel (XLSX/XLS) Sí No
Transmisión de archivos de gran tamaño Solo en memoria Sí (streaming)
Delimitadores personalizados Sí (listDelimiter) Sí (configuración)
Conversión a DataTable Integrado (ToDataTable) Asignación manual
Licencia Comercial Código abierto (MS-PL)

¿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 gestiona automáticamente la complejidad del análisis sintáctico, admite varios delimitadores, proporciona acceso inmediato a datos estructurados y convierte a Excel o DataTable con una sola llamada de método. 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í:

Inicie una prueba gratuita para descubrir 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.

Preguntas Frecuentes

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

La forma más sencilla de leer archivos CSV en C# es utilizar IronXL, que proporciona un método sencillo y eficaz para manejar datos CSV.

¿Puede IronXL manejar archivos CSV grandes de manera eficiente?

Sí, IronXL está diseñado para manejar archivos CSV grandes, lo que lo hace adecuado para procesar conjuntos de datos extensos sin problemas de rendimiento.

¿Es IronXL compatible con las aplicaciones .NET?

IronXL es totalmente compatible con las aplicaciones .NET, lo que permite a los desarrolladores integrar fácilmente las funciones de lectura de CSV en sus proyectos de C#.

¿Es IronXL compatible con la lectura de archivos CSV con diferentes delimitadores?

IronXL es compatible con la lectura de archivos CSV con varios delimitadores, lo que proporciona flexibilidad para manejar archivos con diferentes formatos.

¿Puede IronXL analizar archivos CSV con encabezados?

Sí, IronXL puede analizar archivos CSV con encabezados, lo que le permite acceder fácilmente a los datos por nombres de columna.

¿Cómo simplifica IronXL la manipulación de datos CSV?

IronXL simplifica la manipulación de datos CSV ofreciendo métodos intuitivos para leer, editar y escribir datos CSV directamente en C#.

¿Existe soporte para leer archivos CSV de forma asíncrona en IronXL?

IronXL proporciona soporte para operaciones asíncronas, lo que le permite leer archivos CSV sin bloquear el hilo principal de la aplicación.

¿Puede IronXL convertir datos CSV a formato Excel?

IronXL puede convertir datos CSV al formato Excel, lo que le permite aprovechar las funciones de Excel para el análisis y la presentación de datos.

¿Tiene IronXL alguna dependencia para leer archivos CSV?

IronXL es una biblioteca independiente que no requiere dependencias externas para leer archivos CSV, lo que simplifica el proceso de configuración en sus proyectos.

¿Se puede utilizar IronXL para exportar datos de CSV a otros formatos?

Sí, IronXL puede exportar datos de CSV a varios formatos, incluido Excel, lo que proporciona versatilidad en el manejo de datos y la generación de informes.

Jordi Bardia
Jordi Bardia
  Chatea con el equipo de ingeniería ahora
Ingeniero de Software
Jordi es más competente en Python, C# y C++. Cuando no está aprovechando sus habilidades en Iron Software, está programando juegos. Compartiendo responsabilidades para pruebas de productos, desarrollo de productos e investigación, Jordi agrega un valor inmenso a la mejora continua del producto. La experiencia variada lo mantiene ...
Leer más

Artículos Relacionados
Prueba de 30 días → Producto completo. Sin límites. Sin tarjeta. Prueba gratis

Equipo de soporte de Iron

Estamos disponibles online las 24 horas, 5 días a la semana.
Chat
Email
Llámame