Cómo leer datos de un archivo CSV y almacenarlos en una base de datos C#

En el mundo digital actual, manejar los datos con eficacia es una tarea importante. Un requisito habitual en el desarrollo de software es leer datos de un archivo CSV y almacenarlos en una base de datos. Este tutorial cubre los pasos para leer datos de un archivo CSV y almacenarlos en una base de datos SQL Server usando C#, específicamente utilizando la función**Biblioteca IronXL. Esta guía está pensada para principiantes y se explicará de forma sencilla y atractiva.

Entender lo básico

*¿Qué es un archivo CSV?

UN CSV(Valores separados por comas) es un archivo de texto sin formato que contiene datos separados por comas. Es un formato popular para transferir datos debido a su sencillez y compatibilidad con diversas aplicaciones, como Excel.

El papel de SQL Server y las bases de datos

SQL Server es un sistema de gestión de bases de datos de Microsoft. Sirve para almacenar y gestionar datos de forma estructurada. En nuestro caso, almacenaremos los datos CSV en una tabla de SQL Server.

Introducción a IronXL

IronXL es una librería Excel adaptada para aplicaciones .NET, diseñada específicamente para permitir a los desarrolladores leer, generar y editar archivos Excel sin necesidad de Microsoft Office Interop. Esta biblioteca destaca por su compatibilidad con varias versiones y plataformas .NET, incluidas .NET Core, .NET Standard y .NET Framework, así como por su compatibilidad con diferentes sistemas operativos como Windows, Linux y macOS. Es una potente biblioteca para importar datos, especialmente para manejar archivos CSV.

Cómo leer y almacenar datos de archivos CSV en C#

1. Cree un programa de consola C# en Visual Studio.

2. Instale la biblioteca CSV utilizando NuGet Package Manager.

3. Cargue el archivo CSV en el programa utilizando la biblioteca.

4. Crear una conexión con la base de datos.

5. Lea el contenido del archivo CSV utilizando la biblioteca.

6. Copia ese contenido en la base de datos utilizando el método SqlBulkCopy.

   He aquí un fragmento de código de ejemplo:

using System;
using System.Data;
using System.Data.SqlClient;
using CsvHelper;

namespace CsvReader
{
    class Program
    {
        static void Main(string [] args)
        {
            string csvPath = @"path\to\your\csv\file.csv";

            using (var reader = new StreamReader(csvPath))
            using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
            {
                var records = csv.GetRecords<YourModel>();

                using (var sqlBulkCopy = new SqlBulkCopy("your_connection_string"))
                {
                    sqlBulkCopy.DestinationTableName = "YourTableName";
                    sqlBulkCopy.WriteToServer(records.AsDataReader());
                }

                Console.WriteLine("Data imported successfully!");
            }
        }
    }
}

using System;
using System.Data;
using System.Data.SqlClient;
using CsvHelper;

namespace CsvReader
{
    class Program
    {
        static void Main(string [] args)
        {
            string csvPath = @"path\to\your\csv\file.csv";

            using (var reader = new StreamReader(csvPath))
            using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
            {
                var records = csv.GetRecords<YourModel>();

                using (var sqlBulkCopy = new SqlBulkCopy("your_connection_string"))
                {
                    sqlBulkCopy.DestinationTableName = "YourTableName";
                    sqlBulkCopy.WriteToServer(records.AsDataReader());
                }

                Console.WriteLine("Data imported successfully!");
            }
        }
    }
}

Imports System
Imports System.Data
Imports System.Data.SqlClient
Imports CsvHelper

Namespace CsvReader
	Friend Class Program
		Shared Sub Main(ByVal args() As String)
			Dim csvPath As String = "path\to\your\csv\file.csv"

			Using reader = New StreamReader(csvPath)
			Using csv = New CsvReader(reader, CultureInfo.InvariantCulture)
				Dim records = csv.GetRecords(Of YourModel)()

				Using sqlBulkCopy As New SqlBulkCopy("your_connection_string")
					sqlBulkCopy.DestinationTableName = "YourTableName"
					sqlBulkCopy.WriteToServer(records.AsDataReader())
				End Using

				Console.WriteLine("Data imported successfully!")
			End Using
			End Using
		End Sub
	End Class
