Cómo importar CSV a Datatable en C#

Introducción

Bienvenido a este tutorial para principiantes sobre la importación de CSV (valores separados por comas) archivos en un Tabla de datos en C# utilizando IronXL. Esta guía le proporcionará un enfoque fácil de seguir, asegurando que incluso si usted es nuevo en C#, encontrará este proceso sencillo. Cubriremos cada paso, desde la configuración del entorno hasta la escritura del código fuente. Al final de este tutorial, usted tendrá una clara comprensión de cómo convertir datos CSV en un Datatable, gestionar columnas datatable, y manejar diversos aspectos de los documentos CSV en C # usando un lector var y cadena de conexión.

Requisitos previos

Antes de sumergirnos, asegúrate de que tienes:

• Conocimientos básicos de C#
• Visual Studio instalado en su equipo local
• La biblioteca IronXL, que puede obtenerse a través del gestor de paquetes NuGet

Entender lo básico

¿Qué es un archivo CSV?

Un archivo CSV (Archivo de valores separados por comas) es un tipo de archivo de texto sin formato que utiliza una estructura específica para organizar los datos tabulares. Es un formato habitual para el intercambio de datos, ya que CSV es sencillo, compacto y funciona con numerosas plataformas. En un archivo CSV, los datos están separados por comas, y cada nueva línea significa una nueva fila, con las cabeceras de las columnas a menudo presentes en la primera fila, int i.

Comprender DataTables en C#

Una DataTable forma parte de la biblioteca ADO.NET en C# y representa una única tabla de datos en memoria. Se compone de filas y columnas y cada columna puede ser de un tipo de datos diferente. Las DataTables son muy flexibles y pueden representar datos en un formato estructurado, lo que las hace ideales para manejar datos de archivos CSV.

Configuración del proyecto

Paso 1: Crear un nuevo proyecto C&num

1. Abre Visual Studio.
2. Seleccione Archivo > Nuevo > Proyecto.
3. Elija una aplicación C# Console o Windows Forms, y nómbrela adecuadamente.

Paso 2: Instalar IronXL

IronXL es una potente biblioteca que le permite trabajar con Excel y CSV en C#. Para utilizarlo, debe instalarlo a través de NuGet Package Manager. En Visual Studio:

1. Vaya a Herramientas > Administrador de paquetes NuGet > Administrar paquetes NuGet para la solución.

2. Busque IronXL.Excel.

   

3. Instale el paquete en su proyecto.

Lectura de Archivos CSV en Tablas de Datos con IronXL

Paso 1: Configure su entorno

using IronXL;
using System.Data;

using IronXL;
using System.Data;

Imports IronXL
Imports System.Data

Estas declaraciones using incluyen los espacios de nombres necesarios para nuestra tarea.

Paso 2: Crear un método para importar CSV

Definir una clase, CsvToDataTable, con un método estático ImportCsvToDataTable. Este método se encargará de convertir el fichero CSV en una Tabla de datos.

public class CsvToDataTable
{
    public static DataTable ImportCsvToDataTable(string filePath)
    {
        //  El fragmento de código para importar CSV se colocará aquí
    }
}

public class CsvToDataTable
{
    public static DataTable ImportCsvToDataTable(string filePath)
    {
        //  El fragmento de código para importar CSV se colocará aquí
    }
}

Public Class CsvToDataTable
	Public Shared Function ImportCsvToDataTable(ByVal filePath As String) As DataTable
		'  El fragmento de código para importar CSV se colocará aquí
	End Function
End Class

Paso 3: Cargar el archivo CSV

Dentro del método ImportCsvToDataTable, comience cargando el archivo CSV. IronXL proporciona una manera directa de hacer esto:

//  Cargar el archivo CSV
WorkBook workbook = WorkBook.LoadCSV(filePath);

//  Cargar el archivo CSV
WorkBook workbook = WorkBook.LoadCSV(filePath);

'  Cargar el archivo CSV
Dim workbook As WorkBook = WorkBook.LoadCSV(filePath)

WorkBook.LoadCSV es un método en IronXL para cargar archivos CSV. Aquí, filePath es la ruta a su archivo CSV.

Paso 4: Convertir CSV en DataTable

Convierte los datos CSV cargados en una Tabla de datos. Este paso es el principal, ya que transforma los datos en un formato que puede ser fácilmente manipulado y visualizado dentro de una aplicación C#.

//  Obtener la primera hoja de cálculo
WorkSheet sheet = workbook.DefaultWorkSheet;
//  Convertir hoja de cálculo CSV en DataTable dt
DataTable dataTable = sheet.ToDataTable();
return dataTable;

//  Obtener la primera hoja de cálculo
WorkSheet sheet = workbook.DefaultWorkSheet;
//  Convertir hoja de cálculo CSV en DataTable dt
DataTable dataTable = sheet.ToDataTable();
return dataTable;

