Ícono de mensaje
Saltar al pie de página
  1. Iron Software
  2. Blog de IronXL
  3. Usando IronXL
  4. Exportación de conjuntos de datos a Excel
USANDO IRONXL

Exportar un conjunto de datos a Excel en C# con IronXL | Sin necesidad de Office

Jordi Bardia
Jordi Bardia
Actualizado:

Exportar un DataSet o una DataTable a Excel en C# te ofrece una forma fiable de convertir datos estructurados en memoria en archivos de hoja de cálculo profesionales, sin depender de que Microsoft Office esté instalado en el equipo de destino. Tanto si extraes registros de una base de datos SQL, como si creas un DataSet mediante programación o trabajas con un DataGrid existente, IronXL gestiona todo el proceso a través de una API limpia y centrada en el código. Esta guía recorre todos los escenarios principales —desde la exportación de una sola tabla hasta libros de trabajo de varias hojas y resultados de consultas a bases de datos en tiempo real— utilizando sentencias de C# de primer nivel y .NET 10.

Instala IronXL una vez, escribe unas pocas líneas de código y tus datos estarán en un archivo XLSX sin depender en absoluto de Office. Las secciones siguientes tratan sobre la instalación, los patrones básicos, el formato avanzado y la integración con bases de datos de una forma que te permita copiar y pegar directamente en tus propios proyectos.

¿Cómo se instala IronXL para la exportación a Excel?

Antes de escribir cualquier código de exportación, añade IronXL a tu proyecto a través del Gestor de paquetes NuGet. Abre un terminal en la raíz de tu proyecto y ejecuta el comando de la CLI de .NET, o utiliza la Consola del Administrador de paquetes en Visual Studio con el comando Install-Package:

dotnet add package IronXl.Excel
# Or in Visual Studio Package Manager Console:
# Install-Package IronXl.Excel
dotnet add package IronXl.Excel
# Or in Visual Studio Package Manager Console:
# Install-Package IronXl.Excel
SHELL

Tras la instalación, añada una instrucción "using" de nivel superior para importar el espacio de nombres IronXL:

using IronXL;
using System.Data;
using IronXL;
using System.Data;
Imports IronXL
Imports System.Data
$vbLabelText   $csharpLabel

IronXL está destinado a .NET 8, .NET 9 y .NET 10, así como a versiones anteriores de .NET Framework (4.6.2+). No es necesaria la instalación de Office en ningún equipo: servidor, ordenador de sobremesa o nube. Una vez instalado el paquete, podrá crear, leer y escribir archivos XLSX, XLS y CSV íntegramente en código gestionado.

Para conocer las opciones de instalación detalladas, consulte la guía de instalación de IronXL y la página del paquete NuGet para ver el historial de versiones.

¿Cómo se exporta una sola tabla de datos a un archivo de Excel?

El escenario más habitual es exportar una tabla de datos (DataTable) a una sola hoja de cálculo. Las clases WorkBook y WorkSheet de IronXL se mapean de forma natural al modelo de objetos de Excel. Se crea un libro, se añade una hoja de cálculo y, a continuación, se recorren las columnas y filas de la tabla de datos.

El siguiente ejemplo crea una tabla de datos de empleados en memoria y la escribe en EmployeeData.xlsx:

using IronXL;
using System.Data;

// Build an in-memory DataTable
DataTable dt = new DataTable("Employees");
dt.Columns.Add("ID", typeof(int));
dt.Columns.Add("Name", typeof(string));
dt.Columns.Add("Department", typeof(string));

dt.Rows.Add(1, "John Smith", "Engineering");
dt.Rows.Add(2, "Sarah Jones", "Marketing");
dt.Rows.Add(3, "Mike Wilson", "Sales");

// Create a workbook and a named worksheet
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("Employees");

// Write column headers in row 0
for (int col = 0; col < dt.Columns.Count; col++)
{
    worksheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
}

// Write data rows starting at row 1
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("EmployeeData.xlsx");
using IronXL;
using System.Data;

// Build an in-memory DataTable
DataTable dt = new DataTable("Employees");
dt.Columns.Add("ID", typeof(int));
dt.Columns.Add("Name", typeof(string));
dt.Columns.Add("Department", typeof(string));

dt.Rows.Add(1, "John Smith", "Engineering");
dt.Rows.Add(2, "Sarah Jones", "Marketing");
dt.Rows.Add(3, "Mike Wilson", "Sales");

// Create a workbook and a named worksheet
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("Employees");

// Write column headers in row 0
for (int col = 0; col < dt.Columns.Count; col++)
{
    worksheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
}

// Write data rows starting at row 1
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("EmployeeData.xlsx");
Imports IronXL
Imports System.Data

