En el mundo digital de hoy, manejar datos de manera eficiente es una tarea importante. Un requisito común 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#, utilizando específicamente la biblioteca IronXL. Esta guía está diseñada para principiantes y se explicará de una manera simple y atractiva.

Entendiendo los conceptos básicos

¿Qué es un archivo CSV?

Un archivo 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 simplicidad y compatibilidad con varias 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. Se utiliza para almacenar y gestionar datos de manera estructurada. En nuestro caso, almacenaremos los datos CSV en una tabla de SQL Server.

Introducción a IronXL

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

How to Read and Store Data From CSV Files in C#

1. Crear un programa de consola C# en Visual Studio.
2. Instalar la biblioteca CSV utilizando el Administrador de Paquetes NuGet.
3. Cargar el archivo CSV en el programa utilizando la biblioteca.
4. Crear una conexión con la base de datos.
5. Leer el contenido del archivo CSV utilizando la biblioteca.
6. Copia ese contenido en la base de datos usando el método SqlBulkCopy.

Aquí tienes un fragmento de código de ejemplo:

using System;
using System.Data;
using System.Data.SqlClient; // For .NET Core/.NET 5+, use Microsoft.Data.SqlClient instead
using System.Globalization;
using System.IO;
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))
            {
                // Mapping the CSV data to the corresponding model
                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!");
            }
        }
    }

    // Define your model that maps to the CSV columns
    public class YourModel
    {
        // Define properties here representing the CSV columns
    }
}

using System;
using System.Data;
using System.Data.SqlClient; // For .NET Core/.NET 5+, use Microsoft.Data.SqlClient instead
using System.Globalization;
using System.IO;
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))
            {
                // Mapping the CSV data to the corresponding model
                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!");
            }
        }
    }

    // Define your model that maps to the CSV columns
    public class YourModel
    {
        // Define properties here representing the CSV columns
    }
}

Imports System
Imports System.Data
Imports System.Data.SqlClient ' For .NET Core/.NET 5+, use Microsoft.Data.SqlClient instead
Imports System.Globalization
Imports System.IO
Imports CsvHelper

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

            Using reader As New StreamReader(csvPath)
                Using csv As New CsvReader(reader, CultureInfo.InvariantCulture)
                    ' Mapping the CSV data to the corresponding model
                    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

    ' Define your model that maps to the CSV columns
    Public Class YourModel
        ' Define properties here representing the CSV columns
    End Class
End Namespace

Imports System
Imports System.Data
Imports System.Data.SqlClient ' For .NET Core/.NET 5+, use Microsoft.Data.SqlClient instead
Imports System.Globalization
Imports System.IO
Imports CsvHelper

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

            Using reader As New StreamReader(csvPath)
                Using csv As New CsvReader(reader, CultureInfo.InvariantCulture)
                    ' Mapping the CSV data to the corresponding model
                    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

    ' Define your model that maps to the CSV columns
    Public Class YourModel
        ' Define properties here representing the CSV columns
    End Class
End Namespace

Asegúrate de reemplazar "path\to\your\csv\file.csv" con la ruta actual a tu archivo CSV, YourModel con el modelo que representa tus datos CSV, "your_connection_string" con tu cadena de conexión de base de datos, y "YourTableName" con el nombre de tu tabla de base de datos.

Configuración del entorno

Prerrequisitos

1. Visual Studio: Asegúrate de tener Visual Studio instalado.
2. SQL Server: Debe tener SQL Server instalado y accesible.
3. Instalación de IronXL: Instala IronXL ejecutando el siguiente comando de NuGet:

dotnet add package IronXL.Excel

Asegúrate de ejecutar estos comandos dentro del directorio del proyecto donde deseas instalar IronXL.

Creación de una tabla de SQL Server

Antes de importar datos, crea una tabla de destino en tu base de datos SQL Server. Esta tabla almacenará los datos del CSV.

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

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

Reemplaza YourTableName, Column1, Column2 y DataType con tus detalles específicos.

Guía paso a paso para importar datos CSV

1. Primero, asegúrate de tener un archivo CSV que contenga los datos que deseas importar.

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

3. Instala el paquete NuGet CsvHelper para leer archivos CSV. Puedes hacerlo abriendo la Consola del Administrador de Paquetes NuGet en Visual Studio y ejecutando el siguiente comando:

   Install-Package CsvHelper

   SHELL