'  Obtener la primera hoja de cálculo
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
'  Convertir hoja de cálculo CSV en DataTable dt
Dim dataTable As DataTable = sheet.ToDataTable()
Return dataTable

Este fragmento convierte los datos CSV en una Tabla de datos. El método DefaultWorkSheet obtiene la primera hoja de trabajo del libro de trabajo, equivalente a todos los datos CSV en el caso de un archivo CSV. El método ToDataTable es una poderosa característica de IronXL que mapea eficientemente los datos CSV a una estructura DataTable, incluyendo una fila de encabezado de cadena de columnas si está presente en la primera fila del archivo CSV.

Paso 5: Utilice el método en su aplicación

Ahora, utiliza el método ImportCsvToDataTable en tu aplicación. Por ejemplo, es posible que desee llamar a este método cuando se inicia la aplicación o cuando el usuario carga un archivo CSV.

//  Utilización
string csvFilePath = "csvfile.csv";
DataTable dataTable = CsvToDataTable.ImportCsvToDataTable(csvFilePath);

//  Utilización
string csvFilePath = "csvfile.csv";
DataTable dataTable = CsvToDataTable.ImportCsvToDataTable(csvFilePath);

'  Utilización
Dim csvFilePath As String = "csvfile.csv"
Dim dataTable As DataTable = CsvToDataTable.ImportCsvToDataTable(csvFilePath)

Este fragmento de código muestra cómo llamar al método ImportCsvToDataTable. Sustituya "csvfile.csv " por la ruta real de su archivo CSV.

Paso 6: Trabajar con la tabla de datos de salida

Una vez que tengas la Tabla de datos, puedes realizar varias operaciones como mostrar los datos en una interfaz de usuario, filtrar o procesar los datos. He aquí algunos ejemplos:

Visualización de datos en una aplicación de consola

foreach (DataRow row in dataTable.Rows)
{
    foreach (var item in row.ItemArray)
    {
        Console.Write($"{item} ");
    }
    Console.WriteLine();
}

foreach (DataRow row in dataTable.Rows)
{
    foreach (var item in row.ItemArray)
    {
        Console.Write($"{item} ");
    }
    Console.WriteLine();
}

For Each row As DataRow In dataTable.Rows
	For Each item In row.ItemArray
		Console.Write($"{item} ")
	Next item
	Console.WriteLine()
Next row

Este código recorre cada fila y columna de DataTable e imprime los datos en la consola.

Filtrado de datos

Puede utilizar LINQ para filtrar datos en la DataTable. Por ejemplo, si desea seleccionar filas en las que una columna específica cumple una condición:

var filteredRows = dataTable.AsEnumerable()
                            .Where(row => row.Field<string>("ColumnName") == "SomeValue");

var filteredRows = dataTable.AsEnumerable()
                            .Where(row => row.Field<string>("ColumnName") == "SomeValue");

Dim filteredRows = dataTable.AsEnumerable().Where(Function(row) row.Field(Of String)("ColumnName") = "SomeValue")

Sustituye "NombreColumna " y "AlgúnValor " por el nombre de la columna y el valor que estás filtrando.

Fragmento de código completo

Aquí está el código fuente completo que puede utilizar en su proyecto:

using IronXL;
using System;
using System.Data;
using System.IO;
public class CsvToDataTable
{
    public static DataTable ImportCsvToDataTable(string filePath)
    {
        //  Comprobar si el archivo existe
        if (!File.Exists(filePath))
        {
            throw new FileNotFoundException($"The file at {filePath} was not found.");
        }
        //  Cargar el archivo CSV
        WorkBook workbook = WorkBook.LoadCSV(filePath, listDelimiter: ";");
        //  Obtener la primera hoja de cálculo
        WorkSheet sheet = workbook.DefaultWorkSheet;
        //  Convertir la hoja de cálculo en DataTable
        DataTable dataTable = sheet.ToDataTable();
        return dataTable;
    }
}
class Program
{
    static void Main(string [] args)
    {
        //  Utilización
        try
        {
            string strfilepath = "sample_data.csv"; //  Ruta del archivo CSV
            DataTable dataTable = CsvToDataTable.ImportCsvToDataTable(strfilepath);
            foreach (DataRow row in dataTable.Rows)
            {
                foreach (var item in row.ItemArray)
                {
                    Console.Write($"{item} ");
                }
                Console.WriteLine();
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"An error occurred: {ex.Message}");
        }
    }
}

