Exportar datos SQL a Excel en C# con IronXL

¿Cómo se instala IronXL para la exportación de datos SQL?

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:

Install-Package IronXl.Excel

Install-Package IronXl.Excel

Alternativamente, utilice la CLI de .NET :

dotnet add package IronXl.Excel

dotnet add package IronXl.Excel

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;

using IronXL;
using System.Data;
using System.Data.SqlClient;

Imports IronXL
Imports System.Data
Imports System.Data.SqlClient

IronXL 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.

¿Cuál es la mejor forma de exportar datos de una base de datos SQL Server?

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:

1. Abre un SqlConnection con tu cadena de conexión
2. Utilice SqlDataAdapter para rellenar un DataTable o DataSet
3. Llama a los métodos de IronXL para crear un libro y rellenar las celdas de la hoja de cálculo
4. Guarde el libro como .xlsx o .xls

Este 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.

¿Cómo conectarse a SQL Server y recuperar datos?

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

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

¿Cómo se utiliza LoadWorkSheetsFromDataSet para exportar varias tablas?

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

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

¿Cómo exportar datos con un botón de exportación ASP.NET?

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

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

¿Cómo se añade formato y encabezados de columna a los archivos Excel exportados?

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

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 Using

Aplicar 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.

¿Cómo se gestionan de forma eficiente grandes conjuntos de datos SQL?

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:

• Paginación con SQL OFFSET/FETCH: Divida las exportaciones de gran tamaño en varias hojas de cálculo, cada una con una página de resultados. Esto permite que el tamaño de las hojas individuales sea manejable en Excel.
• Transfiere a disco: Llama a workBook.SaveAs(filePath) después de cada lote en lugar de mantenerlo todo en memoria con ToByteArray().
• Limitar las columnas seleccionadas: Utilice listas de columnas explícitas en su instrucción 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.

¿Cómo se importan datos de Excel a SQL Server?

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

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 Using

Las 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.

¿Cómo se compara IronXL con otros enfoques de exportación?

Existen varios métodos para exportar datos SQL a Excel en .NET. La siguiente tabla resume las principales compensaciones:

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.

¿Cuales son tus próximos pasos?

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:

• Crear un archivo Excel en C#: tutorial completo sobre la creación y el formato de libros de trabajo
• Exportar DataSet y DataTable a Excel: guía oficial de instrucciones para el método LoadWorkSheetsFromDataSet
• Importar datos de Excel a SQL: flujo de trabajo completo de ida y vuelta
• Exportación de DataTable a Excel: guía específica para escenarios de una sola tabla
• ASP.NET Exportar DataTable a Excel -- patrones de exportación de aplicaciones web
• La forma más rápida de exportar DataTable a Excel: pruebas de rendimiento

Adquiera 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.