' Build an in-memory DataTable
Dim dt As New DataTable("Employees")
dt.Columns.Add("ID", GetType(Integer))
dt.Columns.Add("Name", GetType(String))
dt.Columns.Add("Department", GetType(String))

dt.Rows.Add(1, "John Smith", "Engineering")
dt.Rows.Add(2, "Sarah Jones", "Marketing")
dt.Rows.Add(3, "Mike Wilson", "Sales")

' Create a workbook and a named worksheet
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Employees")

' Write column headers in row 0
For col As Integer = 0 To dt.Columns.Count - 1
    worksheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
Next

' Write data rows starting at row 1
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("EmployeeData.xlsx")
$vbLabelText   $csharpLabel

Resultado

Cómo exportar un conjunto de datos a Excel en VB .NET: una guía completa con IronXL: Imagen 1 - Resultado de la exportación de una tabla de datos sencilla a Excel en VB.NET

SetCellValue admite int, double, string y bool, por lo que obtienes tipos de celda nativos de Excel sin necesidad de conversiones adicionales. El patrón de bucle funciona para tablas de cualquier tamaño porque IronXL escribe directamente en la memoria y solo vacía el contenido al disco cuando se llama a SaveAs, lo que mantiene la eficiencia del proceso incluso con miles de filas.

Para obtener una visión más amplia de las técnicas de lectura y escritura, el tutorial de IronXL C# cubre toda la gama de operaciones con archivos junto con este patrón de exportación.

¿Cómo se exporta un conjunto de datos a varias hojas de cálculo de Excel?

Cuando un DataSet contiene varias tablas relacionadas —como Productos y Pedidos—, puede asignar cada DataTable a su propia hoja de cálculo dentro de un mismo libro. Esto permite a los destinatarios ver todos los datos relacionados en un único archivo sin necesidad de abrir varios documentos.

El bucle siguiente itera ds.Tables y crea una hoja por tabla:

using IronXL;
using System.Data;

// Build a DataSet with two related tables
DataSet ds = new DataSet("CompanyData");

DataTable dtProducts = new DataTable("Products");
dtProducts.Columns.Add("ProductID", typeof(int));
dtProducts.Columns.Add("ProductName", typeof(string));
dtProducts.Columns.Add("Price", typeof(decimal));
dtProducts.Rows.Add(101, "Widget A", 29.99m);
dtProducts.Rows.Add(102, "Widget B", 49.99m);
ds.Tables.Add(dtProducts);

DataTable dtOrders = new DataTable("Orders");
dtOrders.Columns.Add("OrderID", typeof(int));
dtOrders.Columns.Add("Customer", typeof(string));
dtOrders.Columns.Add("Total", typeof(decimal));
dtOrders.Rows.Add(1001, "Acme Corp", 599.90m);
dtOrders.Rows.Add(1002, "Tech Inc", 299.95m);
ds.Tables.Add(dtOrders);

// Create one workbook and iterate each DataTable
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);

foreach (DataTable table in ds.Tables)
{
    WorkSheet sheet = workbook.CreateWorkSheet(table.TableName);

    // Write headers
    for (int col = 0; col < table.Columns.Count; col++)
    {
        sheet.SetCellValue(0, col, table.Columns[col].ColumnName);
    }

    // Write rows
    for (int row = 0; row < table.Rows.Count; row++)
    {
        for (int col = 0; col < table.Columns.Count; col++)
        {
            sheet.SetCellValue(row + 1, col, table.Rows[row][col].ToString());
        }
    }
}

workbook.SaveAs("CompanyReport.xlsx");
using IronXL;
using System.Data;

// Build a DataSet with two related tables
DataSet ds = new DataSet("CompanyData");

DataTable dtProducts = new DataTable("Products");
dtProducts.Columns.Add("ProductID", typeof(int));
dtProducts.Columns.Add("ProductName", typeof(string));
dtProducts.Columns.Add("Price", typeof(decimal));
dtProducts.Rows.Add(101, "Widget A", 29.99m);
dtProducts.Rows.Add(102, "Widget B", 49.99m);
ds.Tables.Add(dtProducts);

DataTable dtOrders = new DataTable("Orders");
dtOrders.Columns.Add("OrderID", typeof(int));
dtOrders.Columns.Add("Customer", typeof(string));
dtOrders.Columns.Add("Total", typeof(decimal));
dtOrders.Rows.Add(1001, "Acme Corp", 599.90m);
dtOrders.Rows.Add(1002, "Tech Inc", 299.95m);
ds.Tables.Add(dtOrders);

// Create one workbook and iterate each DataTable
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);