using IronXL;
using System;
using System.Data;
using System.IO;
public class CsvToDataTable
{
    public static DataTable ImportCsvToDataTable(string filePath)
    {
        //  Comprobar si el archivo existe
        if (!File.Exists(filePath))
        {
            throw new FileNotFoundException($"The file at {filePath} was not found.");
        }
        //  Cargar el archivo CSV
        WorkBook workbook = WorkBook.LoadCSV(filePath, listDelimiter: ";");
        //  Obtener la primera hoja de cálculo
        WorkSheet sheet = workbook.DefaultWorkSheet;
        //  Convertir la hoja de cálculo en DataTable
        DataTable dataTable = sheet.ToDataTable();
        return dataTable;
    }
}
class Program
{
    static void Main(string [] args)
    {
        //  Utilización
        try
        {
            string strfilepath = "sample_data.csv"; //  Ruta del archivo CSV
            DataTable dataTable = CsvToDataTable.ImportCsvToDataTable(strfilepath);
            foreach (DataRow row in dataTable.Rows)
            {
                foreach (var item in row.ItemArray)
                {
                    Console.Write($"{item} ");
                }
                Console.WriteLine();
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"An error occurred: {ex.Message}");
        }
    }
}

Imports IronXL
Imports System
Imports System.Data
Imports System.IO
Public Class CsvToDataTable
	Public Shared Function ImportCsvToDataTable(ByVal filePath As String) As DataTable
		'  Comprobar si el archivo existe
		If Not File.Exists(filePath) Then
			Throw New FileNotFoundException($"The file at {filePath} was not found.")
		End If
		'  Cargar el archivo CSV
		Dim workbook As WorkBook = WorkBook.LoadCSV(filePath, listDelimiter:= ";")
		'  Obtener la primera hoja de cálculo
		Dim sheet As WorkSheet = workbook.DefaultWorkSheet
		'  Convertir la hoja de cálculo en DataTable
		Dim dataTable As DataTable = sheet.ToDataTable()
		Return dataTable
	End Function
End Class
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		'  Utilización
		Try
			Dim strfilepath As String = "sample_data.csv" '  Ruta del archivo CSV
			Dim dataTable As DataTable = CsvToDataTable.ImportCsvToDataTable(strfilepath)
			For Each row As DataRow In dataTable.Rows
				For Each item In row.ItemArray
					Console.Write($"{item} ")
				Next item
				Console.WriteLine()
			Next row
		Catch ex As Exception
			Console.WriteLine($"An error occurred: {ex.Message}")
		End Try
	End Sub
End Class

Puede utilizar este código en el archivo Program.cs. No olvide añadir la licencia de IronXL si está trabajando en el entorno de producción.

Salida de código

Una vez que ejecutes el código, cargará el archivo CSV e importará sus datos a la DataTable. Después, mostrará el contenido de las columnas de la datatabla en la consola. Ayuda a verificar que los datos se importan correctamente a la DataTable.

Manejo de diferentes escenarios

En el mundo real, los archivos CSV pueden variar significativamente en formato y estructura. Es importante manejar estas variaciones para asegurar que su aplicación sea robusta y versátil. Vamos a ampliar sobre cómo manejar diferentes escenarios al importar datos CSV en un DataTable usando IronXL.

Manejo de un delimitador diferente

Las comas son el valor por defecto del delimitador en los archivos CSV. Sin embargo, los archivos CSV no siempre utilizan comas para separar los valores. A veces, se utiliza un punto y coma, un tabulador u otros caracteres como delimitadores. Para manejar esto en IronXL:

Especificar un delimitador personalizado: Antes de cargar el archivo CSV, puede especificar el delimitador de su archivo. Por ejemplo, si su archivo utiliza un punto y coma (;)puedes configurarlo así:

WorkBook workbook = WorkBook.LoadCSV(filePath, listDelimiter: ";");

WorkBook workbook = WorkBook.LoadCSV(filePath, listDelimiter: ";");

Dim workbook As WorkBook = WorkBook.LoadCSV(filePath, listDelimiter:= ";")

Detección dinámica del delimitador: Como alternativa, puede escribir una función que detecte el delimitador dinámicamente. Esto puede hacerse analizando las primeras líneas del fichero y determinando el carácter especial más frecuente.

Gestión de archivos CSV de gran tamaño

Cuando se trabaja con archivos CSV de gran tamaño, es importante tener en cuenta el uso de memoria y el rendimiento. IronXL proporciona formas eficientes de manejar archivos grandes sin cargar todo el archivo en la memoria a la vez. Puede leer el archivo en trozos o utilizar las API de streaming proporcionadas por IronXL para gestionar el uso de la memoria de forma eficaz.

Conclusión

Importar datos CSV a una DataTable utilizando IronXL en C# es sencillo. Mejora las capacidades de manipulación de datos de su aplicación, permitiéndole manejar archivos CSV de forma eficiente. Con los pasos descritos en este tutorial, los principiantes pueden integrar fácilmente esta funcionalidad en sus proyectos de C#.

IronXL ofrece una versión de prueba gratuita para que los usuarios exploren sus funciones. Para aquellos que busquen funciones y soporte más avanzados, las opciones de licencia comienzan en $599.