Saltar al pie de página
USANDO IRONXL

Cómo importar Excel a SQL Server en C#

En muchos contextos empresariales diferentes, importar datos de Excel a SQL Server es una necesidad típica. Leer datos de un archivo de Excel e ingresarlos en una base de datos de SQL Server son las tareas involucradas en esta actividad. Aunque a menudo se usa el asistente de exportación, IronXL proporciona un enfoque más programático y flexible para el manejo de datos. IronXL es una poderosa biblioteca de C# que puede importar datos de Excel desde archivos; por lo tanto, es posible agilizar esta operación. Para ese fin, este post ofrecerá una guía completa que aborda la configuración, ejecución y mejora de la importación de Excel a SQL Server usando C#.

Cómo importar Excel a SQL Server en C#: Figura 1 - IronXL: La biblioteca de Excel para C#

Cómo importar Excel a SQL Server en C

  1. Configura tu entorno de desarrollo
  2. Prepara tu archivo de Excel
  3. Conéctate a tu base de datos SQL Server
  4. Lee datos de archivos de Excel usando IronXL
  5. Exporta datos y genera un informe PDF usando IronPDF
  6. Revisa el informe PDF

¿Qué es IronXL?

IronXL, a veces referido como IronXL.Excel, es una biblioteca de C# rica en funciones diseñada para facilitar el trabajo con archivos Excel en aplicaciones .NET. Esta herramienta robusta es ideal para aplicaciones del lado del servidor ya que permite a los desarrolladores leer, crear y editar archivos Excel sin necesidad de instalar Microsoft Excel en la computadora. Excel 2007 y posteriores (.xlsx) y formatos Excel 97–2003 (.xls) son compatibles con IronXL, proporcionando versatilidad en la gestión de varias versiones de archivos Excel. Permite una manipulación significativa de datos, como manipular hojas de trabajo, filas y columnas además de insertar, actualizar y eliminar datos.

IronXL también admite formato de celdas y fórmulas de Excel, permitiendo la generación programada de hojas de cálculo complejas y bien formateadas. Con su optimización de rendimiento y compatibilidad con múltiples plataformas .NET, incluyendo .NET Framework, .NET Core y .NET 5/6, IronXL garantiza un manejo efectivo de grandes conjuntos de datos. Es una opción flexible para los desarrolladores que deseen integrar operaciones de archivo Excel en sus aplicaciones, ya sea para actividades sencillas de importación/exportación de datos o sistemas de reporte intrincados, gracias a su interfaz fluida con otros marcos .NET.

Características clave

Leer y escribir archivos de Excel

Los desarrolladores pueden leer y escribir datos hacia y desde archivos Excel usando IronXL. Es sencillo crear nuevos archivos Excel y editar los existentes.

No se requiere instalación para Microsoft Excel

A diferencia de ciertas otras bibliotecas, IronXL no requiere la instalación de Microsoft Excel en la computadora que alberga la aplicación. Es perfecto para aplicaciones del lado del servidor por esto.

Compatibilidad con varios formatos de Excel

La biblioteca ofrece versatilidad en la gestión de varios tipos de archivos Excel al soportar los formatos .xls (Excel 97-2003) y .xlsx (Excel 2007 y posteriores).

Crear un nuevo proyecto de Visual Studio

Es sencillo crear un proyecto de consola en Visual Studio. En Visual Studio, realice las siguientes acciones para crear una aplicación de consola:

  1. Abre Visual Studio: Asegúrate de haber instalado Visual Studio en tu computadora antes de abrirlo.
  2. Inicia un nuevo proyecto: Elige Archivo -> Nuevo -> Proyecto.

Cómo importar Excel a SQL Server en C#: Figura 2 - Haga clic en Nuevo

  1. Desde el panel izquierdo del cuadro Crear un nuevo proyecto, selecciona tu lenguaje de programación preferido, por ejemplo, C#.
  2. Selecciona la plantilla Aplicación Console o Aplicación Console (.NET Core) de la lista de plantillas de proyectos disponibles.
  3. En el área Nombre, dale un nombre a tu proyecto.

Cómo importar Excel a SQL Server en C#: Figura 3 - Proporcione un nombre y una ubicación para guardar

  1. Decide una ubicación para guardar el proyecto.
  2. Haz clic en Crear para iniciar un proyecto de aplicación para un Console.

