Pruebe en producción sin marcas de agua.
Funciona donde lo necesite.
Obtén 30 días de producto totalmente funcional.
Ténlo en funcionamiento en minutos.
Acceso completo a nuestro equipo de asistencia técnica durante la prueba del producto
En este tutorial para principiantes, vamos a ver cómo leer archivos CSV en una lista en C# usando la biblioteca IronXL. Bueno, esta es una de las cosas más básicas que necesitas saber en cualquier lenguaje de programación ya que los archivos CSV son una forma muy común de almacenar datos y transferirlos de un sistema o aplicación a otro. Cubriremos todos los aspectos, desde la configuración del proyecto hasta el análisis eficaz de archivos CSV.
Crear un proyecto de consola C# en Visual Studio.
Instale la biblioteca CSV de C# mediante el gestor de paquetes NuGet.
Cargue el archivo CSV usando el método WorkBook.LoadCSV
.
Leer los valores de los datos del archivo y rellenar la lista.
Abrir Visual Studio: Inicia Visual Studio en tu computadora.
Crear un nuevo proyecto: Haz clic en "Crear un nuevo proyecto". Se abre una ventana en la que puede seleccionar el tipo de proyecto.
Seleccionar tipo de proyecto: Elija "Aplicación de consola (.NET Core)" como su tipo de proyecto para mayor simplicidad.
Nombre su proyecto: Nombre su proyecto CSVFileReader.
Elige ubicación: Selecciona una ubicación adecuada en tu dispositivo para guardar este proyecto.
Abrir el Administrador de Paquetes NuGet: En Visual Studio, vaya al menú "Herramientas", luego seleccione "Administrador de Paquetes NuGet" y elija "Administrar paquetes NuGet para la solución...".
Buscar IronXL: Haz clic en la pestaña "Explorar" y busca "IronXL.Excel".
Instalar IronXL: Encuentra el paquete de IronXL en los resultados de búsqueda, selecciónalo y haz clic en "Instalar". Asegúrate de aceptar cualquier acuerdo de licencia y revisar los cambios.
Verificar instalación: Después de la instalación, deberías ver IronXL referenciado en las referencias de tu proyecto.
Ahora, su proyecto CSVFileReader está configurado con la biblioteca IronXL, y está listo para comenzar a leer y procesar archivos CSV en C#. Esta configuración constituye la base para las tareas de lectura de CSV que realizaremos en las secciones siguientes de este tutorial.
Con el proyecto configurado y la librería IronXL instalada, centrémonos en analizar y procesar archivos CSV. Trabajaremos dentro del archivo Program.cs
, que se genera automáticamente en su proyecto CSVFileReader.
Antes de poder leer cualquier dato, necesitamos saber dónde se encuentra nuestro archivo CSV. Define una variable en el método Main
para almacenar la ruta del archivo.
string filename = "csvfile.csv"; // Replace with your actual file path
string filename = "csvfile.csv"; // Replace with your actual file path
Dim filename As String = "csvfile.csv" ' Replace with your actual file path
IronXL hace que sea sencillo cargar un archivo CSV. Use el método WorkBook.LoadCSV
para leer el archivo CSV en un objeto WorkBook
.
var csv = WorkBook.LoadCSV(filename);
var csv = WorkBook.LoadCSV(filename);
Dim csv = WorkBook.LoadCSV(filename)
Crea una clase que represente la estructura de datos en tu archivo CSV. Por ejemplo, si tu CSV contiene información sobre personas, define una clase Person
así:
public class Person
{
public string Name { get; set; }
public int Age { get; set; }
}
public class Person
{
public string Name { get; set; }
public int Age { get; set; }
}
Public Class Person
Public Property Name() As String
Public Property Age() As Integer
End Class
En este paso, analizaremos el archivo CSV y llenaremos una List<Person>
con los datos. Estamos utilizando IronXL para manejar la lectura CSV, y la clave es procesar correctamente cada fila o línea var del CSV, teniendo en cuenta las cabeceras y cualquier fila potencialmente vacía. Aquí tienes un desglose detallado del código:
List<Person> people = new List<Person>();
bool isFirstRow = true; // Add a flag to check for the first row
foreach (var row in csv.WorkSheets [0].Rows)
{
if (isFirstRow)
{
isFirstRow = false; // Set the flag to false after skipping the first row
continue;
}
if (row.IsEmpty) continue; // Skip empty rows
var cells = row.ToArray();
var person = new Person()
{
Name = cells [0].StringValue,
Age = int.Parse(cells [1].StringValue) // Ensure this is a numeric value
};
people.Add(person);
}
List<Person> people = new List<Person>();
bool isFirstRow = true; // Add a flag to check for the first row
foreach (var row in csv.WorkSheets [0].Rows)
{
if (isFirstRow)
{
isFirstRow = false; // Set the flag to false after skipping the first row
continue;
}
if (row.IsEmpty) continue; // Skip empty rows
var cells = row.ToArray();
var person = new Person()
{
Name = cells [0].StringValue,
Age = int.Parse(cells [1].StringValue) // Ensure this is a numeric value
};
people.Add(person);
}
Dim people As New List(Of Person)()
Dim isFirstRow As Boolean = True ' Add a flag to check for the first row
For Each row In csv.WorkSheets (0).Rows
If isFirstRow Then
isFirstRow = False ' Set the flag to false after skipping the first row
Continue For
End If
If row.IsEmpty Then
Continue For ' Skip empty rows
End If
Dim cells = row.ToArray()
Dim person As New Person() With {
.Name = cells (0).StringValue,
.Age = Integer.Parse(cells (1).StringValue)
}
people.Add(person)
Next row
En este proceso de análisis, primero inicializamos una List<Person>
para almacenar los datos analizados y usamos un indicador booleano isFirstRow
para omitir la fila de encabezado del archivo CSV. El bucle foreach
recorre cada fila del archivo CSV. Durante la primera iteración, la fila del encabezado se identifica y se omite, asegurando que solo se procesen las filas de datos. A continuación, comprobamos cada fila para asegurarnos de que no esté vacía utilizando row.IsEmpty
. Este paso es fundamental para evitar errores de análisis sintáctico con líneas vacías.
Para cada fila de datos, convertimos la fila en un array de celdas (row.ToArray()
) y luego creamos un objeto Person
con estos datos. Es crucial analizar y convertir correctamente los tipos de datos, como convertir la cadena "Edad" en un número entero. El objeto Person
analizado se añade a nuestra lista people
. Este enfoque asegura que solo las filas de datos válidas sean procesadas y almacenadas, manejando eficazmente problemas potenciales como cadenas no numéricas en columnas numéricas o filas vacías inesperadas.
Después de analizar los datos CSV en nuestra List<Person>
, el siguiente paso importante es mostrar y verificar los datos. Esto no sólo ayuda a garantizar que nuestro análisis sintáctico se ha realizado correctamente, sino que también nos permite observar el resultado y realizar una rápida comprobación de la calidad de los datos. A continuación te explicamos cómo puedes ponerlo en práctica:
foreach (var person in people)
{
Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");
}
foreach (var person in people)
{
Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");
}
For Each person In people
Console.WriteLine($"Name: {person.Name}, Age: {person.Age}")
Next person
Aquí está el código completo de Program.cs:
using IronXL;
public class Person
{
public string Name { get; set; }
public int Age { get; set; }
}
class Program
{
static void Main(string [] args)
{
string filename = @"C:\Users\tayya\Downloads\sample_data.csv"; // Replace with your actual file path
var csv = WorkBook.LoadCSV(filename);
List<Person> people = new List<Person>();
bool isFirstRow = true; // Add a flag to check for the first row
foreach (var row in csv.WorkSheets [0].Rows)
{
if (isFirstRow)
{
isFirstRow = false; // Set the flag to false after skipping the first row
continue;
}
if (row.IsEmpty) continue; // Skip empty rows
var cells = row.ToArray();
var person = new Person()
{
Name = cells [0].StringValue,
Age = int.Parse(cells [1].StringValue) // Ensure this is a numeric value
};
people.Add(person);
}
foreach (var person in people)
{
Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");
}
}
}
using IronXL;
public class Person
{
public string Name { get; set; }
public int Age { get; set; }
}
class Program
{
static void Main(string [] args)
{
string filename = @"C:\Users\tayya\Downloads\sample_data.csv"; // Replace with your actual file path
var csv = WorkBook.LoadCSV(filename);
List<Person> people = new List<Person>();
bool isFirstRow = true; // Add a flag to check for the first row
foreach (var row in csv.WorkSheets [0].Rows)
{
if (isFirstRow)
{
isFirstRow = false; // Set the flag to false after skipping the first row
continue;
}
if (row.IsEmpty) continue; // Skip empty rows
var cells = row.ToArray();
var person = new Person()
{
Name = cells [0].StringValue,
Age = int.Parse(cells [1].StringValue) // Ensure this is a numeric value
};
people.Add(person);
}
foreach (var person in people)
{
Console.WriteLine($"Name: {person.Name}, Age: {person.Age}");
}
}
}
Imports IronXL
Public Class Person
Public Property Name() As String
Public Property Age() As Integer
End Class
Friend Class Program
Shared Sub Main(ByVal args() As String)
Dim filename As String = "C:\Users\tayya\Downloads\sample_data.csv" ' Replace with your actual file path
Dim csv = WorkBook.LoadCSV(filename)
Dim people As New List(Of Person)()
Dim isFirstRow As Boolean = True ' Add a flag to check for the first row
For Each row In csv.WorkSheets (0).Rows
If isFirstRow Then
isFirstRow = False ' Set the flag to false after skipping the first row
Continue For
End If
If row.IsEmpty Then
Continue For ' Skip empty rows
End If
Dim cells = row.ToArray()
Dim person As New Person() With {
.Name = cells (0).StringValue,
.Age = Integer.Parse(cells (1).StringValue)
}
people.Add(person)
Next row
For Each person In people
Console.WriteLine($"Name: {person.Name}, Age: {person.Age}")
Next person
End Sub
End Class
Al ejecutar el archivo, mostrará los datos de la lista en la consola:
Cuando se manejan varios tipos de datos en un archivo CSV, es importante adaptar la lógica de análisis al tipo específico de cada columna de datos. En el ejemplo de la clase Person
, mientras que Name
es una cadena y se puede asignar directamente usando StringValue
, los campos numéricos como Age
requieren conversión de cadena a entero usando Int32.Parse
o Convert.ToInt32
. Esto es esencial para evitar errores de incompatibilidad de tipos.
Para tipos de datos más complejos, como fechas, use DateTime.Parse
para convertir representaciones de cadenas de fechas en objetos DateTime
. Es importante conocer el formato de fecha utilizado en el archivo CSV y asegurarse de que coincide con el formato esperado en el código. Los formatos de fecha incoherentes pueden dar lugar a errores de análisis o a una interpretación incorrecta de los datos.
Acaba de aprender a leer, analizar y mostrar los datos de un archivo CSV utilizando IronXL en C#. Este enfoque puede emplearse con distintos tipos de estructuras de datos y formatos de archivo. Por lo tanto, esto representa una habilidad útil en general para todos los desarrolladores por ahí llegando a C # como su principal lenguaje de elección.
IronXL ofrece una prueba gratuita para que los usuarios puedan experimentar sus características. Una vez que concluye el período de prueba, la licencia para IronXL comienza a un precio inicial de $749.
Hay que tener en cuenta las excepciones y los casos extremos para escribir un código más robusto, especialmente cuando se gestionan distintos tipos de datos y se utilizan archivos de gran tamaño. Siga experimentando y explorando más características de IronXL para mejorar el procesamiento de sus datos en C#. ¡Feliz codificación!