Cómo convertir un archivo CSV en una lista en C#

En este tutorial para principiantes, vamos a ver cómo leer archivos CSV en un lista en C# utilizando el IronXL biblioteca. 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.

Cómo convertir un archivo CSV en una lista en C#

1. Crear un proyecto de consola C# en Visual Studio.
2. Instale la biblioteca CSV de C# mediante el gestor de paquetes NuGet.
3. Cargue el archivo CSV utilizando el método WorkBook.LoadCSV.
4. Leer los valores de los datos del archivo y rellenar la lista.
5. Imprime la lista en la consola.

Configuración del proyecto

Paso 1: Creación de un nuevo proyecto C

1. Abra Visual Studio: Inicie Visual Studio en su ordenador.
2. Crear un nuevo proyecto: Haga clic en "Crear un nuevo proyecto". Se abre una ventana en la que puede seleccionar el tipo de proyecto.
3. Seleccione el tipo de proyecto: Elija "Consola App (.NET Core)" como tipo de proyecto para simplificar.
4. Nombre de su proyecto: Nombra tu proyecto CSVFileReader.
5. Elegir ubicación: Selecciona una ubicación adecuada en tu dispositivo para guardar este proyecto.
6. Generar el proyecto: Haga clic en "Crear" para inicializar su nuevo proyecto C#.

Paso 2: Instalación de la biblioteca IronXL

1. Abra el Gestor de paquetes NuGet: En Visual Studio, vaya al menú "Herramientas", seleccione "Gestor de paquetes NuGet" y elija "Gestionar paquetes NuGet para solución...".

2. Busque IronXL: Haga clic en la pestaña "Examinar" y busque "IronXL.Excel".

   

3. Instalar IronXL: Encuentre el paquete IronXL en los resultados de búsqueda, selecciónelo y haga clic en "Instalar". Asegúrese de que acepta cualquier acuerdo de licencia y revise los cambios.

4. Compruebe la instalación: Después de la instalación, debería ver IronXL referenciado en las referencias de su proyecto.

   Ahora, tu proyecto CSVFileReader está configurado con la librería IronXL, y estás 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.

Análisis y procesamiento de archivos CSV en C#

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 tu proyecto CSVFileReader.

Paso 1: Especificar la ruta del archivo

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 fichero.

string filename = "csvfile.csv"; //  Sustitúyalo por la ruta real del archivo

string filename = "csvfile.csv"; //  Sustitúyalo por la ruta real del archivo

Dim filename As String = "csvfile.csv" '  Sustitúyalo por la ruta real del archivo

Paso 2: Cargar el archivo CSV

IronXL hace que sea sencillo cargar un archivo CSV. Utilice 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)

Paso 3: Definir una estructura de datos

Cree una clase que represente la estructura de datos de su archivo CSV. Por ejemplo, si tu CSV contiene información sobre personas, define una clase Persona como esta:

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

Paso 4: Análisis de datos CSV

En este paso, analizaremos el archivo CSV y rellenaremos una Lista<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; //  Añadir una bandera para comprobar la primera fila
foreach (var row in csv.WorkSheets [0].Rows)
{
    if (isFirstRow)
    {
        isFirstRow = false; //  Establecer la bandera en false después de saltarse la primera fila
        continue;
    }
    if (row.IsEmpty) continue; //  Saltar filas vacías
    var cells = row.ToArray();
    var person = new Person()
    {
        Name = cells [0].StringValue,
        Age = int.Parse(cells [1].StringValue) //  Asegúrese de que es un valor numérico
    };
    people.Add(person);
}

List<Person> people = new List<Person>();
bool isFirstRow = true; //  Añadir una bandera para comprobar la primera fila
foreach (var row in csv.WorkSheets [0].Rows)
{
    if (isFirstRow)
    {
        isFirstRow = false; //  Establecer la bandera en false después de saltarse la primera fila
        continue;
    }
    if (row.IsEmpty) continue; //  Saltar filas vacías
    var cells = row.ToArray();
    var person = new Person()
    {
        Name = cells [0].StringValue,
        Age = int.Parse(cells [1].StringValue) //  Asegúrese de que es un valor numérico
    };
    people.Add(person);
}