foreach (DataTable table in ds.Tables)
{
    WorkSheet sheet = workbook.CreateWorkSheet(table.TableName);

    // Write headers
    for (int col = 0; col < table.Columns.Count; col++)
    {
        sheet.SetCellValue(0, col, table.Columns[col].ColumnName);
    }

    // Write rows
    for (int row = 0; row < table.Rows.Count; row++)
    {
        for (int col = 0; col < table.Columns.Count; col++)
        {
            sheet.SetCellValue(row + 1, col, table.Rows[row][col].ToString());
        }
    }
}

workbook.SaveAs("CompanyReport.xlsx");
Imports IronXL
Imports System.Data

' Build a DataSet with two related tables
Dim ds As New DataSet("CompanyData")

Dim dtProducts As New DataTable("Products")
dtProducts.Columns.Add("ProductID", GetType(Integer))
dtProducts.Columns.Add("ProductName", GetType(String))
dtProducts.Columns.Add("Price", GetType(Decimal))
dtProducts.Rows.Add(101, "Widget A", 29.99D)
dtProducts.Rows.Add(102, "Widget B", 49.99D)
ds.Tables.Add(dtProducts)

Dim dtOrders As New DataTable("Orders")
dtOrders.Columns.Add("OrderID", GetType(Integer))
dtOrders.Columns.Add("Customer", GetType(String))
dtOrders.Columns.Add("Total", GetType(Decimal))
dtOrders.Rows.Add(1001, "Acme Corp", 599.90D)
dtOrders.Rows.Add(1002, "Tech Inc", 299.95D)
ds.Tables.Add(dtOrders)

' Create one workbook and iterate each DataTable
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)

For Each table As DataTable In ds.Tables
    Dim sheet As WorkSheet = workbook.CreateWorkSheet(table.TableName)

    ' Write headers
    For col As Integer = 0 To table.Columns.Count - 1
        sheet.SetCellValue(0, col, table.Columns(col).ColumnName)
    Next

    ' Write rows
    For row As Integer = 0 To table.Rows.Count - 1
        For col As Integer = 0 To table.Columns.Count - 1
            sheet.SetCellValue(row + 1, col, table.Rows(row)(col).ToString())
        Next
    Next
Next

workbook.SaveAs("CompanyReport.xlsx")
$vbLabelText   $csharpLabel

Resultado

Cómo exportar un conjunto de datos a Excel en VB .NET: una guía completa con IronXL: Imagen 2 - Archivo Excel generado con los conjuntos de datos exportados como hojas de cálculo independientes

Cada hoja de cálculo lleva el nombre de la tabla de datos de origen, lo que facilita la navegación dentro de Excel. Dado que WorkBook.Create aloca el libro en memoria, puedes seguir añadiendo hojas de cálculo en el bucle sin necesidad de volver a abrir el archivo; IronXL construye toda la estructura XLSX antes de escribir en el disco.

La documentación de IronXL WorkBook enumera todos los métodos disponibles en el objeto WorkBook, incluyendo la reordenación de hojas, la protección con contraseña y el guardado en formatos distintos de XLSX.

¿Cómo se añade formato de encabezado a las exportaciones de Excel?

Las exportaciones de datos sin formato son funcionales, pero añadir encabezados en negrita y anchos de columna hace que el resultado sea inmediatamente utilizable en un contexto empresarial. IronXL expone el estilo de celdas y rangos a través del objeto Style asociado a cualquier rango WorkSheet.

El fragmento de código siguiente aplica formato de negrita a la fila de encabezado y ajusta automáticamente el tamaño de las columnas tras escribir los datos:

using IronXL;
using System.Data;

DataTable dt = new DataTable("Sales");
dt.Columns.Add("Region", typeof(string));
dt.Columns.Add("Q1", typeof(decimal));
dt.Columns.Add("Q2", typeof(decimal));
dt.Columns.Add("Q3", typeof(decimal));
dt.Columns.Add("Q4", typeof(decimal));

dt.Rows.Add("North", 120000m, 135000m, 142000m, 158000m);
dt.Rows.Add("South", 98000m, 104000m, 112000m, 121000m);
dt.Rows.Add("East",  87000m, 93000m,  99000m,  108000m);
dt.Rows.Add("West",  145000m, 152000m, 161000m, 174000m);

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Sales");

// Write and style headers
for (int col = 0; col < dt.Columns.Count; col++)
{
    sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
    sheet["A1:E1"].Style.Font.Bold = true;
    sheet["A1:E1"].Style.Font.Height = 12;
}

// Write data rows
for (int row = 0; row < dt.Rows.Count; row++)
{
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        sheet.SetCellValue(row + 1, col, dt.Rows[row][col]);
    }
}

workbook.SaveAs("SalesReport.xlsx");
using IronXL;
using System.Data;