Cómo importar Excel a SQL Server en C#: Figura 4 - Finalmente haga clic en crear para iniciar una aplicación

Instalación de la biblioteca IronXL

Se requiere instalar la biblioteca IronXL debido a la próxima actualización. Por último, para completar el procedimiento, lanza la Consola del Administrador de Paquetes NuGet y escribe el siguiente comando:

Install-Package IronXL.Excel

Cómo importar Excel a SQL Server en C#: Figura 5 - Ingrese el comando anterior en la Consola del Administrador de Paquetes NuGet para instalar IronXL

Usar el Administrador de Paquetes NuGet para buscar el paquete IronXL es otro método. Esto nos permite seleccionar cuál de los paquetes NuGet vinculados a IronXL descargar.

Cómo importar Excel a SQL Server en C#: Figura 6 - Alternativamente, busca IronXL usando el Administrador de Paquetes NuGet e instálalo

Importar Excel a SQL con IronXL

Lectura de datos de Excel con IronXL

El proceso de lectura de datos de archivos Excel se facilita con IronXL. El siguiente ejemplo te muestra cómo usar IronXL para leer datos de un archivo Excel. Con este enfoque, los datos se leen y se guardan en una lista de diccionarios, cada uno de los cuales corresponde a una fila en la hoja Excel.

using IronXL;
using System;
using System.Collections.Generic;

public class ExcelReader
{
    public static List<Dictionary<string, object>> ReadExcelFile(string filePath)
    {
        // Initialize a list to store data from Excel
        var data = new List<Dictionary<string, object>>();

        // Load the workbook from the file path provided
        WorkBook workbook = WorkBook.Load(filePath);

        // Access the first worksheet in the workbook
        WorkSheet sheet = workbook.WorkSheets[0];

        // Retrieve column headers from the first row
        var headers = new List<string>();
        foreach (var header in sheet.Rows[0].Columns)
        {
            headers.Add(header.ToString());
        }

        // Loop through each row starting from the second row
        for (int i = 1; i < sheet.Rows.Count; i++)
        {
            // Create a dictionary to store the row data associated with column headers
            var rowData = new Dictionary<string, object>();
            for (int j = 0; j < headers.Count; j++)
            {
                rowData[headers[j]] = sheet.Rows[i][j].Value;
            }
            data.Add(rowData);
        }

        return data;
    }
}
using IronXL;
using System;
using System.Collections.Generic;

public class ExcelReader
{
    public static List<Dictionary<string, object>> ReadExcelFile(string filePath)
    {
        // Initialize a list to store data from Excel
        var data = new List<Dictionary<string, object>>();

        // Load the workbook from the file path provided
        WorkBook workbook = WorkBook.Load(filePath);

        // Access the first worksheet in the workbook
        WorkSheet sheet = workbook.WorkSheets[0];

        // Retrieve column headers from the first row
        var headers = new List<string>();
        foreach (var header in sheet.Rows[0].Columns)
        {
            headers.Add(header.ToString());
        }

        // Loop through each row starting from the second row
        for (int i = 1; i < sheet.Rows.Count; i++)
        {
            // Create a dictionary to store the row data associated with column headers
            var rowData = new Dictionary<string, object>();
            for (int j = 0; j < headers.Count; j++)
            {
                rowData[headers[j]] = sheet.Rows[i][j].Value;
            }
            data.Add(rowData);
        }

        return data;
    }
}
Imports IronXL
Imports System
Imports System.Collections.Generic

Public Class ExcelReader
	Public Shared Function ReadExcelFile(ByVal filePath As String) As List(Of Dictionary(Of String, Object))
		' Initialize a list to store data from Excel
		Dim data = New List(Of Dictionary(Of String, Object))()

		' Load the workbook from the file path provided
		Dim workbook As WorkBook = WorkBook.Load(filePath)

		' Access the first worksheet in the workbook
		Dim sheet As WorkSheet = workbook.WorkSheets(0)

		' Retrieve column headers from the first row
		Dim headers = New List(Of String)()
		For Each header In sheet.Rows(0).Columns
			headers.Add(header.ToString())
		Next header

		' Loop through each row starting from the second row
		For i As Integer = 1 To sheet.Rows.Count - 1
			' Create a dictionary to store the row data associated with column headers
			Dim rowData = New Dictionary(Of String, Object)()
			For j As Integer = 0 To headers.Count - 1
				rowData(headers(j)) = sheet.Rows(i)(j).Value
			Next j
			data.Add(rowData)
		Next i

		Return data
	End Function
