Exportar una DataTable a un archivo de Excel en C# —sin depender de Office— es sencillo con la biblioteca adecuada. Llamas a WorkBook.Create(), escribes encabezados desde dataTable.Columns, recorres dataTable.Rows para llenar las celdas, luego guardas con workbook.SaveAs("output.xlsx"). El resultado es un archivo XLSX totalmente formateado que funciona en cualquier plataforma, incluyendo .NET 10, contenedores Linux y funciones sin servidor de Azure.
Esta guía compara el enfoque tradicional de OleDb con el método moderno de IronXL for .NET. Verás por qué el controlador OleDb crea problemas de implementación y compatibilidad, y cómo sustituirlo por código limpio y fácil de mantener que gestione encabezados de columna, tipos de datos, formato de celdas y grandes conjuntos de datos sin necesidad de sintaxis SQL ni instalaciones de controladores exclusivos de Windows.
Antes de escribir cualquier código de exportación, añade IronXL a tu proyecto. Abra la consola del gestor de paquetes en Visual Studio y ejecute:
IronXL no depende de Microsoft Office, del motor de base de datos de Access ni de ninguna capa de interoperabilidad COM. Una vez instalado el paquete, puedes ejecutar el mismo código en Windows, Linux, macOS, Docker, Azure y AWS sin cambiar ni una sola línea.
El enfoque tradicional de OleDb trata un archivo de Excel como una base de datos. Estableces un OleDbConnection usando el proveedor Microsoft.ACE.OLEDB.12.0 (o el más antiguo Microsoft.Jet.OLEDB.4.0 para archivos .xls), luego ejecutas comandos SQL CREATE TABLE y INSERT INTO contra la hoja de cálculo. Esto funciona en equipos de desarrolladores en los que ya esté instalado Microsoft Office o el motor de base de datos Access independiente redistribuible. Sin embargo, los entornos de producción —especialmente las funciones en la nube, los contenedores Docker y las granjas de servidores que ejecutan .NET 10 sin interfaz gráfica— rara vez disponen de ese controlador, y su instalación requiere privilegios elevados y una coincidencia de bits entre el controlador y el proceso.
OleDb se convirtió en la opción predeterminada para la automatización de Excel porque ya formaba parte del .NET Framework. Los desarrolladores ya conocían ADO.NET, por lo que reutilizar OleDbConnection, OleDbCommand y OleDbDataAdapter para escribir en Excel se sentía natural. No se necesitaba ningún paquete de terceros, y la sintaxis similar a SQL para CREATE TABLE y INSERT INTO hacía que la intención fuera obvia para cualquiera familiarizado con la programación de bases de datos.
Este es el patrón tradicional para exportar una DataTable utilizando OleDb:
using System.Data;
using System.Data.OleDb;
// Build a sample DataTable
DataTable dataTable = new DataTable("Products");
dataTable.Columns.Add("ProductID", typeof(int));
dataTable.Columns.Add("ProductName", typeof(string));
dataTable.Columns.Add("Price", typeof(decimal));
dataTable.Rows.Add(1, "Widget", 29.99m);
dataTable.Rows.Add(2, "Gadget", 49.99m);
dataTable.Rows.Add(3, "Gizmo", 19.99m);
// OleDb connection string -- file must already exist on disk
string filename = @"C:\Output\Products.xlsx";
string connectionString =
$"Provider=Microsoft.ACE.OLEDB.12.0;Data Source={filename};" +
"Extended Properties='Excel 12.0 Xml;HDR=YES'";
using OleDbConnection connection = new(connectionString);
connection.Open();
// Create the sheet structure with SQL DDL
string create = "CREATE TABLE [Sheet1$] (ProductID INT, ProductName CHAR(255), Price DOUBLE)";
using (var createCmd = new OleDbCommand(create, connection))
createCmd.ExecuteNonQuery();
// Insert rows one at a time
string insert = "INSERT INTO [Sheet1$] (ProductID, ProductName, Price) VALUES (?, ?, ?)";
using OleDbCommand insertCmd = new(insert, connection);
insertCmd.Parameters.Add(new OleDbParameter("ProductID", OleDbType.Integer));
insertCmd.Parameters.Add(new OleDbParameter("ProductName", OleDbType.VarChar, 255));
insertCmd.Parameters.Add(new OleDbParameter("Price", OleDbType.Double));
foreach (DataRow row in dataTable.Rows)
{
insertCmd.Parameters[0].Value = row["ProductID"];
insertCmd.Parameters[1].Value = row["ProductName"];
insertCmd.Parameters[2].Value = row["Price"];
insertCmd.ExecuteNonQuery();
}Imports System.Data
Imports System.Data.OleDb
' Build a sample DataTable
Dim dataTable As New DataTable("Products")
dataTable.Columns.Add("ProductID", GetType(Integer))
dataTable.Columns.Add("ProductName", GetType(String))
dataTable.Columns.Add("Price", GetType(Decimal))
dataTable.Rows.Add(1, "Widget", 29.99D)
dataTable.Rows.Add(2, "Gadget", 49.99D)
dataTable.Rows.Add(3, "Gizmo", 19.99D)
' OleDb connection string -- file must already exist on disk
Dim filename As String = "C:\Output\Products.xlsx"
Dim connectionString As String = $"Provider=Microsoft.ACE.OLEDB.12.0;Data Source={filename};" &
"Extended Properties='Excel 12.0 Xml;HDR=YES'"
Using connection As New OleDbConnection(connectionString)
connection.Open()
' Create the sheet structure with SQL DDL
Dim create As String = "CREATE TABLE [Sheet1$] (ProductID INT, ProductName CHAR(255), Price DOUBLE)"
Using createCmd As New OleDbCommand(create, connection)
createCmd.ExecuteNonQuery()
End Using
' Insert rows one at a time
Dim insert As String = "INSERT INTO [Sheet1$] (ProductID, ProductName, Price) VALUES (?, ?, ?)"
Using insertCmd As New OleDbCommand(insert, connection)
insertCmd.Parameters.Add(New OleDbParameter("ProductID", OleDbType.Integer))
insertCmd.Parameters.Add(New OleDbParameter("ProductName", OleDbType.VarChar, 255))
insertCmd.Parameters.Add(New OleDbParameter("Price", OleDbType.Double))
For Each row As DataRow In dataTable.Rows
insertCmd.Parameters(0).Value = row("ProductID")
insertCmd.Parameters(1).Value = row("ProductName")
insertCmd.Parameters(2).Value = row("Price")
insertCmd.ExecuteNonQuery()
Next
End Using
End UsingEste código inserta cada DataRow como una ida y vuelta independiente a la base de datos. En el caso de conjuntos de datos de gran tamaño, ese bucle se convierte en un cuello de botella, ya que no existe ningún mecanismo de inserción por lotes disponible a través de OleDb. Cada fila desencadena un ciclo completo de análisis SQL, enlace de parámetros y escritura antes de pasar a la siguiente.
Entender por qué OleDb se queda corto te ayuda a justificar la migración ante tu equipo y a elegir el sustituto adecuado.
El proveedor Microsoft.ACE.OLEDB.12.0 debe instalarse por separado en cada máquina que ejecute tu aplicación. Si su proceso es de 64 bits pero solo está disponible el motor de base de datos de Access de 32 bits —una configuración habitual cuando se instala Microsoft Office de 32 bits junto con un tiempo de ejecución de .NET de 64 bits—, la conexión genera una excepción en tiempo de ejecución. Microsoft documenta estas limitaciones de bits y recomienda utilizar una coincidencia de bits entre el controlador y el proceso de llamada, pero esto suele ser poco práctico en entornos de alojamiento compartido o en contenedores.
OleDb es una tecnología exclusiva de Windows. .NET 10 es compatible de forma nativa con Linux y macOS, y las arquitecturas modernas ejecutan cada vez más cargas de trabajo de aplicaciones en contenedores Docker en nodos Linux. Debido a que el espacio de nombres System.Data.OleDb lanza un PlatformNotSupportedException en sistemas operativos no Windows, cualquier camino de código que use OleDb está bloqueado para ejecutarse en estas plataformas por completo.
OleDb trata la hoja de cálculo como una tabla de base de datos plana. Puedes insertar valores sin formato, pero no dispones de ningún mecanismo para aplicar fuentes a las celdas, colores de fondo, bordes, formatos numéricos o anchos de columna. Si su exportación requiere un informe de aspecto profesional con estilo de fila de encabezado, formato de moneda o coloración condicional, OleDb no puede proporcionarlo. Necesitarías una segunda pasada con una biblioteca diferente o con el objeto COM de Excel Interop, lo que añade su propia dependencia de Office.
OleDb no puede crear un nuevo libro de Excel desde cero. El archivo debe existir ya en la ruta de destino antes de abrir la conexión. Esto requiere un archivo de plantilla preconfigurado o un paso adicional para crear el libro de trabajo utilizando otra biblioteca, lo que añade una complejidad innecesaria al paquete de implementación.
El controlador OleDb para Excel admite INSERT y operaciones UPDATE limitadas, pero la eliminación de filas usando DELETE FROM no es compatible. Cualquier flujo de trabajo de manipulación de datos que requiera eliminar filas tras la exportación debe recurrir a la manipulación manual de archivos o a la recreación completa del archivo, ninguna de las cuales es sencilla a través de la interfaz OleDb.
IronXL sustituye todo el proceso de OleDb por un modelo de objetos directo. No hay cadenas de conexión, ni comandos SQL, ni requisitos de controladores. Creas un WorkBook, agregas un WorkSheet, y llamas a SetCellValue() para cada celda:
using IronXL;
using System.Data;
// Build the same DataTable
DataTable dataTable = new DataTable("Products");
dataTable.Columns.Add("ProductID", typeof(int));
dataTable.Columns.Add("ProductName", typeof(string));
dataTable.Columns.Add("Price", typeof(decimal));
dataTable.Rows.Add(1, "Widget", 29.99m);
dataTable.Rows.Add(2, "Gadget", 49.99m);
dataTable.Rows.Add(3, "Gizmo", 19.99m);
// Create a new workbook and worksheet -- no template file needed
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("Products");
// Write column headers into the first row
for (int col = 0; col < dataTable.Columns.Count; col++)
{
worksheet.SetCellValue(0, col, dataTable.Columns[col].ColumnName);
}
// Write data rows
for (int row = 0; row < dataTable.Rows.Count; row++)
{
for (int col = 0; col < dataTable.Columns.Count; col++)
{
worksheet.SetCellValue(row + 1, col, dataTable.Rows[row][col].ToString());
}
}
workbook.SaveAs("Products.xlsx");Imports IronXL
Imports System.Data
' Build the same DataTable
Dim dataTable As New DataTable("Products")
dataTable.Columns.Add("ProductID", GetType(Integer))
dataTable.Columns.Add("ProductName", GetType(String))
dataTable.Columns.Add("Price", GetType(Decimal))
dataTable.Rows.Add(1, "Widget", 29.99D)
dataTable.Rows.Add(2, "Gadget", 49.99D)
dataTable.Rows.Add(3, "Gizmo", 19.99D)
' Create a new workbook and worksheet -- no template file needed
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Products")
' Write column headers into the first row
For col As Integer = 0 To dataTable.Columns.Count - 1
worksheet.SetCellValue(0, col, dataTable.Columns(col).ColumnName)
Next
' Write data rows
For row As Integer = 0 To dataTable.Rows.Count - 1
For col As Integer = 0 To dataTable.Columns.Count - 1
worksheet.SetCellValue(row + 1, col, dataTable.Rows(row)(col).ToString())
Next
Next
workbook.SaveAs("Products.xlsx")WorkBook.Create(ExcelFileFormat.XLSX) construye un libro nuevo en memoria -- no se necesita que exista ningún archivo de antemano. CreateWorkSheet("Products") añade una pestaña nombrada. Los bucles anidados reflejan exactamente el número de filas y columnas de la DataTable, escribiendo un valor por celda. SaveAs() descarga el libro al disco como un archivo XLSX completamente válido.
Para obtener una visión más detallada de las opciones disponibles, la guía práctica sobre la exportación de DataSet y DataTable cubre sobrecargas adicionales y patrones de exportación por lotes.
Uno de los requisitos más comunes tras una exportación básica es aplicar un estilo a la fila de encabezado para distinguirla de las filas de datos. IronXL ofrece una API de estilo completa que OleDb no puede igualar:
using IronXL;
using IronXL.Styles;
using System.Data;
DataTable dataTable = new DataTable("Products");
dataTable.Columns.Add("ProductID", typeof(int));
dataTable.Columns.Add("ProductName", typeof(string));
dataTable.Columns.Add("Price", typeof(decimal));
dataTable.Rows.Add(1, "Widget", 29.99m);
dataTable.Rows.Add(2, "Gadget", 49.99m);
dataTable.Rows.Add(3, "Gizmo", 19.99m);
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("Products");
// Write and style the header row
for (int col = 0; col < dataTable.Columns.Count; col++)
{
var headerCell = worksheet[$"{(char)('A' + col)}1"];
headerCell.Value = dataTable.Columns[col].ColumnName;
headerCell.Style.Font.Bold = true;
headerCell.Style.BackgroundColor = "#4472C4";
headerCell.Style.Font.FontColor = "#FFFFFF";
}
// Write data rows with price column formatted as currency
for (int row = 0; row < dataTable.Rows.Count; row++)
{
for (int col = 0; col < dataTable.Columns.Count; col++)
{
var cell = worksheet[$"{(char)('A' + col)}{row + 2}"];
cell.Value = dataTable.Rows[row][col].ToString();
// Apply currency format to the Price column
if (dataTable.Columns[col].ColumnName == "Price")
cell.FormatString = "$#,##0.00";
}
}
// Auto-size columns so content is not clipped
worksheet.AutoSizeColumn(0);
worksheet.AutoSizeColumn(1);
worksheet.AutoSizeColumn(2);
workbook.SaveAs("ProductsStyled.xlsx");Imports IronXL
Imports IronXL.Styles
Imports System.Data
Dim dataTable As New DataTable("Products")
dataTable.Columns.Add("ProductID", GetType(Integer))
dataTable.Columns.Add("ProductName", GetType(String))
dataTable.Columns.Add("Price", GetType(Decimal))
dataTable.Rows.Add(1, "Widget", 29.99D)
dataTable.Rows.Add(2, "Gadget", 49.99D)
dataTable.Rows.Add(3, "Gizmo", 19.99D)
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Products")
' Write and style the header row
For col As Integer = 0 To dataTable.Columns.Count - 1
Dim headerCell = worksheet($"{ChrW(AscW("A"c) + col)}1")
headerCell.Value = dataTable.Columns(col).ColumnName
headerCell.Style.Font.Bold = True
headerCell.Style.BackgroundColor = "#4472C4"
headerCell.Style.Font.FontColor = "#FFFFFF"
Next
' Write data rows with price column formatted as currency
For row As Integer = 0 To dataTable.Rows.Count - 1
For col As Integer = 0 To dataTable.Columns.Count - 1
Dim cell = worksheet($"{ChrW(AscW("A"c) + col)}{row + 2}")
cell.Value = dataTable.Rows(row)(col).ToString()
' Apply currency format to the Price column
If dataTable.Columns(col).ColumnName = "Price" Then
cell.FormatString = "$#,##0.00"
End If
Next
Next
' Auto-size columns so content is not clipped
worksheet.AutoSizeColumn(0)
worksheet.AutoSizeColumn(1)
worksheet.AutoSizeColumn(2)
workbook.SaveAs("ProductsStyled.xlsx")Esto genera un archivo con una fila de encabezado azul, texto de encabezado en blanco y valores de precio mostrados con el símbolo del dólar y dos decimales. La guía de tamaño de fuente de las celdas y la referencia de bordes y alineación explican el conjunto completo de opciones de estilo disponibles.
En el caso de conjuntos de datos con miles de filas, el rendimiento es fundamental. IronXL escribe todos los valores de las celdas en memoria antes de una sola escritura en disco en SaveAs(), lo cual es mucho más eficiente que el patrón OleDb de un ExecuteNonQuery() por fila. Si necesitas exportar tablas muy grandes, la guía "La forma más rápida de exportar DataTable a Excel" describe técnicas de streaming que ahorran memoria.
También puede agrupar la lógica de exportación con fórmulas, rangos y tablas con nombre. La guía práctica para crear hojas de cálculo y la guía para escribir en Excel en .NET proporcionan patrones completos para crear libros de trabajo de varias hojas a partir de DataTables.
En una aplicación web, normalmente se transmite el libro de trabajo directamente al navegador en lugar de guardarlo en el disco. IronXL lo soporta con workbook.ToByteArray(), que devuelve el contenido binario que puedes escribir en una respuesta HTTP:
// In an ASP.NET controller action
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("Report");
// Assume dataTable is populated from your data source
for (int col = 0; col < dataTable.Columns.Count; col++)
worksheet.SetCellValue(0, col, dataTable.Columns[col].ColumnName);
for (int row = 0; row < dataTable.Rows.Count; row++)
for (int col = 0; col < dataTable.Columns.Count; col++)
worksheet.SetCellValue(row + 1, col, dataTable.Rows[row][col].ToString());
byte[] fileBytes = workbook.ToByteArray();
return File(fileBytes, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "Report.xlsx");' In an ASP.NET controller action
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Report")
' Assume dataTable is populated from your data source
For col As Integer = 0 To dataTable.Columns.Count - 1
worksheet.SetCellValue(0, col, dataTable.Columns(col).ColumnName)
Next
For row As Integer = 0 To dataTable.Rows.Count - 1
For col As Integer = 0 To dataTable.Columns.Count - 1
worksheet.SetCellValue(row + 1, col, dataTable.Rows(row)(col).ToString())
Next
Next
Dim fileBytes As Byte() = workbook.ToByteArray()
Return File(fileBytes, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet", "Report.xlsx")El tutorial de ASP.NET sobre la exportación de DataTable a Excel explica paso a paso la configuración completa del controlador y la vista para una aplicación ASP.NET. La guía de DataTable a Excel en C# cubre escenarios adicionales, incluyendo exportaciones a varias hojas y compatibilidad con DataSet.
| Capacidad | OleDb | IronXL |
|---|---|---|
| Se requiere la instalación de un controlador | Sí (ACE.OLEDB o Jet) | No |
| Multipropósito (.NET 10 / Linux) | No | Sí |
| Crear un nuevo libro de trabajo desde cero | No | Sí |
| Formato y estilo de las celdas | No | Sí |
| Soporte de fórmulas | No | Sí |
| Rendimiento de la inserción por lotes | Fila por fila (lento) | En memoria (rápido) |
| Compatibilidad con la instrucción DELETE | No | Sí |
| Compatibilidad con Docker / contenedores | No | Sí |
Cuando una columna de DataTable contiene valores numéricos o de fecha, escribirlos como cadenas hace que Excel trate la celda como texto, lo que deshabilita la ordenación, el filtrado y las referencias a fórmulas. IronXL preserva los tipos nativos cuando pasas el valor directamente en lugar de llamar a .ToString():
WorkBook workbook = WorkBook.Create(ExcelFileFormat.XLSX);
WorkSheet worksheet = workbook.CreateWorkSheet("TypedData");
DataTable table = new DataTable();
table.Columns.Add("ID", typeof(int));
table.Columns.Add("Amount", typeof(decimal));
table.Columns.Add("Date", typeof(DateTime));
table.Rows.Add(1, 1500.75m, new DateTime(2025, 6, 15));
table.Rows.Add(2, 3200.00m, new DateTime(2025, 7, 4));
// Write headers
for (int col = 0; col < table.Columns.Count; col++)
worksheet.SetCellValue(0, col, table.Columns[col].ColumnName);
// Write typed values -- no .ToString() conversion
for (int row = 0; row < table.Rows.Count; row++)
{
worksheet.SetCellValue(row + 1, 0, (int)table.Rows[row]["ID"]);
worksheet.SetCellValue(row + 1, 1, (double)(decimal)table.Rows[row]["Amount"]);
worksheet[$"C{row + 2}"].Value = (DateTime)table.Rows[row]["Date"];
worksheet[$"C{row + 2}"].FormatString = "yyyy-MM-dd";
}
workbook.SaveAs("TypedData.xlsx");Imports System
Imports System.Data
Dim workbook As WorkBook = WorkBook.Create(ExcelFileFormat.XLSX)
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("TypedData")
Dim table As New DataTable()
table.Columns.Add("ID", GetType(Integer))
table.Columns.Add("Amount", GetType(Decimal))
table.Columns.Add("Date", GetType(DateTime))
table.Rows.Add(1, 1500.75D, New DateTime(2025, 6, 15))
table.Rows.Add(2, 3200.00D, New DateTime(2025, 7, 4))
' Write headers
For col As Integer = 0 To table.Columns.Count - 1
worksheet.SetCellValue(0, col, table.Columns(col).ColumnName)
Next
' Write typed values -- no .ToString() conversion
For row As Integer = 0 To table.Rows.Count - 1
worksheet.SetCellValue(row + 1, 0, CInt(table.Rows(row)("ID")))
worksheet.SetCellValue(row + 1, 1, CDbl(CDec(table.Rows(row)("Amount"))))
worksheet($"C{row + 2}").Value = CType(table.Rows(row)("Date"), DateTime)
worksheet($"C{row + 2}").FormatString = "yyyy-MM-dd"
Next
workbook.SaveAs("TypedData.xlsx")Excel ahora puede ordenar la columna "Importe" numéricamente y filtrar la columna "Fecha" con selectores de fecha. Para conocer otros patrones de formato de datos, consulte la guía de formato de datos de celdas. Si necesitas volver a leer los datos tras la exportación, el tutorial de Excel a DataTable explica la operación inversa.
La migración de OleDb a IronXL suele llevar menos tiempo que un solo sprint. Los cambios estructurales son:
using System.Data.OleDb y las referencias NuGet a cualquier paquete contenedor del controlador ACE.OleDbConnection con WorkBook.Create(ExcelFileFormat.XLSX).CREATE TABLE con workbook.CreateWorkSheet("SheetName").INSERT INTO con llamadas anidadas SetCellValue(), una por celda.connection.Close() con workbook.SaveAs("output.xlsx").También puedes llamar a workbook.SaveAs() con una extensión .xls para producir archivos en formato heredado si los consumidores posteriores aún no han actualizado a Excel 2007 o posterior. La guía de tipos de archivos de hojas de cálculo para convertir enumera todos los formatos de salida compatibles.
IronXL se puede utilizar de forma gratuita en el desarrollo con una Licencia Trial. Se aplica la clave en el código antes de la primera llamada a IronXL:
IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";Imports IronXL
IronXL.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"La guía de aplicación de la clave de licencia describe todas las opciones de ubicación, incluidos los archivos de configuración y las variables de Entorno. Para las implementaciones en la nube, las páginas de introducción a Docker y Linux describen los pasos de configuración específicos de cada plataforma.
Microsoft documenta las limitaciones conocidas del motor de base de datos Access para escenarios OleDb, y NuGet.org aloja el paquete IronXL con el historial completo de versiones y las estadísticas de descarga. La documentación oficial del SDK de Open XML explica la especificación XLSX subyacente que implementa IronXL.
Ahora dispone de un patrón funcional para exportar una tabla de datos (DataTable) a un archivo XLSX sin controladores OleDb, sin sintaxis SQL y sin restricciones de plataforma. El flujo de trabajo principal -- WorkBook.Create(), CreateWorkSheet(), SetCellValue() en un bucle, luego SaveAs() -- escala desde un conjunto de muestra de tres filas hasta conjuntos de datos con cientos de miles de filas.
Empieza sustituyendo tu exportación OleDb actual por el patrón básico de IronXL mostrado arriba y, una vez verificada la exportación de datos, añade el formato utilizando la API de estilo. La guía de introducción a IronXL y la descripción general de las características son lecturas recomendadas para comprender todo el alcance de lo que ofrece la biblioteca IronXL. Si trabajas con archivos CSV como parte del mismo proceso, la guía "C# DataTable to CSV" muestra cómo generar una salida delimitada por comas a partir del mismo objeto DataTable.
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.