End Namespace

Asegúrese de sustituir "path\to\your\csv\file.csv" por la ruta real a su archivo CSV, "YourModel" por el modelo que representa sus datos CSV, "your_connection_string" por su cadena de conexión a la base de datos y "YourTableName" por el nombre de su tabla de base de datos.

Configuración del entorno

Requisitos previos

1. Visual Studio: Asegúrese de tener instalado Visual Studio.

2. Servidor SQL: Debe tener SQL Server instalado y accesible.

3. Instalación de IronXL: Instale IronXL ejecutando el siguiente comando NuGet:

Install-Package IronXL.Excel

o

dotnet add package IronXL

Asegúrese de ejecutar estos comandos dentro del directorio del proyecto donde desea instalar IronXL.

Creación de una tabla SQL Server

Antes de importar los datos, cree una tabla de destino en su base de datos SQL Server. Esta tabla almacenará los datos CSV.

CREATE TABLE YourTableName (
    Column1 DataType,
    Column2 DataType,
    ...
);

Sustituya NombreDeTabla, Columna1, Columna2 y TipoDeDatos por sus datos específicos.

Guía paso a paso para importar datos CSV

1. En primer lugar, asegúrese de que dispone de un archivo CSV con los datos que desea importar.

2. Cree un nuevo proyecto de aplicación de consola C# en Visual Studio.

3. Instale el paquete NuGet CsvHelper para leer archivos CSV. Para ello, abra la consola del gestor de paquetes NuGet en Visual Studio y ejecute el siguiente comando:

    :installCmd Install-Package CsvHelper

4. Añada las sentencias using necesarias en la parte superior de su archivo de código C#:

    using System;
    using System.IO;
    using CsvHelper;

    using System;
    using System.IO;
    using CsvHelper;

Imports System
	Imports System.IO
	Imports CsvHelper

5. En su código, especifique la ruta a su archivo CSV. Por ejemplo:

    string csvFilePath = @"C:\path\to\your\csv\file.csv";

    string csvFilePath = @"C:\path\to\your\csv\file.csv";

Dim csvFilePath As String = "C:\path\to\your\csv\file.csv"

Asegúrese de sustituir C:\path\to\your\csv\file.csv con la ruta real a su archivo CSV.

6. Crea una nueva instancia de la clase StreamReader para leer el fichero CSV:

    using (var reader = new StreamReader(csvFilePath))
    {
        // code goes here
    }

    using (var reader = new StreamReader(csvFilePath))
    {
        // code goes here
    }

IRON VB CONVERTER ERROR developers@ironsoftware.com

7. Crea una nueva instancia de la clase CsvReader, pasando el objeto StreamReader:

    using (var reader = new StreamReader(csvFilePath))
    using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
    {
        // code goes here
    }

    using (var reader = new StreamReader(csvFilePath))
    using (var csv = new CsvReader(reader, CultureInfo.InvariantCulture))
    {
        // code goes here
    }

IRON VB CONVERTER ERROR developers@ironsoftware.com

8. Opcionalmente, configure el objeto CsvReader con los ajustes necesarios. Por ejemplo:

    csv.Configuration.HasHeaderRecord = true;

    csv.Configuration.HasHeaderRecord = true;

csv.Configuration.HasHeaderRecord = True