End Class
$vbLabelText   $csharpLabel

Conexión a SQL Server

Utiliza la clase SqlConnection del espacio de nombres System.Data.SqlClient para establecer una conexión con SQL Server. Asegúrate de tener la cadena de conexión correcta, que normalmente consta del nombre de la base de datos, el nombre del servidor e información de autenticación. Cómo conectar a una base de datos SQL Server y agregar datos se cubre en el siguiente ejemplo.

using System;
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Linq;

public class SqlServerConnector
{
    private string connectionString;

    // Constructor accepts a connection string
    public SqlServerConnector(string connectionString)
    {
        this.connectionString = connectionString;
    }

    // Inserts data into the specified table
    public void InsertData(Dictionary<string, object> data, string tableName)
    {
        using (SqlConnection connection = new SqlConnection(connectionString))
        {
            connection.Open();

            // Construct an SQL INSERT command with parameterized values to prevent SQL injection
            var columns = string.Join(",", data.Keys);
            var parameters = string.Join(",", data.Keys.Select(key => "@" + key));
            string query = $"INSERT INTO {tableName} ({columns}) VALUES ({parameters})";

            using (SqlCommand command = new SqlCommand(query, connection))
            {
                // Add parameters to the command
                foreach (var kvp in data)
                {
                    command.Parameters.AddWithValue("@" + kvp.Key, kvp.Value ?? DBNull.Value);
                }

                // Execute the command
                command.ExecuteNonQuery();
            }
        }
    }
}
using System;
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Linq;

public class SqlServerConnector
{
    private string connectionString;

    // Constructor accepts a connection string
    public SqlServerConnector(string connectionString)
    {
        this.connectionString = connectionString;
    }

    // Inserts data into the specified table
    public void InsertData(Dictionary<string, object> data, string tableName)
    {
        using (SqlConnection connection = new SqlConnection(connectionString))
        {
            connection.Open();

            // Construct an SQL INSERT command with parameterized values to prevent SQL injection
            var columns = string.Join(",", data.Keys);
            var parameters = string.Join(",", data.Keys.Select(key => "@" + key));
            string query = $"INSERT INTO {tableName} ({columns}) VALUES ({parameters})";

            using (SqlCommand command = new SqlCommand(query, connection))
            {
                // Add parameters to the command
                foreach (var kvp in data)
                {
                    command.Parameters.AddWithValue("@" + kvp.Key, kvp.Value ?? DBNull.Value);
                }

                // Execute the command
                command.ExecuteNonQuery();
            }
        }
    }
}
Imports System
Imports System.Collections.Generic
Imports System.Data.SqlClient
Imports System.Linq

Public Class SqlServerConnector
	Private connectionString As String

	' Constructor accepts a connection string
	Public Sub New(ByVal connectionString As String)
		Me.connectionString = connectionString
	End Sub

	' Inserts data into the specified table
	Public Sub InsertData(ByVal data As Dictionary(Of String, Object), ByVal tableName As String)
		Using connection As New SqlConnection(connectionString)
			connection.Open()

			' Construct an SQL INSERT command with parameterized values to prevent SQL injection
			Dim columns = String.Join(",", data.Keys)
			Dim parameters = String.Join(",", data.Keys.Select(Function(key) "@" & key))
			Dim query As String = $"INSERT INTO {tableName} ({columns}) VALUES ({parameters})"

			Using command As New SqlCommand(query, connection)
				' Add parameters to the command
				For Each kvp In data
					command.Parameters.AddWithValue("@" & kvp.Key, If(kvp.Value, DBNull.Value))
				Next kvp

				' Execute the command
				command.ExecuteNonQuery()
			End Using
		End Using
	End Sub
End Class
$vbLabelText   $csharpLabel

Combinando IronXL con SQL Server

Una vez que se ha establecido la lógica para leer archivos Excel e insertar datos en una base de datos SQL, integra estas características para terminar el proceso de importación. La aplicación que sigue recibe información de un archivo Excel y la agrega a una base de datos de Microsoft SQL Server.

using System;
using System.Collections.Generic;