DataTable dt = new DataTable("Sales");
dt.Columns.Add("Region", typeof(string));
dt.Columns.Add("Q1", typeof(decimal));
dt.Columns.Add("Q2", typeof(decimal));
dt.Columns.Add("Q3", typeof(decimal));
dt.Columns.Add("Q4", typeof(decimal));

dt.Rows.Add("North", 120000m, 135000m, 142000m, 158000m);
dt.Rows.Add("South", 98000m, 104000m, 112000m, 121000m);
dt.Rows.Add("East",  87000m, 93000m,  99000m,  108000m);
dt.Rows.Add("West",  145000m, 152000m, 161000m, 174000m);

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Sales");

// Write and style headers
for (int col = 0; col < dt.Columns.Count; col++)
{
    sheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
    sheet["A1:E1"].Style.Font.Bold = true;
    sheet["A1:E1"].Style.Font.Height = 12;
}

// Write data rows
for (int row = 0; row < dt.Rows.Count; row++)
{
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        sheet.SetCellValue(row + 1, col, dt.Rows[row][col]);
    }
}

workbook.SaveAs("SalesReport.xlsx");
Imports IronXL
Imports System.Data

Dim dt As New DataTable("Sales")
dt.Columns.Add("Region", GetType(String))
dt.Columns.Add("Q1", GetType(Decimal))
dt.Columns.Add("Q2", GetType(Decimal))
dt.Columns.Add("Q3", GetType(Decimal))
dt.Columns.Add("Q4", GetType(Decimal))

dt.Rows.Add("North", 120000D, 135000D, 142000D, 158000D)
dt.Rows.Add("South", 98000D, 104000D, 112000D, 121000D)
dt.Rows.Add("East", 87000D, 93000D, 99000D, 108000D)
dt.Rows.Add("West", 145000D, 152000D, 161000D, 174000D)

Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim sheet As WorkSheet = workbook.CreateWorkSheet("Sales")

' Write and style headers
For col As Integer = 0 To dt.Columns.Count - 1
    sheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
    sheet("A1:E1").Style.Font.Bold = True
    sheet("A1:E1").Style.Font.Height = 12
Next

' Write data rows
For row As Integer = 0 To dt.Rows.Count - 1
    For col As Integer = 0 To dt.Columns.Count - 1
        sheet.SetCellValue(row + 1, col, dt.Rows(row)(col))
    Next
Next

workbook.SaveAs("SalesReport.xlsx")
$vbLabelText   $csharpLabel

La propiedad Style.Font.Bold se aplica a todo el rango de encabezados en una sola instrucción. IronXL también admite colores de fondo (Style.BackgroundColor), estilos de borde (Style.Border), formatos numéricos (Style.NumberFormat.FormatCode) y alineación horizontal (Style.HorizontalAlignment). Para consultar la referencia de estilo completa, véase la guía de formato de celdas de IronXL.

¿Cómo se exportan los resultados de una consulta de base de datos a Excel?

La conexión a una base de datos SQL y la exportación de los resultados directamente a Excel cubre un caso de uso real muy importante: informes programados, instantáneas de datos y exportaciones administrativas. El enfoque consiste en rellenar un DataSet utilizando SqlDataAdapter y, a continuación, asignar la DataTable resultante a una hoja de cálculo de IronXL.

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

string connectionString = "Server=localhost;Database=SalesDB;Integrated Security=True;";
string query = "SELECT CustomerID, CompanyName, ContactName, Country FROM Customers";

// Fill DataSet from SQL query
DataSet ds = new DataSet();
using (SqlConnection connection = new SqlConnection(connectionString))
{
    SqlDataAdapter adapter = new SqlDataAdapter(query, connection);
    adapter.Fill(ds, "Customers");
}

DataTable dt = ds.Tables["Customers"]!;

// Create workbook and export
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("CustomerData");

// Bold header row
for (int col = 0; col < dt.Columns.Count; col++)
{
    worksheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
}
worksheet["A1:D1"].Style.Font.Bold = true;

// Write rows, handling DBNull values safely
for (int row = 0; row < dt.Rows.Count; row++)
{
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        object cellValue = dt.Rows[row][col];
        worksheet.SetCellValue(row + 1, col,
            cellValue == DBNull.Value ? "" : cellValue.ToString()!);
    }
}

workbook.SaveAs("CustomerExport.xlsx");
Console.WriteLine("Export complete.");
using IronXL;
using System.Data;
using System.Data.SqlClient;

string connectionString = "Server=localhost;Database=SalesDB;Integrated Security=True;";
string query = "SELECT CustomerID, CompanyName, ContactName, Country FROM Customers";