Dim people As New List(Of Person)()
Dim isFirstRow As Boolean = True '  Añadir una bandera para comprobar la primera fila
For Each row In csv.WorkSheets (0).Rows
	If isFirstRow Then
		isFirstRow = False '  Establecer la bandera en false después de saltarse la primera fila
		Continue For
	End If
	If row.IsEmpty Then
		Continue For '  Saltar filas vacías
	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 sintáctico, primero inicializamos una Lista<Person> para almacenar los datos analizados y utilizar un indicador booleano isFirstRow para omitir la fila de cabecera del archivo CSV. El bucle foreach recorre cada fila del archivo CSV. Durante la primera iteración, se identifica la fila de cabecera y se omite, lo que garantiza que sólo 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 una matriz de celdas (row.ToArray()) y luego crear un objeto Persona 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 "Persona" analizado se añade a la lista "Personas". Este método garantiza que sólo se procesen y almacenen las filas de datos válidas, lo que evita posibles problemas como cadenas no numéricas en columnas numéricas o filas vacías inesperadas.

Paso 5: Visualización de los datos

Después de analizar los datos CSV en nuestra Lista<Person>, el siguiente paso importante es visualizar 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"; //  Sustitúyalo por la ruta real del archivo
        var csv = WorkBook.LoadCSV(filename);
        List<Person> people = new List<Person>();
        bool isFirstRow = true; //  Añadir una bandera para comprobar la primera fila
        foreach (var row in csv.WorkSheets [0].Rows)
        {
            if (isFirstRow)
            {
                isFirstRow = false; //  Establecer la bandera en false después de saltarse la primera fila
                continue;
            }
            if (row.IsEmpty) continue; //  Saltar filas vacías
            var cells = row.ToArray();
            var person = new Person()
            {
                Name = cells [0].StringValue,
                Age = int.Parse(cells [1].StringValue) //  Asegúrese de que es un valor numérico
            };
            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"; //  Sustitúyalo por la ruta real del archivo
        var csv = WorkBook.LoadCSV(filename);
        List<Person> people = new List<Person>();
        bool isFirstRow = true; //  Añadir una bandera para comprobar la primera fila
        foreach (var row in csv.WorkSheets [0].Rows)
        {
            if (isFirstRow)
            {
                isFirstRow = false; //  Establecer la bandera en false después de saltarse la primera fila
                continue;
            }
            if (row.IsEmpty) continue; //  Saltar filas vacías
            var cells = row.ToArray();
            var person = new Person()
            {
                Name = cells [0].StringValue,
                Age = int.Parse(cells [1].StringValue) //  Asegúrese de que es un valor numérico
            };
            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" '  Sustitúyalo por la ruta real del archivo
		Dim csv = WorkBook.LoadCSV(filename)
		Dim people As New List(Of Person)()
		Dim isFirstRow As Boolean = True '  Añadir una bandera para comprobar la primera fila
		For Each row In csv.WorkSheets (0).Rows
			If isFirstRow Then
				isFirstRow = False '  Establecer la bandera en false después de saltarse la primera fila
				Continue For
			End If
			If row.IsEmpty Then
				Continue For '  Saltar filas vacías
			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

Salida del código

Al ejecutar el archivo, mostrará los datos de la lista en la consola:

Manejo de distintos tipos de datos

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 Persona, mientras que el Nombre es una cadena y se puede asignar directamente utilizando StringValue, los campos numéricos como Edad requieren la conversión de cadena a entero utilizando Int32.Parse o Convert.ToInt32. Esto es esencial para evitar errores de incompatibilidad de tipos.

Para tipos de datos más complejos, como las fechas, utilice 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.

Conclusión

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 un prueba gratuita para que los usuarios experimenten sus funciones. Una vez concluido el período de prueba, la licencia para IronXL comienza a un precio inicial de $599.

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!