Í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 DataTable a Excel en C# le ofrece una forma fiable de convertir datos estructurados en memoria en archivos de hoja de cálculo profesionales, sin necesidad de tener instalado Microsoft Office en el equipo de destino. Tanto si extrae registros de una base de datos SQL, crea un DataSet mediante programación como si trabaja con un DataGrid existente, IronXL gestiona todo el proceso mediante una API limpia y centrada en el código. Esta guía recorre cada escenario principal, desde una exportación de una sola tabla hasta libros de trabajo de varias hojas y resultados de consultas de bases de datos en vivo, utilizando declaraciones de C# de nivel superior y .NET 10.

Instale IronXL una vez, escriba unas pocas líneas de código y sus datos estarán en un archivo XLSX sin una sola dependencia de Office. Las secciones a continuación cubren la instalación, patrones básicos, formato avanzado e integración de bases de datos de forma que pueda copiar y pegar directamente en sus propios proyectos.

¿Cómo instalar IronXL para exportar a Excel?

Antes de escribir cualquier código de exportación, agregue IronXL a su proyecto a través del Administrador de paquetes NuGet . Abra una terminal en la raíz de su proyecto y ejecute el comando CLI de .NET , o use 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

Después de la instalación, agregue una declaración using de nivel superior para importar el espacio de nombres IronXL :

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

IronXL está dirigido a .NET 8, .NET 9 y .NET 10, así como a versiones anteriores de .NET Framework (4.6.2+). No se requiere instalación de Office en ninguna máquina: servidor, computadora de escritorio o nube. Una vez instalado el paquete, puede crear, leer y escribir archivos XLSX, XLS y CSV completamente en código administrado.

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 exportar una sola tabla de datos a un archivo de Excel?

El escenario más común es exportar una DataTable a una sola hoja de cálculo. Las clases WorkBook y WorkSheet de IronXL se asignan naturalmente al modelo de objetos de Excel. Crea un libro de trabajo, agrega una hoja de trabajo y luego itera las columnas y filas de DataTable.

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");
$vbLabelText   $csharpLabel

Resultado

Cómo exportar un conjunto de datos a Excel VB .NET: una guía completa con IronXL: Imagen 1 - Salida para exportar una DataTable simple a Excel en VB .NET

SetCellValue acepta int, double, string y bool, por lo que obtiene tipos de celdas nativos de Excel sin conversión adicional. El patrón de bucle funciona para tablas de cualquier tamaño porque IronXL escribe directamente en la memoria y vacía el disco solo cuando se llama a SaveAs, lo que mantiene el proceso eficiente incluso para miles de filas.

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

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

Cuando un conjunto de datos contiene varias tablas relacionadas (como productos y pedidos), puede asignar cada tabla de datos a su propia hoja de cálculo dentro de un libro de trabajo. Esto permite a los destinatarios ver todos los datos relacionados en un solo archivo sin necesidad de abrir varios documentos.

El siguiente bucle 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");
$vbLabelText   $csharpLabel

Resultado

Cómo exportar un conjunto de datos a Excel VB .NET: una guía completa con IronXL: Imagen 2: archivo Excel generado con los conjuntos de datos exportados como hojas de trabajo separadas

Cada hoja de cálculo recibe el nombre de la DataTable de origen, lo que hace que la navegación dentro de Excel sea sencilla. Debido a que WorkBook.Create asigna el libro de trabajo en la memoria, puede seguir agregando hojas de trabajo en el bucle sin volver a abrir el archivo: IronXL crea 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, incluidos la reordenación de hojas, la protección con contraseña y el guardado en formatos distintos de XLSX.

¿Cómo agregar formato de encabezado a las exportaciones de Excel?

Las exportaciones de datos simples son funcionales, pero agregar encabezados en negrita y anchos de columna hace que el resultado se pueda utilizar inmediatamente en un contexto comercial. IronXL expone el estilo de celdas y rangos a través del objeto Style adjunto a cualquier rango WorkSheet.

El siguiente fragmento aplica formato de fuente en negrita a la fila del encabezado y ajusta automáticamente el tamaño de las columnas después de 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");
$vbLabelText   $csharpLabel

La propiedad Style.Font.Bold se aplica a todo el rango de encabezado en una sola declaración. IronXL también admite colores de fondo (Style.BackgroundColor), estilos de borde (Style.Border), formatos de números (Style.NumberFormat.FormatCode) y alineación horizontal (Style.HorizontalAlignment). Para obtener una referencia de estilo completa, consulte la guía de formato de celda de IronXL .

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

Conectarse a una base de datos SQL y exportar los resultados directamente a Excel cubre un importante caso de uso del mundo real: informes programados, instantáneas de datos y exportaciones administrativas. El enfoque llena un DataSet usando SqlDataAdapter y luego asigna la DataTable resultante a una hoja de cálculo 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.");
$vbLabelText   $csharpLabel

