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.
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 .NET CLI, o utiliza la Consola del Administrador de Paquetes en Visual Studio con el comando Install-Package:
O en la Consola del Administrador de Paquetes de Visual Studio:
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;Imports IronXL
Imports System.DataIronXL 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.
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 asignan naturalmente 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 un DataTable de Empleados en memoria y lo 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");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")
SetCellValue acepta int, double, string y bool -- así obtienes tipos nativos de celdas de Excel sin necesidad de conversiones extra. El patrón de bucle funciona para tablas de cualquier tamaño porque IronXL escribe directamente en memoria y descarga al disco solo cuando se llama a SaveAs, manteniendo el proceso eficiente incluso para 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.
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 a continuación 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");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")
Cada hoja de cálculo lleva el nombre de la tabla de datos de origen, lo que facilita la navegación dentro de Excel. Debido a que WorkBook.Create asigna el libro de trabajo en memoria, puedes seguir agregando hojas de trabajo en el bucle sin reabrir 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.
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 celda y rango a través del objeto Style adjunto 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");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")La propiedad Style.Font.Bold se aplica a todo el rango del encabezado en una sola declaración. IronXL también admite colores de fondo (Style.BackgroundColor), estilos de borde (Style.Border), formatos de número (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.
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 llena un DataSet usando SqlDataAdapter, luego asigna el DataTable resultante a una hoja de trabajo 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.");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.")El operador de comprobación de valores nulos (cellValue == DBNull.Value ? "" : cellValue.ToString()) prevents exceptions when the database returns valores NULL` -- una ocurrencia común con 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 más patrones sobre cómo leer datos de vuelta desde Excel a objetos C#, el tutorial de exportación de DataTable de IronXL muestra cómo revertir este flujo de trabajo.
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.
| 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 | None | 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.
Al exportar DataTables con decenas de miles de filas, es importante que el uso de memoria sea predecible. El patrón a continuación transmite datos desde un IDataReader en lugar de cargar primero el conjunto de resultados completo en un DataTable. Esto evita el costo de memoria doble de mantener tanto el búfer del lector como el DataTable simultáneamente.
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 UsingSe 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.
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");Imports IronXL
' IronXL can save any workbook as CSV
workbook.SaveAs("LargeExport.csv")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.
IronXL admite guardar en la ruta del archivo, MemoryStream y byte[] -- lo cual es relevante para 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 actionImports 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 UsingPara ASP.NET Core, devuelve File(fileBytes, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "Report.xlsx") desde tu acción del controlador para activar una descarga de 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.
IronXL guarda en los siguientes formatos sin ninguna dependencia adicional:
Cambia formatos cambiando la extensión del archivo en la ruta SaveAs o utilizando el método sobrecargado que acepta un valor enum ExcelFileFormat.
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}");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}")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 después de 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.
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:
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.
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.