// Fill DataSet from SQL query
DataSet ds = new DataSet();
using (SqlConnection connection = new SqlConnection(connectionString))
{
    SqlDataAdapter adapter = new SqlDataAdapter(query, connection);
    adapter.Fill(ds, "Customers");
}

DataTable dt = ds.Tables["Customers"]!;

// Create workbook and export
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("CustomerData");

// Bold header row
for (int col = 0; col < dt.Columns.Count; col++)
{
    worksheet.SetCellValue(0, col, dt.Columns[col].ColumnName);
}
worksheet["A1:D1"].Style.Font.Bold = true;

// Write rows, handling DBNull values safely
for (int row = 0; row < dt.Rows.Count; row++)
{
    for (int col = 0; col < dt.Columns.Count; col++)
    {
        object cellValue = dt.Rows[row][col];
        worksheet.SetCellValue(row + 1, col,
            cellValue == DBNull.Value ? "" : cellValue.ToString()!);
    }
}

workbook.SaveAs("CustomerExport.xlsx");
Console.WriteLine("Export complete.");
Imports IronXL
Imports System.Data
Imports System.Data.SqlClient

Dim connectionString As String = "Server=localhost;Database=SalesDB;Integrated Security=True;"
Dim query As String = "SELECT CustomerID, CompanyName, ContactName, Country FROM Customers"

' Fill DataSet from SQL query
Dim ds As New DataSet()
Using connection As New SqlConnection(connectionString)
    Dim adapter As New SqlDataAdapter(query, connection)
    adapter.Fill(ds, "Customers")
End Using

Dim dt As DataTable = ds.Tables("Customers")

' Create workbook and export
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("CustomerData")

' Bold header row
For col As Integer = 0 To dt.Columns.Count - 1
    worksheet.SetCellValue(0, col, dt.Columns(col).ColumnName)
Next
worksheet("A1:D1").Style.Font.Bold = True

' Write rows, handling DBNull values safely
For row As Integer = 0 To dt.Rows.Count - 1
    For col As Integer = 0 To dt.Columns.Count - 1
        Dim cellValue As Object = dt.Rows(row)(col)
        worksheet.SetCellValue(row + 1, col, If(cellValue Is DBNull.Value, "", cellValue.ToString()))
    Next
Next

workbook.SaveAs("CustomerExport.xlsx")
Console.WriteLine("Export complete.")
$vbLabelText   $csharpLabel

Puntos clave para las exportaciones de bases de datos

El operador de comprobación de valores nulos (cellValue == DBNull.Value ? "" : cellValue.ToString()) prevents exceptions when the database returns NULL valores -- algo habitual en las columnas opcionales. El formato en negrita de la fila de encabezado permite a los destinatarios del informe distinguir inmediatamente los encabezados de los datos.

Para conocer más patrones sobre cómo leer datos de Excel en objetos C#, el tutorial de exportación de IronXL DataTable muestra cómo invertir este flujo de trabajo.

¿Cómo se compara IronXL con otros métodos de exportación de Excel?

Antes de elegir una biblioteca, resulta útil comprender cómo se comparan las principales opciones entre sí en las áreas más relevantes para los escenarios de exportación de DataSet.

Comparación de bibliotecas de exportación a Excel para escenarios de .NET DataSet
Acercarse Se requiere oficina Compatibilidad con XLSX API de estilo Varias hojas Rendimiento (grandes volúmenes de datos)
IronXL No Sí Lleno Sí Alto
Interop de Microsoft Office Sí Sí Lleno Sí Bajo
EPPlus No Sí Parcial Sí Alto
ClosedXML No Sí Parcial Sí Medio
CSV (manual) No No Ninguno No Muy alta

Interop de Microsoft Office solo funciona en equipos Windows con Office instalado, lo que lo descarta para implementaciones en servidor y funciones en la nube. IronXL, EPPlus y ClosedXML admiten la generación del lado del servidor; el factor diferenciador clave es la amplitud de la API de estilo y el modelo de licencia. La licencia de IronXL incluye el uso comercial y cubre todos los marcos de trabajo .NET de destino desde un único paquete.

En cuanto a comparativas y pruebas de rendimiento de terceros, la documentación de Microsoft sobre formatos de archivo de Excel y la página del proyecto EPPlus proporcionan contexto adicional para tomar la decisión adecuada para su proyecto.

¿Cómo se gestionan grandes conjuntos de datos sin problemas de memoria?

Al exportar DataTables con decenas de miles de filas, es importante que el uso de memoria sea predecible. El patrón que se muestra a continuación transmite datos desde un IDataReader en lugar de cargar primero el conjunto de resultados completo en una DataTable. Esto evita el doble coste de memoria que supone mantener simultáneamente tanto el búfer del lector como la DataTable.

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

