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
- Configura tu entorno de desarrollo
- Prepara tu archivo de Excel
- Conéctate a tu base de datos SQL Server
- Lee datos de archivos de Excel usando IronXL
- Exporta datos y genera un informe PDF usando IronPDF
- 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:
- Abre Visual Studio: Asegúrate de haber instalado Visual Studio en tu computadora antes de abrirlo.
- Inicia un nuevo proyecto: Elige
Archivo->Nuevo->Proyecto.

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

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

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

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.

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 ClassConexió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 ClassCombinando 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 ClassEsta 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.

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.

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 TryConclusió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.






