Cómo importar CSV a Datatable en C#

Introducción

Bienvenido a este tutorial para principiantes sobre cómo importar archivos CSV (valores separados por comas) en un DataTable en C# usando 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 plano que utiliza una estructura específica para organizar 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 te permite trabajar con archivos 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. Buscar 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

Defina una clase, CsvToDataTable, con un método estático ImportCsvToDataTable. Este método será responsable de convertir el archivo CSV en un DataTable.

public class CsvToDataTable
{
    public static DataTable ImportCsvToDataTable(string filePath)
    {
        // Code snippet to import CSV will be placed here
    }
}

public class CsvToDataTable
{
    public static DataTable ImportCsvToDataTable(string filePath)
    {
        // Code snippet to import CSV will be placed here
    }
}

Public Class CsvToDataTable
	Public Shared Function ImportCsvToDataTable(ByVal filePath As String) As DataTable
		' Code snippet to import CSV will be placed here
	End Function
End Class

Paso 3: Cargar el archivo CSV

Dentro del método ImportCsvToDataTable, comienza cargando el archivo CSV. IronXL ofrece una manera sencilla de hacer esto:

// Load the CSV file
WorkBook workbook = WorkBook.LoadCSV(filePath);

// Load the CSV file
WorkBook workbook = WorkBook.LoadCSV(filePath);

' Load the CSV file
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 tu archivo CSV.

Paso 4: Convertir CSV en DataTable

Convierta los datos CSV cargados en un DataTable. 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#.

// Get the first worksheet
WorkSheet sheet = workbook.DefaultWorkSheet;
// Convert CSV worksheet to DataTable dt
DataTable dataTable = sheet.ToDataTable();
return dataTable;

// Get the first worksheet
WorkSheet sheet = workbook.DefaultWorkSheet;
// Convert CSV worksheet to DataTable dt
DataTable dataTable = sheet.ToDataTable();
return dataTable;

' Get the first worksheet
Dim sheet As WorkSheet = workbook.DefaultWorkSheet
' Convert CSV worksheet to DataTable dt
Dim dataTable As DataTable = sheet.ToDataTable()
Return dataTable

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

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

Ahora, use el método ImportCsvToDataTable en su 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.

// Usage
string csvFilePath = "csvfile.csv";
DataTable dataTable = CsvToDataTable.ImportCsvToDataTable(csvFilePath);

// Usage
string csvFilePath = "csvfile.csv";
DataTable dataTable = CsvToDataTable.ImportCsvToDataTable(csvFilePath);

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

Este fragmento de código demuestra cómo llamar al método ImportCsvToDataTable. Reemplace "csvfile.csv" con la ruta real de su archivo CSV.

Paso 6: Trabajar con la tabla de datos de salida

Una vez que tenga el DataTable, puede 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 itera a través de cada fila y columna en el DataTable y 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")

Reemplace "ColumnName" y "SomeValue" con el nombre de la columna y el valor por el que está 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)
    {
        // Check if the file exists
        if (!File.Exists(filePath))
        {
            throw new FileNotFoundException($"The file at {filePath} was not found.");
        }
        // Load the CSV file
        WorkBook workbook = WorkBook.LoadCSV(filePath, listDelimiter: ";");
        // Get the first worksheet
        WorkSheet sheet = workbook.DefaultWorkSheet;
        // Convert the worksheet to DataTable
        DataTable dataTable = sheet.ToDataTable();
        return dataTable;
    }
}
class Program
{
    static void Main(string [] args)
    {
        // Usage
        try
        {
            string strfilepath = "sample_data.csv"; // CSV file path
            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)
    {
        // Check if the file exists
        if (!File.Exists(filePath))
        {
            throw new FileNotFoundException($"The file at {filePath} was not found.");
        }
        // Load the CSV file
        WorkBook workbook = WorkBook.LoadCSV(filePath, listDelimiter: ";");
        // Get the first worksheet
        WorkSheet sheet = workbook.DefaultWorkSheet;
        // Convert the worksheet to DataTable
        DataTable dataTable = sheet.ToDataTable();
        return dataTable;
    }
}
class Program
{
    static void Main(string [] args)
    {
        // Usage
        try
        {
            string strfilepath = "sample_data.csv"; // CSV file path
            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
		' Check if the file exists
		If Not File.Exists(filePath) Then
			Throw New FileNotFoundException($"The file at {filePath} was not found.")
		End If
		' Load the CSV file
		Dim workbook As WorkBook = WorkBook.LoadCSV(filePath, listDelimiter:= ";")
		' Get the first worksheet
		Dim sheet As WorkSheet = workbook.DefaultWorkSheet
		' Convert the worksheet to DataTable
		Dim dataTable As DataTable = sheet.ToDataTable()
		Return dataTable
	End Function
End Class
Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Usage
		Try
			Dim strfilepath As String = "sample_data.csv" ' CSV file path
			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, puedes especificar el delimitador de tu archivo. Por ejemplo, si su archivo utiliza un punto y coma (;), puede configurarlo de esta manera:

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

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

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

Detección de Delimitador Dinámico: Alternativamente, podrías escribir una función para detectar el delimitador de forma dinámica. 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 buscan capacidades más avanzadas y soporte, las opciones de licencia comienzan en $749.