9. Utilice la función GetRecords<T>()del objetoCsvReaderpara leer los datos CSV en una colección de objetos. Sustituir` con el tipo de objeto que representa cada registro en el archivo CSV. Por ejemplo:

    var records = csv.GetRecords<YourModel>();

    var records = csv.GetRecords<YourModel>();

Dim records = csv.GetRecords(Of YourModel)()

Asegúrese de sustituir YourModel por el nombre real de su clase modelo.

10. Iterar sobre los registros y realizar cualquier tratamiento o validación necesarios:

    foreach (var record in records)
    {
        // code goes here
    }

    foreach (var record in records)
    {
        // code goes here
    }

IRON VB CONVERTER ERROR developers@ironsoftware.com

11. Opcionalmente, establezca una conexión con su base de datos SQL Server utilizando ADO.NET o una herramienta ORM como Entity Framework.

12. Inserte cada registro en la base de datos utilizando el mecanismo de acceso a la base de datos que haya elegido. Por ejemplo, si utiliza ADO.NET, puede aprovechar la clase SqlBulkCopy para insertar los datos de forma masiva y eficaz.

13. Gestione las excepciones que puedan producirse durante el proceso de importación y proporcione los mensajes de error o registros adecuados.

14. Pruebe su aplicación ejecutándola y verificando que los datos CSV se importan correctamente en su base de datos.

    Ya está.! Ahora ha importado con éxito datos CSV a su base de datos SQL Server utilizando C#.

Paso 1: Lectura del archivo CSV

Al iniciar la tarea de importar datos de un archivo CSV, el primer paso crucial es leer con precisión los datos que contiene. Cada línea de un archivo CSV suele representar un registro de datos, y cada registro consta de uno o varios campos, separados por comas.

A continuación, utilizamos la biblioteca IronXL para manejar el archivo CSV. Para leer el archivo CSV utilizando IronXL, utilizarás sus clases WorkBook y WorkSheet. La clase WorkBook representa una hoja de cálculo completa, que podría ser un archivo Excel o, en nuestro caso, un archivo CSV. Cuando carga la ruta del archivo CSV en un objeto WorkBook, IronXL trata el archivo CSV como una hoja de cálculo/tabla de datos.

using IronXL;
public class CSVReader
{
    public DataTable ReadCSV(string filePath)
    {
        WorkBook workbook = WorkBook.Load(filePath);
        WorkSheet sheet = workbook.DefaultWorkSheet;
        // Convert to DataTable for easier processing
        DataTable dataTable = sheet.ToDataTable(true); // Set to 'true' if your CSV has a header row
        return dataTable;
    }
}

using IronXL;
public class CSVReader
{
    public DataTable ReadCSV(string filePath)
    {
        WorkBook workbook = WorkBook.Load(filePath);
        WorkSheet sheet = workbook.DefaultWorkSheet;
        // Convert to DataTable for easier processing
        DataTable dataTable = sheet.ToDataTable(true); // Set to 'true' if your CSV has a header row
        return dataTable;
    }
}

Imports IronXL
Public Class CSVReader
	Public Function ReadCSV(ByVal filePath As String) As DataTable
		Dim workbook As WorkBook = WorkBook.Load(filePath)
		Dim sheet As WorkSheet = workbook.DefaultWorkSheet
		' Convert to DataTable for easier processing
		Dim dataTable As DataTable = sheet.ToDataTable(True) ' Set to 'true' if your CSV has a header row
		Return dataTable
	End Function
End Class

Paso 2: Establecer una conexión con la base de datos

Establecer una conexión con su base de datos SQL Server es un paso fundamental en el proceso de almacenamiento de sus datos CSV. Este paso consiste en establecer un enlace de comunicación entre su aplicación y el servidor de base de datos. Una conexión correcta es crucial porque, sin ella, la transferencia de datos a la base de datos sería imposible.

Este paso se centra en la creación y apertura de una conexión utilizando una cadena de conexión en C#. La cadena de conexión es un componente vital, ya que contiene la información necesaria para establecer la conexión. Es como una llave que abre la puerta de tu base de datos.

public class DatabaseConnector
{
    private string connectionString = "your_connection_string_here";

    public SqlConnection ConnectToDatabase()
    {
        SqlConnection connection = new SqlConnection(connectionString);
        connection.Open();
        return connection;
    }
}

public class DatabaseConnector
{
    private string connectionString = "your_connection_string_here";

    public SqlConnection ConnectToDatabase()
    {
        SqlConnection connection = new SqlConnection(connectionString);
        connection.Open();
        return connection;
    }
}

Public Class DatabaseConnector
	Private connectionString As String = "your_connection_string_here"

	Public Function ConnectToDatabase() As SqlConnection
		Dim connection As New SqlConnection(connectionString)
		connection.Open()
		Return connection
	End Function
End Class

La variable connectionString contiene todos los detalles necesarios para conectarse a su servidor SQL. Suele incluir el nombre del servidor, el nombre de la base de datos, el ID de usuario y la contraseña. Un ejemplo de cadena de conexión es el siguiente Servidor=miDirecciónServidor;BaseDatos=miBaseDatos;Id Usuario=miNombreUsuario;Contraseña=miContraseña;. Es esencial reemplazar estos marcadores de posición con los detalles reales de su servidor.

Paso 3: Almacenamiento de datos en la base de datos

Una vez establecida la conexión con la base de datos SQL Server, el siguiente paso fundamental es almacenar los datos CSV en la base de datos. Este paso consiste en transferir los datos que ha leído y procesado a su tabla SQL Server. Es una parte crucial del proceso de tratamiento de datos, ya que implica la migración real de datos de un archivo local a un servidor de bases de datos.

En este paso, nos centraremos en cómo los datos CSV, ahora almacenados en una DataTable, se transfieren a la base de datos SQL Server. Utilizamos una combinación de funciones de C# y SQL Server para llevar a cabo esta tarea con eficacia.

public class DataImporter
{
    public void ImportData(DataTable dataTable)
    {
        using (SqlConnection connection = new DatabaseConnector().ConnectToDatabase())
        {
            // Check if the table exists and create it if it does not.
            string tableName = "CSVData"; // Use a valid SQL table name format
            string checkTable = $"IF NOT EXISTS (SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = '{tableName}') BEGIN ";
            string createTable = "CREATE TABLE " + tableName + " (";
            for (int i = 0; i < dataTable.Columns.Count; i++)
            {
                createTable += $"[{dataTable.Columns [i].ColumnName}] NVARCHAR(MAX)";
                if (i < dataTable.Columns.Count - 1)
                    createTable += ", ";
            }
            createTable += ") END";
            SqlCommand createTableCommand = new SqlCommand(checkTable + createTable, connection);
            createTableCommand.ExecuteNonQuery();

            // Now we use SqlBulkCopy to import the data
            using (SqlBulkCopy bulkCopy = new SqlBulkCopy(connection))
            {
                bulkCopy.DestinationTableName = tableName;
                try
                {
                    bulkCopy.WriteToServer(dataTable);
                    Console.WriteLine("Data imported successfully!");
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
            }
        }
    }
}

public class DataImporter
{
    public void ImportData(DataTable dataTable)
    {
        using (SqlConnection connection = new DatabaseConnector().ConnectToDatabase())
        {
            // Check if the table exists and create it if it does not.
            string tableName = "CSVData"; // Use a valid SQL table name format
            string checkTable = $"IF NOT EXISTS (SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = '{tableName}') BEGIN ";
            string createTable = "CREATE TABLE " + tableName + " (";
            for (int i = 0; i < dataTable.Columns.Count; i++)
            {
                createTable += $"[{dataTable.Columns [i].ColumnName}] NVARCHAR(MAX)";
                if (i < dataTable.Columns.Count - 1)
                    createTable += ", ";
            }
            createTable += ") END";
            SqlCommand createTableCommand = new SqlCommand(checkTable + createTable, connection);
            createTableCommand.ExecuteNonQuery();

            // Now we use SqlBulkCopy to import the data
            using (SqlBulkCopy bulkCopy = new SqlBulkCopy(connection))
            {
                bulkCopy.DestinationTableName = tableName;
                try
                {
                    bulkCopy.WriteToServer(dataTable);
                    Console.WriteLine("Data imported successfully!");
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                }
            }
        }
    }
}

Public Class DataImporter
	Public Sub ImportData(ByVal dataTable As DataTable)
		Using connection As SqlConnection = (New DatabaseConnector()).ConnectToDatabase()
			' Check if the table exists and create it if it does not.
			Dim tableName As String = "CSVData" ' Use a valid SQL table name format
			Dim checkTable As String = $"IF NOT EXISTS (SELECT * FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_NAME = '{tableName}') BEGIN "
			Dim createTable As String = "CREATE TABLE " & tableName & " ("
			For i As Integer = 0 To dataTable.Columns.Count - 1
				createTable &= $"[{dataTable.Columns (i).ColumnName}] NVARCHAR(MAX)"
				If i < dataTable.Columns.Count - 1 Then
					createTable &= ", "
				End If
			Next i
			createTable &= ") END"
			Dim createTableCommand As New SqlCommand(checkTable & createTable, connection)
			createTableCommand.ExecuteNonQuery()

			' Now we use SqlBulkCopy to import the data
			Using bulkCopy As New SqlBulkCopy(connection)
				bulkCopy.DestinationTableName = tableName
				Try
					bulkCopy.WriteToServer(dataTable)
					Console.WriteLine("Data imported successfully!")
				Catch ex As Exception
					Console.WriteLine(ex.Message)
				End Try
			End Using
		End Using
	End Sub
End Class

Comienza abriendo una conexión a la base de datos SQL Server utilizando la clase DatabaseConnector, asegurando una vía para las transacciones de datos. El método comprueba la existencia de la tabla "CSVData" en la base de datos.

Si no encuentra la tabla, procede a crearla. El esquema de la tabla se construye basándose en el esquema DataTable pasado al método, con todas las columnas establecidas a NVARCHAR(MAX) para dar cabida a cualquier dato de texto. Se trata de un enfoque genérico y puede ser necesario perfeccionarlo para ajustarlo mejor a tipos de datos específicos.

A continuación, se formula y ejecuta un comando SQL para verificar la existencia de la tabla o para crearla. Esto garantiza que la siguiente operación de copia masiva tenga una tabla de destino lista para la inserción de datos. Con la tabla lista, se emplea la clase SqlBulkCopy para transferir los datos de la DataTable directamente a la tabla SQL Server. Esta operación está diseñada para transferencias masivas de datos de alto rendimiento, por lo que es adecuada para manejar grandes volúmenes de datos de forma eficiente.

Paso 4: Ponerlo todo junto

Después de trabajar diligentemente en los pasos previos de lectura de datos CSV, establecimiento de una conexión a la base de datos y preparación para transferir los datos, llegamos a la etapa final y crucial: la integración de estos componentes individuales en un proceso cohesivo.

Esta integración se realiza en el método Main de su aplicación C#, donde todo se une, permitiendo la ejecución real de la importación de datos desde el archivo CSV a la base de datos SQL Server.

class Program
{
    static void Main(string [] args)
    {
        string filePath = "path_to_your_csv_file.csv";
        CSVReader reader = new CSVReader();
        DataTable dataTable = reader.ReadCSV(filePath);
        DataImporter importer = new DataImporter();
        importer.ImportData(dataTable);
        Console.WriteLine("Data imported successfully!");
    }
}

class Program
{
    static void Main(string [] args)
    {
        string filePath = "path_to_your_csv_file.csv";
        CSVReader reader = new CSVReader();
        DataTable dataTable = reader.ReadCSV(filePath);
        DataImporter importer = new DataImporter();
        importer.ImportData(dataTable);
        Console.WriteLine("Data imported successfully!");
    }
}

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		Dim filePath As String = "path_to_your_csv_file.csv"
		Dim reader As New CSVReader()
		Dim dataTable As DataTable = reader.ReadCSV(filePath)
		Dim importer As New DataImporter()
		importer.ImportData(dataTable)
		Console.WriteLine("Data imported successfully!")
	End Sub
End Class

Sustituya ruta_a_su_archivo_csv.csv por la ruta a su archivo CSV.

Ejecución del proyecto

Una vez que ejecutes el proyecto, verás la siguiente salida. Los mensajes de éxito representan que todas las operaciones se han ejecutado correctamente y los datos se copian en la base de datos.

Data imported successfully!

Ahora, puede abrir SQL Server Management Studio(SSMS) y comprueba la tabla de la base de datos. Verás los siguientes datos en la tabla.

Conclusión

Este tutorial le ha guiado a través del proceso de lectura de datos de un archivo CSV y su almacenamiento en una base de datos SQL Server utilizando C#. Siguiendo estos pasos y utilizando la librería IronXL, podrá gestionar eficazmente los datos CSV en sus aplicaciones C#.

IronXL ofrece unprueba gratuita para que los usuarios experimenten sus funciones antes de comprometerse a comprarlo. Esta versión de prueba totalmente funcional permite a los usuarios potenciales probar y evaluar el producto en un entorno real sin marcas de agua en la producción. Después del período de prueba, si decide seguir utilizando IronXL para sus proyectos, la licencia del producto comienza a partir de $749.