4. Agrega las declaraciones using necesarias en la parte superior de tu archivo de código C#:

   using System;
   using System.IO;
   using System.Globalization;
   using CsvHelper;
   using System.Data.SqlClient; // For .NET Core/.NET 5+, use Microsoft.Data.SqlClient instead

   Imports System
   Imports System.IO
   Imports System.Globalization
   Imports CsvHelper
   Imports System.Data.SqlClient ' For .NET Core/.NET 5+, use Microsoft.Data.SqlClient instead

   C#VB

5. En tu código, especifica la ruta de tu archivo CSV. Por ejemplo:

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

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

   C#VB

   Asegúrate de reemplazar C:\path\to\your\csv\file.csv con la ruta actual a tu archivo CSV.

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

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

   Using reader = New StreamReader(csvFilePath)
   	' code goes here
   End Using

   C#VB

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 reader = New StreamReader(csvFilePath)
   Using csv = New CsvReader(reader, CultureInfo.InvariantCulture)
   	' code goes here
   End Using
   End Using

   C#VB

8. Opcionalmente, configura el CsvReader con cualquier configuración necesaria, pasando un objeto CsvConfiguration a su constructor. Por ejemplo:

   var config = new CsvConfiguration(CultureInfo.InvariantCulture)
   {
       HasHeaderRecord = true,
   };
   using var csv = new CsvReader(reader, config);

   Imports System.Globalization
   Imports CsvHelper
   
   Dim config As New CsvConfiguration(CultureInfo.InvariantCulture) With {
       .HasHeaderRecord = True
   }
   
   Using csv As New CsvReader(reader, config)
       ' Use csv here
   End Using

   C#VB

9. Usa el método GetRecords<t>() del objeto CsvReader para leer los datos CSV en una colección de objetos. Reemplaza <t> con el tipo de objeto que representa cada registro en el archivo CSV. Por ejemplo:

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

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

   C#VB

   Asegúrate de reemplazar YourModel con el nombre actual de tu clase de modelo.

10. Itera sobre los registros y realiza cualquier procesamiento o validación requerida:

    foreach (var record in records)
    {
        // Process each record as needed
    }

    For Each record In records
    	' Process each record as needed
    Next record

    C#VB

11. Opcionalmente, establece una conexión a tu base de datos SQL Server utilizando ADO.NET o una herramienta ORM como Entity Framework.

12. Inserta cada registro en la base de datos utilizando el mecanismo de acceso a la base de datos que hayas elegido. Por ejemplo, si estás usando ADO.NET, puedes aprovechar la clase SqlBulkCopy para insertar datos de forma eficiente en bloque.

13. Maneja cualquier excepción que pueda ocurrir durante el proceso de importación y proporciona mensajes de error o registros apropiados.

14. Prueba tu aplicación ejecutándola y verifica que los datos del CSV se hayan importado exitosamente en tu base de datos.

using IronPDF; Ahora has importado exitosamente datos CSV en tu base de datos SQL Server utilizando C#.

Paso 1: Lectura del archivo CSV

Al comenzar la tarea de importar datos de un archivo CSV, el primer paso crucial es leer los datos dentro del mismo con precisión. Cada línea en un archivo CSV típicamente representa un registro de datos, y cada registro consta de uno o más campos, separados por comas.

Luego empleamos la biblioteca IronXL para manejar el archivo CSV. Para leer el archivo CSV usando IronXL, usará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 cargas 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;
using System.Data;