Puntos clave para las exportaciones de bases de datos

La protección nula (cellValue == DBNull.Value ? "": cellValue.ToString()) prevents exceptions when the database returns NULL valores: una ocurrencia común con columnas opcionales. El formato en negrita en la fila del encabezado permite a los destinatarios del informe distinguir inmediatamente los encabezados de los datos.

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

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

Antes de elegir una biblioteca, es útil comprender cómo se comparan las opciones principales entre sí en las áreas que más importan para los escenarios de exportación de conjuntos de datos.

Comparación de bibliotecas de exportación de Excel para escenarios de conjuntos de datos .NET
Acercarse Se requiere oficina Compatibilidad con XLSX API de estilo Multi-Hoja Rendimiento (datos de gran tamaño)
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 alto

Interop de Microsoft Office solo funciona en máquinas Windows con Office instalado, lo que lo descarta para implementaciones de servidores y funciones en la nube. IronXL, EPPlus y ClosedXML admiten la generación del lado del servidor: el 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 destino .NET desde un solo paquete.

Para realizar comparaciones y evaluaciones comparativas de terceros, la documentación de Microsoft sobre formatos de archivos Excel y la página del proyecto EPPlus brindan contexto adicional para tomar la decisión correcta para su proyecto.

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

Al exportar tablas de datos con decenas de miles de filas, es importante mantener predecible el uso de la memoria. El siguiente patrón transmite datos desde un IDataReader en lugar de cargar primero el conjunto completo de resultados en una DataTable. Esto evita el doble consumo de memoria que supone mantener simultáneamente el búfer del lector y 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.");
$vbLabelText   $csharpLabel

Este patrón se recomienda 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 de rendimiento de IronXL incluye opciones adicionales de ajuste de memoria y rendimiento para exportaciones de gran volumen.

Guardado por lotes en CSV para exportaciones muy grandes

Para las exportaciones que superan las 500 000 filas donde la memoria es extremadamente limitada, considere dividir la salida en varios libros de trabajo o exportar a 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");
$vbLabelText   $csharpLabel

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

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

IronXL admite guardar en la 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
$vbLabelText   $csharpLabel

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

Para las bibliotecas alternativas de .NET Excel, el SDK Open XML es la base de código abierto sobre la que se construyen muchas bibliotecas.

Formatos de salida admitidos

IronXL guarda en los siguientes formatos sin dependencias adicionales:

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

Cambie los formatos 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 verificar que el archivo Excel exportado sea correcto?

Después de la exportación, puede volver a leer el archivo con IronXL para verificar los recuentos de filas, verificar valores puntualmente o ejecutar afirmaciones 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}");
$vbLabelText   $csharpLabel

Este patrón de verificación es particularmente útil en conjuntos de pruebas de integración donde se debe confirmar la corrección de la exportación antes de enviar archivos a sistemas externos. El tutorial de lectura de IronXL muestra la gama completa de operaciones de lectura disponibles después de cargar un archivo.

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

¿Cuales son tus próximos pasos?

Ahora tiene patrones de trabajo para cada escenario principal de exportación de DataSet a Excel en C#, desde una sola DataTable hasta libros de trabajo de varias hojas, exportaciones controladas por bases de datos, encabezados formateados y transmisión de datos de gran tamaño. A continuación te indicamos cómo dar el siguiente paso en función de tu objetivo:

  • Pruebe IronXL gratis : comience con una licencia de prueba gratuita y ejecute los ejemplos anteriores con sus propios datos antes de comprometerse con la producción.
  • Lea la referencia de API completa : la referencia del objeto IronXL cubre todos los métodos en WorkBook, WorkSheet y rangos de celdas.
  • Explore tutoriales de exportación relacionados : la guía de C# DataTable a Excel cubre el flujo de trabajo inverso (volver a leer Excel en objetos DataTable).
  • Revisar las opciones de formato : la documentación de formato de celda de IronXL muestra formatos de números, bordes, colores de fondo y opciones de alineación.
  • Verificar la licencia : para implementaciones de producción, consulte la página de licencias de IronXL para elegir entre las opciones de Desarrollador, Organización y Libre de regalías.
  • Compárese con otras herramientas de Iron Software : si su proyecto también necesita generación de PDF u OCR, el paquete de productos de Iron Software le permite agrupar varias bibliotecas a un precio reducido.

Basándose en los patrones tratados aquí, puede incorporar automatización de tareas programadas, puntos finales de descarga de ASP.NET Core y canales de salida multiformato completamente en C# administrado, sin Office, sin COM, 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

Iron Support Team

We're online 24 hours, 5 days a week.
Chat
Email
Call Me