string connectionString = "Server=localhost;Database=InventoryDB;Integrated Security=True;";
string query = "SELECT ProductID, SKU, Description, StockLevel, UnitCost FROM Products";

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Inventory");

using SqlConnection conn = new SqlConnection(connectionString);
conn.Open();

using SqlCommand cmd = new SqlCommand(query, conn);
using SqlDataReader reader = cmd.ExecuteReader();

// Write schema-derived headers
for (int col = 0; col < reader.FieldCount; col++)
{
    sheet.SetCellValue(0, col, reader.GetName(col));
}

// Stream rows directly into IronXL without buffering a DataTable
int excelRow = 1;
while (reader.Read())
{
    for (int col = 0; col < reader.FieldCount; col++)
    {
        sheet.SetCellValue(excelRow, col,
            reader.IsDBNull(col) ? "" : reader.GetValue(col).ToString()!);
    }
    excelRow++;
}

workbook.SaveAs("InventoryExport.xlsx");
Console.WriteLine($"Exported {excelRow - 1} rows.");
using IronXL;
using System.Data;
using System.Data.SqlClient;

string connectionString = "Server=localhost;Database=InventoryDB;Integrated Security=True;";
string query = "SELECT ProductID, SKU, Description, StockLevel, UnitCost FROM Products";

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Inventory");

using SqlConnection conn = new SqlConnection(connectionString);
conn.Open();

using SqlCommand cmd = new SqlCommand(query, conn);
using SqlDataReader reader = cmd.ExecuteReader();

// Write schema-derived headers
for (int col = 0; col < reader.FieldCount; col++)
{
    sheet.SetCellValue(0, col, reader.GetName(col));
}

// Stream rows directly into IronXL without buffering a DataTable
int excelRow = 1;
while (reader.Read())
{
    for (int col = 0; col < reader.FieldCount; col++)
    {
        sheet.SetCellValue(excelRow, col,
            reader.IsDBNull(col) ? "" : reader.GetValue(col).ToString()!);
    }
    excelRow++;
}

workbook.SaveAs("InventoryExport.xlsx");
Console.WriteLine($"Exported {excelRow - 1} rows.");
Imports IronXL
Imports System.Data
Imports System.Data.SqlClient

Dim connectionString As String = "Server=localhost;Database=InventoryDB;Integrated Security=True;"
Dim query As String = "SELECT ProductID, SKU, Description, StockLevel, UnitCost FROM Products"

Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim sheet As WorkSheet = workbook.CreateWorkSheet("Inventory")

Using conn As New SqlConnection(connectionString)
    conn.Open()

    Using cmd As New SqlCommand(query, conn)
        Using reader As SqlDataReader = cmd.ExecuteReader()

            ' Write schema-derived headers
            For col As Integer = 0 To reader.FieldCount - 1
                sheet.SetCellValue(0, col, reader.GetName(col))
            Next

            ' Stream rows directly into IronXL without buffering a DataTable
            Dim excelRow As Integer = 1
            While reader.Read()
                For col As Integer = 0 To reader.FieldCount - 1
                    sheet.SetCellValue(excelRow, col, If(reader.IsDBNull(col), "", reader.GetValue(col).ToString()))
                Next
                excelRow += 1
            End While

            workbook.SaveAs("InventoryExport.xlsx")
            Console.WriteLine($"Exported {excelRow - 1} rows.")
        End Using
    End Using
End Using
$vbLabelText   $csharpLabel

Se recomienda este patrón cuando el conjunto de resultados puede superar las 50 000 filas o cuando se ejecuta dentro de un servicio con limitaciones de memoria. La documentación sobre el rendimiento de IronXL incluye opciones adicionales de ajuste de memoria y rendimiento para exportaciones de gran volumen.

Guardado por lotes en CSV para exportaciones de gran volumen

Para exportaciones que superen las 500 000 filas, en las que la memoria sea extremadamente limitada, considere dividir la salida en varios libros de trabajo o exportar al formato CSV en su lugar:

using IronXL;

// IronXL can save any workbook as CSV
workbook.SaveAs("LargeExport.csv");
using IronXL;

// IronXL can save any workbook as CSV
workbook.SaveAs("LargeExport.csv");
Imports IronXL

' IronXL can save any workbook as CSV
workbook.SaveAs("LargeExport.csv")
$vbLabelText   $csharpLabel

El formato CSV pierde el formato y la compatibilidad con hojas múltiples, pero sigue siendo válido para procesos ETL posteriores que consumen datos sin procesar delimitados.

¿Cómo se guardan archivos de Excel en diferentes formatos y ubicaciones?