class Program
{
    static void Main(string[] args)
    {
        // Define the path to the Excel file, SQL connection string, and target table name
        string excelFilePath = "path_to_your_excel_file.xlsx";
        string connectionString = "your_sql_server_connection_string";
        string tableName = "your_table_name";

        // Read data from Excel
        List<Dictionary<string, object>> excelData = ExcelReader.ReadExcelFile(excelFilePath);

        // Create an instance of the SQL connector and insert data
        SqlServerConnector sqlConnector = new SqlServerConnector(connectionString);
        foreach (var row in excelData)
        {
            sqlConnector.InsertData(row, tableName);
        }

        Console.WriteLine("Data import completed successfully.");
    }
}
using System;
using System.Collections.Generic;

class Program
{
    static void Main(string[] args)
    {
        // Define the path to the Excel file, SQL connection string, and target table name
        string excelFilePath = "path_to_your_excel_file.xlsx";
        string connectionString = "your_sql_server_connection_string";
        string tableName = "your_table_name";

        // Read data from Excel
        List<Dictionary<string, object>> excelData = ExcelReader.ReadExcelFile(excelFilePath);

        // Create an instance of the SQL connector and insert data
        SqlServerConnector sqlConnector = new SqlServerConnector(connectionString);
        foreach (var row in excelData)
        {
            sqlConnector.InsertData(row, tableName);
        }

        Console.WriteLine("Data import completed successfully.");
    }
}
Imports System
Imports System.Collections.Generic

Friend Class Program
	Shared Sub Main(ByVal args() As String)
		' Define the path to the Excel file, SQL connection string, and target table name
		Dim excelFilePath As String = "path_to_your_excel_file.xlsx"
		Dim connectionString As String = "your_sql_server_connection_string"
		Dim tableName As String = "your_table_name"

		' Read data from Excel
		Dim excelData As List(Of Dictionary(Of String, Object)) = ExcelReader.ReadExcelFile(excelFilePath)

		' Create an instance of the SQL connector and insert data
		Dim sqlConnector As New SqlServerConnector(connectionString)
		For Each row In excelData
			sqlConnector.InsertData(row, tableName)
		Next row

		Console.WriteLine("Data import completed successfully.")
	End Sub
End Class
$vbLabelText   $csharpLabel

Esta clase está a cargo de usar IronXL para leer los datos del archivo Excel dado. La función ReadExcelFile carga el libro Excel, abre la primera hoja de trabajo y recopila datos al recorrer las filas de la hoja de datos. Para facilitar la gestión de las tablas, la informacion se guarda en una lista de diccionarios.

Cómo importar Excel a SQL Server en C#: Figura 7 - Ejemplo de archivo de entrada de Excel

La clase inserta los datos en la tabla de base de datos designada, la cual también gestiona la conexión a la base de datos SQL Server. El método InsertData utiliza consultas parametrizadas para prevenir la inyección SQL y construye dinámicamente una consulta SQL INSERT basada en las claves del diccionario, que representan nombres de columna.

Usando la clase ExcelReader para leer los datos en la tabla SQL del archivo Excel y la clase SqlServerConnector para insertar cada fila en la tabla SQL Server, la función Main gestiona todo el proceso.

Cómo importar Excel a SQL Server en C#: Figura 8 - Salida mostrando una consulta exitosa en el SQL Server

El manejo de errores y la optimización son cruciales para asegurar un proceso de importación sólido y eficiente. La implementación de un manejo de errores robusto puede gestionar problemas potenciales como archivos faltantes, formatos de datos no válidos y excepciones SQL. Aquí hay un ejemplo de incorporación de manejo de errores.

try
{
    // Insert the importing logic here
}
catch (Exception ex)
{
    Console.WriteLine("An error occurred: " + ex.Message);
}
try
{
    // Insert the importing logic here
}
catch (Exception ex)
{
    Console.WriteLine("An error occurred: " + ex.Message);
}
Try
	' Insert the importing logic here
Catch ex As Exception
	Console.WriteLine("An error occurred: " & ex.Message)
End Try
$vbLabelText   $csharpLabel

Conclusión