public class CSVReader
{
    // Reads a CSV file and converts it to a DataTable
    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;
using System.Data;

public class CSVReader
{
    // Reads a CSV file and converts it to a DataTable
    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
Imports System.Data

Public Class CSVReader
	' Reads a CSV file and converts it to a DataTable
	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

Imports IronXL
Imports System.Data

Public Class CSVReader
	' Reads a CSV file and converts it to a DataTable
	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 a la base de datos

Establecer una conexión a tu base de datos SQL Server es un paso fundamental en el proceso de almacenar tus datos CSV. Este paso implica configurar un enlace de comunicación entre tu aplicación y el servidor de base de datos. Una conexión exitosa es crucial porque, sin ella, transferir datos a la base de datos sería imposible.

Este paso se centra en crear y abrir 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 a tu base de datos.

using System.Data.SqlClient; // For .NET Core/.NET 5+, use Microsoft.Data.SqlClient instead

public class DatabaseConnector
{
    // Connection string to connect to the database
    private string connectionString = "your_connection_string_here";

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

using System.Data.SqlClient; // For .NET Core/.NET 5+, use Microsoft.Data.SqlClient instead

public class DatabaseConnector
{
    // Connection string to connect to the database
    private string connectionString = "your_connection_string_here";

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

Imports System.Data.SqlClient ' For .NET Core/.NET 5+, use Microsoft.Data.SqlClient instead

Public Class DatabaseConnector
    ' Connection string to connect to the database
    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

Imports System.Data.SqlClient ' For .NET Core/.NET 5+, use Microsoft.Data.SqlClient instead

Public Class DatabaseConnector
    ' Connection string to connect to the database
    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 conectar a tu SQL Server. Típicamente incluye 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 se ve así: Server=myServerAddress;Database=myDataBase;User Id=myUsername;Password=myPassword;. Es esencial reemplazar estos marcadores de posición con los detalles de tu servidor real.

Paso 3: Almacenamiento de datos en la base de datos

Habiendo establecido una conexión con la base de datos SQL Server, el siguiente paso crítico es almacenar los datos CSV en la base de datos. Este paso involucra transferir los datos que has leído y procesado a tu tabla de SQL Server. Es una parte crucial del proceso de manejo de datos, ya que involucra la migración de datos reales de un archivo local a un servidor de base de datos.

En este paso, nos enfocaremos en cómo los datos CSV, ahora almacenados en un DataTable, se transfieren a la base de datos SQL Server. Usamos una combinación de características de C# y SQL Server para lograr esta tarea de manera eficiente.

using System;
using System.Data;
using System.Data.SqlClient; // For .NET Core/.NET 5+, use Microsoft.Data.SqlClient instead

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);
                }
            }
        }
    }
}

using System;
using System.Data;
using System.Data.SqlClient; // For .NET Core/.NET 5+, use Microsoft.Data.SqlClient instead

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);
                }
            }
        }
    }
}

Imports System
Imports System.Data
Imports System.Data.SqlClient ' For .NET Core/.NET 5+, use Microsoft.Data.SqlClient instead

Public Class DataImporter
    Public Sub ImportData(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
            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

Imports System
Imports System.Data
Imports System.Data.SqlClient ' For .NET Core/.NET 5+, use Microsoft.Data.SqlClient instead

Public Class DataImporter
    Public Sub ImportData(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
            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

Se inicia abriendo una conexión con la base de datos SQL Server usando la clase DatabaseConnector, asegurando un camino para las transacciones de datos. El método verifica la existencia de la tabla llamada "CSVData" dentro de la base de datos.

Si la tabla no se encuentra, procede a crearla. El esquema de la tabla se construye basado en el esquema DataTable pasado al método, con todas las columnas configuradas en NVARCHAR(MAX) para acomodar cualquier dato de texto. Este es un enfoque genérico y puede necesitar refinamiento para ajustar más de cerca los tipos de datos específicos.

Después de eso, se formula y ejecuta un comando SQL para verificar la existencia de la tabla o para crearla. Esto asegura que la operación de copiado en bloque subsiguiente tenga una tabla de destino lista para la inserción de datos. Con la tabla lista, se emplea la clase SqlBulkCopy para transferir datos desde el DataTable directamente a la tabla SQL Server. Esta operación está diseñada para transferencias de datos en bloque de alto rendimiento, lo que la hace adecuada para manejar grandes volúmenes de datos de manera eficiente.

Paso 4: Poniéndolo todo junto

Después de trabajar diligentemente en los pasos anteriores de leer datos CSV, establecer una conexión a la base de datos y prepararse para transferir los datos, llegamos a la etapa final y crucial: integrar estos componentes individuales en un proceso cohesivo.

Esta integración se realiza en el método Main de tu aplicación C#, donde todo se junta, 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

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

Reemplaza path_to_your_csv_file.csv con la ruta a tu archivo CSV.

Ejecución del proyecto

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

Data imported successfully!

Data imported successfully!

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

Conclusión

Este tutorial te ha guiado a través del proceso de leer datos de un archivo CSV y almacenarlos en una base de datos SQL Server usando C#. Al seguir estos pasos y utilizar la biblioteca IronXL, puedes gestionar eficazmente los datos CSV en tus aplicaciones C#.

IronXL ofrece una prueba gratuita para que los usuarios experimenten sus características antes de comprometerse con una compra. Esta prueba completamente funcional permite a los usuarios potenciales probar y evaluar el producto en un entorno en vivo sin marcas de agua en la producción. Después del período de prueba, si decides continuar usando IronXL para tus proyectos, la licencia para el producto comienza desde $999.