La exportación de datos de SQL Server a Microsoft Excel es una tarea habitual para los desarrolladores de .NET que crean sistemas de generación de informes, herramientas de análisis de datos y aplicaciones empresariales. Este tutorial le muestra cómo exportar datos SQL a Excel utilizando C# con la biblioteca IronXL, una biblioteca .NET para Excel que gestiona todo el proceso sin necesidad de instalar Microsoft Office.
Inicia tu prueba gratuita para seguir los ejemplos de código que aparecen a continuación.
Antes de escribir cualquier código, debes añadir IronXL a tu proyecto. La forma más rápida es a través de la consola del gestor de paquetes NuGet en Visual Studio:
Alternativamente, utilice la CLI de .NET :
Una vez instalado, añade los espacios de nombres necesarios al principio de tu archivo. Con las sentencias de nivel superior de .NET 10, tu configuración tendrá este aspecto:
using IronXL;
using System.Data;
using System.Data.SqlClient;Imports IronXL
Imports System.Data
Imports System.Data.SqlClientIronXL está destinado a .NET Standard 2.0 y versiones superiores, por lo que funciona con proyectos de .NET 10, .NET Framework, ASP.NET Core y Blazor sin necesidad de configuración adicional. Puedes encontrar el paquete en NuGet.
El método más eficaz para exportar datos de SQL Server a un archivo de Excel consta de tres pasos: establecer una conexión con la base de datos, recuperar los datos en un DataTable y escribir los datos en una hoja de cálculo de Excel utilizando IronXL. A diferencia de las soluciones de interoperabilidad de Microsoft, IronXL funciona de forma independiente y gestiona grandes conjuntos de datos sin los cuellos de botella en el rendimiento que supone la sobrecarga de la interoperabilidad COM.
El patrón básico es sencillo. SqlDataAdapter forma parte del marco de acceso a datos ADO.NET de Microsoft y ha sido la forma estándar de rellenar objetos DataTable desde bases de datos relacionales desde .NET 1.0:
SqlConnection con tu cadena de conexiónSqlDataAdapter para rellenar un DataTable o DataSet.xlsx o .xlsEste enfoque es compatible con SQL Server 2012 y versiones posteriores, así como con Azure SQL Database, Amazon RDS para SQL Server y cualquier fuente de datos compatible con ADO.NET. El mismo patrón se aplica tanto si se trabaja con una aplicación de consola como con una herramienta de generación de informes basada en web.
Antes de poder exportar datos SQL, es necesario establecer una conexión y ejecutar una consulta SQL para rellenar un DataTable. La cadena de conexión contiene las credenciales de la base de datos SQL Server y la información del servidor necesaria para acceder a sus datos.
El siguiente ejemplo consulta la tabla Northwind Customers y escribe cada fila en una hoja de cálculo de Excel utilizando la API de escritura de celdas de IronXL:
using IronXL;
using System.Data;
using System.Data.SqlClient;
string connectionString = "Data Source=localhost;Initial Catalog=Northwind;Integrated Security=True";
string sql = "SELECT * FROM Customers";
using SqlConnection connection = new SqlConnection(connectionString);
connection.Open();
SqlDataAdapter adapter = new SqlDataAdapter(sql, connection);
DataTable dt = new DataTable();
adapter.Fill(dt);
WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet workSheet = workBook.CreateWorkSheet("Customers");
// Write column headers
for (int col = 0; col < dt.Columns.Count; col++)
{
workSheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
}
// Write data rows
for (int row = 0; row < dt.Rows.Count; row++)
{
for (int col = 0; col < dt.Columns.Count; col++)
{
workSheet.SetCellValue(row + 1, col, dt.Rows[row][col].ToString());
}
}
workBook.SaveAs("CustomerExport.xlsx");Imports IronXL
Imports System.Data
Imports System.Data.SqlClient
Dim connectionString As String = "Data Source=localhost;Initial Catalog=Northwind;Integrated Security=True"
Dim sql As String = "SELECT * FROM Customers"
Using connection As New SqlConnection(connectionString)
connection.Open()
Dim adapter As New SqlDataAdapter(sql, connection)
Dim dt As New DataTable()
adapter.Fill(dt)
Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim workSheet As WorkSheet = workBook.CreateWorkSheet("Customers")
' Write column headers
For col As Integer = 0 To dt.Columns.Count - 1
workSheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
Next
' Write data rows
For row As Integer = 0 To dt.Rows.Count - 1
For col As Integer = 0 To dt.Columns.Count - 1
workSheet.SetCellValue(row + 1, col, dt.Rows(row)(col).ToString())
Next
Next
workBook.SaveAs("CustomerExport.xlsx")
End Using
Este código crea un archivo Excel con cabeceras de columna con el formato adecuado derivadas de la estructura de tabla de SQL Server. El DataTable dt almacena los resultados de la consulta, que luego se escriben en cada celda de forma sistemática utilizando índices de filas y columnas basados en cero. IronXL es compatible con los formatos .xls y .xlsx para garantizar una amplia compatibilidad con las aplicaciones de Microsoft Office.
Si su tabla SQL contiene DateTime o columnas numéricas, convierta los valores de las celdas adecuadamente antes de llamar a SetCellValue. Al pasar los tipos numéricos directamente, se conservan los tipos de datos de Excel y se permite ordenar y realizar cálculos con fórmulas en las columnas exportadas.
Cuando su informe necesite datos de varias tablas SQL —por ejemplo, Productos y Categorías—, puede cargarlas en un DataSet y dejar que IronXL cree automáticamente una hoja de cálculo por tabla. Este es el método más conciso para exportar un DataSet o una DataTable a Excel.
using IronXL;
using System.Data;
using System.Data.SqlClient;
string connectionString = "Data Source=.;Initial Catalog=Inventory;Integrated Security=True";
using SqlConnection connection = new SqlConnection(connectionString);
connection.Open();
SqlDataAdapter productsAdapter = new SqlDataAdapter("SELECT * FROM Products", connection);
SqlDataAdapter categoriesAdapter = new SqlDataAdapter("SELECT * FROM Categories", connection);
DataSet dataSet = new DataSet();
productsAdapter.Fill(dataSet, "Products");
categoriesAdapter.Fill(dataSet, "Categories");
WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkBook.LoadWorkSheetsFromDataSet(dataSet, workBook);
workBook.SaveAs("InventoryReport.xlsx");Imports IronXL
Imports System.Data
Imports System.Data.SqlClient
Dim connectionString As String = "Data Source=.;Initial Catalog=Inventory;Integrated Security=True"
Using connection As New SqlConnection(connectionString)
connection.Open()
Dim productsAdapter As New SqlDataAdapter("SELECT * FROM Products", connection)
Dim categoriesAdapter As New SqlDataAdapter("SELECT * FROM Categories", connection)
Dim dataSet As New DataSet()
productsAdapter.Fill(dataSet, "Products")
categoriesAdapter.Fill(dataSet, "Categories")
Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
WorkBook.LoadWorkSheetsFromDataSet(dataSet, workBook)
workBook.SaveAs("InventoryReport.xlsx")
End Using
LoadWorkSheetsFromDataSet lee la propiedad TableName de cada DataTable dentro de DataSet y crea una pestaña de hoja de cálculo correspondiente. Los nombres de las columnas de DataTable se convierten en la fila de encabezado de cada hoja. Este método resulta especialmente útil para procedimientos almacenados que devuelven varios conjuntos de resultados, ya que permite rellenar DataSet mediante varias llamadas a SqlDataAdapter y, a continuación, exportarlo todo en un solo paso.
En el caso de aplicaciones que necesiten crear archivos de Excel mediante programación con formato personalizado, se puede seguir accediendo a hojas de cálculo individuales tras llamar a LoadWorkSheetsFromDataSet y aplicar estilos, anchos de columna o fórmulas antes de guardar.
En el caso de las aplicaciones web, normalmente se activa la exportación cuando un usuario hace clic en un botón. El siguiente ejemplo de formularios web de ASP.NET muestra cómo gestionar el evento de clic del botón, crear el libro de Excel a partir de una consulta SQL y enviar el archivo al navegador como descarga utilizando Response.AddHeader:
using IronXL;
using System;
using System.Data;
using System.Data.SqlClient;
using System.IO;
using System.Web.UI;
public partial class ExportPage : Page
{
private void ExportButton_Click(object sender, EventArgs e)
{
string connectionString = "Data Source=localhost;Initial Catalog=Sales;Integrated Security=True";
using SqlConnection connection = new SqlConnection(connectionString);
SqlDataAdapter adapter = new SqlDataAdapter("SELECT * FROM Orders", connection);
DataSet dataSet = new DataSet();
adapter.Fill(dataSet);
WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkBook.LoadWorkSheetsFromDataSet(dataSet, workBook);
byte[] fileBytes = workBook.ToByteArray();
string filename = "OrdersExport.xlsx";
Response.Clear();
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
Response.AddHeader("content-disposition", "attachment;filename=" + filename);
Response.BinaryWrite(fileBytes);
Response.End();
}
}Imports IronXL
Imports System
Imports System.Data
Imports System.Data.SqlClient
Imports System.IO
Imports System.Web.UI
Public Partial Class ExportPage
Inherits Page
Private Sub ExportButton_Click(sender As Object, e As EventArgs)
Dim connectionString As String = "Data Source=localhost;Initial Catalog=Sales;Integrated Security=True"
Using connection As New SqlConnection(connectionString)
Dim adapter As New SqlDataAdapter("SELECT * FROM Orders", connection)
Dim dataSet As New DataSet()
adapter.Fill(dataSet)
Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
WorkBook.LoadWorkSheetsFromDataSet(dataSet, workBook)
Dim fileBytes As Byte() = workBook.ToByteArray()
Dim filename As String = "OrdersExport.xlsx"
Response.Clear()
Response.ContentType = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
Response.AddHeader("content-disposition", "attachment;filename=" & filename)
Response.BinaryWrite(fileBytes)
Response.End()
End Using
End Sub
End Class
El método ToByteArray() convierte todo el libro de trabajo en una matriz de bytes en memoria, que luego se escribe directamente en el flujo de respuesta HTTP. Esto evita escribir un archivo temporal en el disco. A diferencia de Microsoft Interop, que requiere marcadores de posición object misValue y una licencia de Office instalada en el servidor, IronXL se ejecuta íntegramente en código administrado sin dependencias externas.
Para proyectos de .NET Core y Razor Pages, sustituya Response.BinaryWrite por return File(fileBytes, contentType, filename) en la acción de su controlador. El patrón de exportación de .NET Core a Excel sigue el mismo enfoque de "libro de trabajo a matriz de bytes".
Las exportaciones de SQL sin procesar suelen necesitar mejoras de presentación antes de compartirlas con los usuarios finales. IronXL le permite controlar los estilos de celda, el ancho de las columnas y los formatos numéricos una vez que los datos se han escrito en la hoja de cálculo. El siguiente ejemplo muestra cómo poner en negrita la fila de encabezado y ajustar automáticamente el ancho de las columnas:
using IronXL;
using System.Data;
using System.Data.SqlClient;
string connectionString = "Data Source=localhost;Initial Catalog=Sales;Integrated Security=True";
using SqlConnection connection = new SqlConnection(connectionString);
connection.Open();
SqlDataAdapter adapter = new SqlDataAdapter("SELECT OrderID, CustomerID, OrderDate, Total FROM Orders", connection);
DataTable dt = new DataTable();
adapter.Fill(dt);
WorkBook workBook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet workSheet = workBook.CreateWorkSheet("Orders");
// Write and style header row
for (int col = 0; col < dt.Columns.Count; col++)
{
workSheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
workSheet[0, col].Style.Font.Bold = true;
workSheet[0, col].Style.Font.Height = 12;
}
// Write data rows with type-aware value assignment
for (int row = 0; row < dt.Rows.Count; row++)
{
for (int col = 0; col < dt.Columns.Count; col++)
{
object value = dt.Rows[row][col];
if (value is DateTime date)
workSheet.SetCellValue(row + 1, col, date.ToString("yyyy-MM-dd"));
else if (value is decimal || value is double || value is int)
workSheet.SetCellValue(row + 1, col, Convert.ToDouble(value));
else
workSheet.SetCellValue(row + 1, col, value.ToString());
}
}
workBook.SaveAs("FormattedOrdersExport.xlsx");Imports IronXL
Imports System.Data
Imports System.Data.SqlClient
Dim connectionString As String = "Data Source=localhost;Initial Catalog=Sales;Integrated Security=True"
Using connection As New SqlConnection(connectionString)
connection.Open()
Dim adapter As New SqlDataAdapter("SELECT OrderID, CustomerID, OrderDate, Total FROM Orders", connection)
Dim dt As New DataTable()
adapter.Fill(dt)
Dim workBook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim workSheet As WorkSheet = workBook.CreateWorkSheet("Orders")
' Write and style header row
For col As Integer = 0 To dt.Columns.Count - 1
workSheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
workSheet(0, col).Style.Font.Bold = True
workSheet(0, col).Style.Font.Height = 12
Next
' Write data rows with type-aware value assignment
For row As Integer = 0 To dt.Rows.Count - 1
For col As Integer = 0 To dt.Columns.Count - 1
Dim value As Object = dt.Rows(row)(col)
If TypeOf value Is DateTime Then
Dim dateValue As DateTime = CType(value, DateTime)
workSheet.SetCellValue(row + 1, col, dateValue.ToString("yyyy-MM-dd"))
ElseIf TypeOf value Is Decimal OrElse TypeOf value Is Double OrElse TypeOf value Is Integer Then
workSheet.SetCellValue(row + 1, col, Convert.ToDouble(value))
Else
workSheet.SetCellValue(row + 1, col, value.ToString())
End If
Next
Next
workBook.SaveAs("FormattedOrdersExport.xlsx")
End UsingAplicar negrita y un tamaño de fuente mayor a la fila de encabezado facilita la lectura de los informes exportados en Excel. En el caso de columnas numéricas, como totales o recuentos, pasar un valor double en lugar de una cadena permite que las funciones nativas de clasificación y agregación de Excel funcionen correctamente con los datos exportados.
Puede explorar toda la gama de opciones de formato —incluidos los bordes de celda, los colores de fondo y las máscaras de formato numérico— en la documentación sobre formato de celdas de IronXL.
En el caso de tablas con decenas de miles de filas, la gestión de la memoria cobra importancia. Cargar todo el conjunto de resultados en un DataTable antes de escribir en Excel funciona bien para la mayoría de los informes, pero para exportaciones muy grandes puedes procesar las filas por lotes o utilizar SqlDataReader directamente.
Al trabajar con exportaciones de gran volumen, tenga en cuenta las siguientes estrategias:
workBook.SaveAs(filePath) después de cada lote en lugar de mantenerlo todo en memoria con ToByteArray().SELECT en lugar de SELECT * para reducir la cantidad de datos transferidos desde SQL Server.Si necesitas orientación sobre la forma más rápida de exportar una DataTable a Excel en C#, el blog de IronXL cuenta con un artículo de referencia específico en el que se comparan diferentes enfoques y sus perfiles de memoria.
El método WorkBook.LoadWorkSheetsFromDataSet es especialmente eficaz para objetos DataSet de tamaño moderado, ya que gestiona la iteración de filas internamente. En el caso concreto de la exportación de DataTable a Excel, este método reduce el código repetitivo y está optimizado para escrituras masivas.
El flujo de trabajo de exportación es solo la mitad de la historia para muchas aplicaciones de generación de informes. Es posible que también sea necesario permitir a los usuarios descargar una plantilla, rellenarla con datos y volver a cargarla en SQL Server. IronXL simplifica este flujo de trabajo bidireccional.
Para importar datos de Excel a una base de datos, cargue el archivo subido con WorkBook.Load(filePath), recorra las filas de la hoja de cálculo e inserte cada fila utilizando un SqlCommand parametrizado:
using IronXL;
using System.Data.SqlClient;
WorkBook workBook = WorkBook.Load("UploadedData.xlsx");
WorkSheet sheet = workBook.DefaultWorkSheet;
string connectionString = "Data Source=localhost;Initial Catalog=Inventory;Integrated Security=True";
using SqlConnection connection = new SqlConnection(connectionString);
connection.Open();
// Skip header row, start at row index 1
for (int row = 1; row <= sheet.RowCount; row++)
{
string productName = sheet[row, 0].StringValue;
int quantity = (int)sheet[row, 1].DoubleValue;
decimal price = (decimal)sheet[row, 2].DoubleValue;
using SqlCommand cmd = new SqlCommand(
"INSERT INTO Products (Name, Quantity, Price) VALUES (@name, @qty, @price)",
connection);
cmd.Parameters.AddWithValue("@name", productName);
cmd.Parameters.AddWithValue("@qty", quantity);
cmd.Parameters.AddWithValue("@price", price);
cmd.ExecuteNonQuery();
}Imports IronXL
Imports System.Data.SqlClient
Dim workBook As WorkBook = WorkBook.Load("UploadedData.xlsx")
Dim sheet As WorkSheet = workBook.DefaultWorkSheet
Dim connectionString As String = "Data Source=localhost;Initial Catalog=Inventory;Integrated Security=True"
Using connection As New SqlConnection(connectionString)
connection.Open()
' Skip header row, start at row index 1
For row As Integer = 1 To sheet.RowCount
Dim productName As String = sheet(row, 0).StringValue
Dim quantity As Integer = CInt(sheet(row, 1).DoubleValue)
Dim price As Decimal = CDec(sheet(row, 2).DoubleValue)
Using cmd As New SqlCommand("INSERT INTO Products (Name, Quantity, Price) VALUES (@name, @qty, @price)", connection)
cmd.Parameters.AddWithValue("@name", productName)
cmd.Parameters.AddWithValue("@qty", quantity)
cmd.Parameters.AddWithValue("@price", price)
cmd.ExecuteNonQuery()
End Using
Next
End UsingLas consultas parametrizadas protegen contra la inyección SQL al leer datos de Excel proporcionados por el usuario. La documentación de SqlCommand en Microsoft Learn cubre todas las sobrecargas disponibles y los patrones de enlace de parámetros. Comprueba siempre los valores de las celdas antes de insertarlos: comprueba si hay cadenas vacías, números fuera de rango y tipos de datos inesperados que puedan provocar violaciones de restricciones en tu tabla de SQL Server.
En la dirección inversa, IronXL también admite la lectura de archivos CSV en C# para casos en los que la fuente de datos genera una salida separada por comas en lugar de archivos .xlsx.
Existen varios métodos para exportar datos SQL a Excel en .NET. La siguiente tabla resume las principales compensaciones:
| Acercarse | Se requiere oficina | Compatibilidad con DataSet | Formato | Seguro para servidor |
|---|---|---|---|---|
| IronXL | No | Sí (integrado) | Estilos completos, fórmulas | Sí |
| Microsoft Interop | Sí | Iteración manual | Completo a través de COM | No (servidor COM) |
| EPPlus | No | Iteración manual | Extenso | Sí |
| NPOI | No | Iteración manual | Bien | Sí |
| Salida en CSV | No | Manual | Ninguno | Sí |
Microsoft Interop requiere que Office esté instalado en el servidor y no es compatible con aplicaciones web del lado del servidor. IronXL, EPPlus y NPOI funcionan sin necesidad de Office. La ventaja de IronXL es su soporte de primera clase para DataSet y DataTable a través de LoadWorkSheetsFromDataSet, lo que reduce el código de exportación a unas pocas líneas en comparación con la iteración manual de filas en otras bibliotecas.
Para una comparación detallada, consulte el artículo sobre alternativas a Microsoft Office Interop.
Exportar datos SQL a Excel utilizando C# se convierte en algo sencillo con IronXL. La biblioteca elimina las complejas dependencias de Interop al tiempo que ofrece un sólido soporte para DataTable, DataSet y la integración directa con bases de datos. Ya sea para crear aplicaciones de consola o sistemas de generación de informes basados en web con capacidad de descarga de archivos, IronXL ofrece una generación fiable de archivos Excel en todos los tipos de proyectos de .NET 10.
Para seguir ampliando tus conocimientos sobre esta base, explora estos recursos relacionados:
LoadWorkSheetsFromDataSetAdquiera una licencia para la implementación en producción o siga explorando con una prueba gratuita para comprobar todas las capacidades de esta biblioteca de Excel en sus proyectos .NET.
Curtis Chau tiene una licenciatura en Ciencias de la Computación (Carleton University) y se especializa en el desarrollo front-end con experiencia en Node.js, TypeScript, JavaScript y React. Apasionado por crear interfaces de usuario intuitivas y estéticamente agradables, disfruta trabajando con frameworks modernos y creando manuales bien estructurados y visualmente atractivos.
IronXL es parte de IRONSUITE
10 productos API .NET para tus documentos de oficina
La API de Excel que necesita, sin la molestia de Office Interop.