Finalmente, un método efectivo y confiable para gestionar archivos Excel dentro de aplicaciones .NET es importar datos de Excel a una base SQL Server usando C# y IronXL. IronXL es compatible con múltiples formatos Excel y tiene capacidades sólidas que facilitan la lectura y escritura de datos de Excel sin la necesidad de instalar Microsoft Excel. A través de la integración de System.Data.SqlClient con IronXL, los desarrolladores pueden mover fácilmente datos entre SQL Servers utilizando consultas parametrizadas para mejorar la seguridad y prevenir la inyección SQL.

Finalmente, agregar IronXL e Iron Software a tu conjunto de herramientas para desarrollo .NET te permite manipular Excel de manera eficiente, crear PDFs, realizar OCR y utilizar códigos de barras. La combinación de la suite flexible de Iron Software con la simplicidad de uso, interoperabilidad y rendimiento de IronXL garantiza un desarrollo optimizado y capacidades mejoradas de la aplicación. Con opciones de licencia claras que están personalizadas a los requisitos del proyecto, los desarrolladores pueden seleccionar con confianza el modelo correcto. Aprovechando estos beneficios, los desarrolladores pueden abordar eficazmente una gama de dificultades mientras mantienen el cumplimiento y la transparencia.

Preguntas Frecuentes

¿Cuál es la mejor manera de importar datos de Excel a SQL Server usando C#?

Usando la biblioteca IronXL, puede importar eficientemente datos de Excel a SQL Server leyendo el archivo de Excel e insertando los datos en la base de datos sin necesidad de tener Microsoft Excel instalado.

¿Cómo puedo leer archivos de Excel en C# sin usar Microsoft Excel?

IronXL le permite leer archivos de Excel en C# sin requerir Microsoft Excel. Puede cargar el libro de Excel, acceder a las hojas de trabajo, y extraer datos usando métodos sencillos.

¿Cuáles son los pasos para conectar un archivo de Excel a SQL Server en una aplicación C#?

Primero, use IronXL para leer el archivo de Excel. Luego, establezca una conexión con SQL Server usando la clase SqlConnection y use SqlCommand para insertar datos en la base de datos SQL.

¿Por qué debería usar IronXL para operaciones de Excel en aplicaciones .NET?

IronXL ofrece un manejo eficiente de datos, compatibilidad con múltiples plataformas .NET y no requiere la instalación de Excel, lo que lo hace ideal para aplicaciones del lado del servidor y manejo de grandes conjuntos de datos.

¿Cómo manejo grandes conjuntos de datos de Excel en C#?

IronXL proporciona soporte robusto para grandes conjuntos de datos, permitiéndole leer y manipular eficientemente datos en archivos de Excel e integrarlos en aplicaciones sin problemas de rendimiento.

¿Qué estrategias de manejo de errores se deben usar al importar Excel a SQL Server?

Implemente bloques try-catch para manejar errores potenciales como archivo no encontrado, formatos de datos inválidos o excepciones de SQL para asegurar un proceso de importación fluido.

¿Puedo automatizar la importación de datos de Excel a SQL Server en una aplicación C#?

Sí, usando IronXL, puede automatizar el proceso de importación escribiendo una aplicación C# que lea archivos de Excel e inserte los datos en SQL Server con minimal intervención manual.

¿Cómo las consultas parametrizadas previenen la inyección SQL en C#?

Las consultas parametrizadas en C# le permiten insertar datos de manera segura en SQL Server usando marcadores de posición para los parámetros en los comandos SQL, lo que ayuda a prevenir ataques de inyección SQL.

¿Cómo puedo optimizar el rendimiento de la importación de datos de Excel a SQL Server?

Optimice el rendimiento usando inserciones por lotes, manejando grandes conjuntos de datos eficientemente con IronXL, y asegurando que su conexión y comandos SQL Server estén correctamente configurados.

¿Cuáles son las opciones de licencia para usar IronXL en un proyecto?

IronXL ofrece opciones de licencia flexibles adaptadas a las necesidades del proyecto, permitiendo a los desarrolladores elegir el mejor plan que se ajuste a los requisitos de su aplicación y presupuesto.

Jordi Bardia
Ingeniero de Software
Jordi es más competente en Python, C# y C++. Cuando no está aprovechando sus habilidades en Iron Software, está programando juegos. Compartiendo responsabilidades para pruebas de productos, desarrollo de productos e investigación, Jordi agrega un valor inmenso a la mejora continua del producto. La experiencia variada lo mantiene ...
Leer más