IronXL admite el guardado en ruta de archivo, MemoryStream y byte[], lo cual es importante para las aplicaciones ASP.NET que devuelven Excel como respuesta de descarga.

using IronXL;
using System.IO;

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Report");
sheet.SetCellValue(0, 0, "Generated Report");

// Save to file path
workbook.SaveAs("Report.xlsx");

// Save as XLS (legacy format)
workbook.SaveAs("Report.xls");

// Save to MemoryStream for HTTP response
using MemoryStream ms = new MemoryStream();
workbook.SaveAs(ms);
byte[] fileBytes = ms.ToArray();
// fileBytes can be returned from an ASP.NET controller action
using IronXL;
using System.IO;

WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet sheet = workbook.CreateWorkSheet("Report");
sheet.SetCellValue(0, 0, "Generated Report");

// Save to file path
workbook.SaveAs("Report.xlsx");

// Save as XLS (legacy format)
workbook.SaveAs("Report.xls");

// Save to MemoryStream for HTTP response
using MemoryStream ms = new MemoryStream();
workbook.SaveAs(ms);
byte[] fileBytes = ms.ToArray();
// fileBytes can be returned from an ASP.NET controller action
Imports IronXL
Imports System.IO

Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim sheet As WorkSheet = workbook.CreateWorkSheet("Report")
sheet.SetCellValue(0, 0, "Generated Report")

' Save to file path
workbook.SaveAs("Report.xlsx")

' Save as XLS (legacy format)
workbook.SaveAs("Report.xls")

' Save to MemoryStream for HTTP response
Using ms As New MemoryStream()
    workbook.SaveAs(ms)
    Dim fileBytes As Byte() = ms.ToArray()
    ' fileBytes can be returned from an ASP.NET controller action
End Using
$vbLabelText   $csharpLabel

Para .NET Core, devuelve File(fileBytes, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "Report.xlsx") desde la acción de tu controlador para activar una descarga en el navegador. La guía de IronXL ASP.NET Excel muestra el patrón completo de integración del controlador.

En cuanto a bibliotecas alternativas de .NET para Excel, el Open XML SDK es la base de código abierto sobre la que se construyen muchas bibliotecas.

Formatos de salida compatibles

IronXL guarda en los siguientes formatos sin ninguna dependencia adicional:

  • XLSX -- Formato OpenXML, compatible con Excel 2007 y versiones posteriores
  • XLS -- Formato binario heredado, compatible con Excel 97-2003
  • CSV: valores separados por comas, compatible universalmente
  • TSV -- Valores separados por tabulaciones
  • JSON -- Exportación de datos estructurados

Cambie de formato modificando la extensión del archivo en la ruta SaveAs o utilizando el método sobrecargado que acepta un valor de enumeración ExcelFileFormat.

¿Cómo se verifica que el archivo Excel exportado es correcto?

Tras la exportación, puede volver a leer el archivo con IronXL para verificar el recuento de filas, comprobar valores aleatoriamente o ejecutar verificaciones automatizadas en un proyecto de prueba:

using IronXL;

WorkBook loaded = WorkBook.Load("EmployeeData.xlsx");
WorkSheet sheet = loaded.WorkSheets[0];

// Verify row count (header row + data rows)
int totalRows = sheet.Rows.Count();
Console.WriteLine($"Rows in file: {totalRows}");

// Spot-check specific cell values
string header = sheet["A1"].StringValue;
string firstEmployee = sheet["A2"].StringValue;

Console.WriteLine($"Header: {header}, First row: {firstEmployee}");
using IronXL;

WorkBook loaded = WorkBook.Load("EmployeeData.xlsx");
WorkSheet sheet = loaded.WorkSheets[0];

// Verify row count (header row + data rows)
int totalRows = sheet.Rows.Count();
Console.WriteLine($"Rows in file: {totalRows}");

// Spot-check specific cell values
string header = sheet["A1"].StringValue;
string firstEmployee = sheet["A2"].StringValue;

Console.WriteLine($"Header: {header}, First row: {firstEmployee}");
Imports IronXL

Dim loaded As WorkBook = WorkBook.Load("EmployeeData.xlsx")
Dim sheet As WorkSheet = loaded.WorkSheets(0)

' Verify row count (header row + data rows)
Dim totalRows As Integer = sheet.Rows.Count()
Console.WriteLine($"Rows in file: {totalRows}")

' Spot-check specific cell values
Dim header As String = sheet("A1").StringValue
Dim firstEmployee As String = sheet("A2").StringValue

Console.WriteLine($"Header: {header}, First row: {firstEmployee}")
$vbLabelText   $csharpLabel

Este patrón de verificación resulta especialmente útil en suites de pruebas de integración en las que es necesario confirmar la corrección de la exportación antes de enviar archivos a sistemas externos. El tutorial de lectura de IronXL muestra toda la gama de operaciones de lectura disponibles tras cargar un archivo.

Para más información sobre los patrones DataSet y DataTable en .NET, la documentación de Microsoft DataSet trata en profundidad el modelo de objetos ADO.NET.

¿Cuales son tus próximos pasos?

Ahora dispone de patrones de trabajo para todos los principales escenarios de exportación de DataSet a Excel en C#: desde una sola DataTable hasta libros de trabajo con varias hojas, exportaciones basadas en bases de datos, encabezados formateados y streaming de grandes volúmenes de datos. A continuación te indicamos cómo dar el siguiente paso en función de tu objetivo:

  • Prueba IronXL gratis: empieza con una Licencia de prueba gratuita y ejecuta los ejemplos anteriores con tus propios datos antes de dar el paso a la producción.
  • Lea la referencia completa de la API: la referencia de objetos de IronXL cubre todos los métodos de WorkBook, WorkSheet y rangos de celdas.
  • Explora tutoriales de exportación relacionados: la guía "De DataTable de C# a Excel" cubre el flujo de trabajo inverso, es decir, volver a leer Excel en objetos DataTable.
  • Revisar las opciones de formato: la documentación sobre el formato de celdas de IronXL muestra formatos numéricos, bordes, colores de fondo y opciones de alineación.
  • Comprueba las licencias: para implementaciones en producción, consulta la página de licencias de IronXL para elegir entre las opciones Developer, Organization y Libre de regalías.
  • Compárelo con otras herramientas de Iron Software: si su proyecto también requiere la generación de PDF o OCR, la suite de productos de Iron Software le permite combinar varias bibliotecas a un precio reducido.

Partiendo de los patrones aquí descritos, puedes incorporar la automatización de tareas programadas, los puntos finales de descarga de .NET Core y los flujos de salida multiformato íntegramente en C# gestionado: sin Office, sin COM y sin dependencias de tiempo de ejecución más allá del paquete NuGet.

Preguntas Frecuentes

¿Cómo puedo exportar un conjunto de datos a Excel en C#?

Puede exportar un conjunto de datos a Excel en C# utilizando la biblioteca IronXL , que proporciona una API de código primero para crear, editar y manipular archivos de Excel sin necesidad de Microsoft Office.

¿Necesito tener instalado Microsoft Office para usar IronXL?

No, IronXL no requiere que Microsoft Office esté instalado en la máquina para exportar o manipular archivos de Excel.

¿Qué tipos de datos puedo exportar usando IronXL?

IronXL le permite exportar datos estructurados como DataTables y DataSets a archivos Excel, así como datos de SqlDataReader y otras fuentes ADO .NET .

¿Puede IronXL gestionar la creación y edición de archivos Excel?

Sí, IronXL proporciona funcionalidad para crear, editar y manipular archivos de Excel mediante programación en C#.

¿ IronXL es adecuado para aplicaciones del lado del servidor y de la nube?

Sí, IronXL es ideal para aplicaciones del lado del servidor y funciones en la nube que necesitan generar archivos Excel sin ninguna instalación de Office.

¿Cuáles son los beneficios de utilizar IronXL para exportar conjuntos de datos?

IronXL maneja la creación y manipulación de archivos Excel sin dependencias externas como Microsoft Office, admite los formatos XLSX, XLS y CSV, y funciona en todos los marcos de destino .NET .

¿Se puede utilizar IronXL en ASP.NET Core para devolver una descarga de Excel?

Sí, IronXL puede guardar libros de trabajo en un MemoryStream y la matriz de bytes resultante se puede devolver desde una acción del controlador ASP.NET Core como una descarga de archivo.

¿ IronXL admite conjuntos de datos grandes?

Sí, IronXL puede transmitir datos directamente desde SqlDataReader sin almacenar en búfer un DataTable completo, lo que mantiene el uso de memoria predecible para conjuntos de resultados grandes.

¿Qué formatos de Excel admite IronXL para guardar?

IronXL admite guardar en formatos XLSX, XLS, CSV, TSV y JSON sin dependencias adicionales.

¿Puedo aplicar formato como encabezados en negrita al exportar a Excel?

Sí, IronXL proporciona una API de estilo en rangos de celdas para fuentes en negrita, colores de fondo, bordes, formatos de números y alineación.

Jordi Bardia
Jordi Bardia
  Chatea con el equipo de ingeniería ahora
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

Artículos Relacionados
Prueba de 30 días → Producto completo. Sin límites. Sin tarjeta. Prueba gratis

Equipo de soporte de Iron

Estamos disponibles online las 24 horas, 5 días a la semana.
Chat
Email
Llámame