Ícono de mensaje
Saltar al pie de página
  1. Iron Software
  2. Blog de IronXL
  3. Usando IronXL
  4. Exportar tabla de datos usando Oledb
USANDO IRONXL

Exportar DataTable a Excel C# usando OleDb vs IronXL

Jordi Bardia
Jordi Bardia
Actualizado:

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 rellenar las celdas y, a continuación, 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.

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

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:

Install-Package IronXL
dotnet add package IronXL
Install-Package IronXL
dotnet add package IronXL
SHELL

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.

Por qué OleDb requiere la instalación de un controlador

El enfoque tradicional de OleDb trata un archivo de Excel como una base de datos. Se establece un OleDbConnection utilizando el proveedor Microsoft.ACE.OLEDB.12.0 (o el antiguo Microsoft.Jet.OLEDB.4.0 para archivos .xls), y luego se ejecutan los comandos SQL CREATE TABLE y INSERT INTO sobre 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.

¿Por qué los desarrolladores siguen utilizando OleDb para las exportaciones a Excel?

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 les resultaba natural reutilizar OleDbConnection, OleDbCommand y OleDbDataAdapter para escribir en Excel. 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 resultara 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();
}
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 Using
$vbLabelText   $csharpLabel

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

¿Cuáles son las principales limitaciones de OleDb para la exportación a Excel?

Entender por qué OleDb se queda corto te ayuda a justificar la migración ante tu equipo y a elegir el sustituto adecuado.

Dependencias de controladores y conflictos de bits

El proveedor Microsoft.ACE.OLEDB.12.0 debe instalarse por separado en cada máquina que ejecute su 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.

Sin compatibilidad multiplataforma

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. Dado que el espacio de nombres System.Data.OleDb genera un PlatformNotSupportedException en sistemas operativos distintos de Windows, cualquier ruta de código que utilice OleDb queda totalmente bloqueada para su ejecución en estas plataformas.

Sin funciones de formato de celdas

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.

El archivo Excel debe existir ya

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.

Las operaciones DELETE no son compatibles

El controlador OleDb para Excel admite INSERT y operaciones limitadas de UPDATE, pero no admite la eliminación de filas mediante DELETE FROM. 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.

¿Cómo se exporta una DataTable a Excel con IronXL?

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. Se crea un WorkBook, se añade un WorkSheet y se llama 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");
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")
$vbLabelText   $csharpLabel

WorkBook.Create(ExcelFileFormat.XLSX) crea un nuevo libro de trabajo en memoria; no es necesario que exista ningún archivo previamente. CreateWorkSheet("Products") añade una pestaña con nombre. Los bucles anidados reflejan exactamente el número de filas y columnas de la DataTable, escribiendo un valor por celda. SaveAs() guarda el libro en el disco como un archivo XLSX totalmente válido.

Resultado

Cómo exportar una tabla de datos a Excel en C# utilizando OleDb frente a IronXL: Imagen 1 - Resultado en Excel

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.

¿Cómo se añade formato a las celdas al exportar una DataTable?

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

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.

Gestión de exportaciones de DataTable de gran tamaño

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 realizar una sola escritura en disco en SaveAs(), lo cual es mucho más eficiente que el patrón de 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.

¿Cómo se exporta una DataTable a Excel en ASP.NET?

En una aplicación web, normalmente se transmite el libro de trabajo directamente al navegador en lugar de guardarlo en el disco. IronXL admite esto con workbook.ToByteArray(), que devuelve el contenido binario que se puede 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
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")
$vbLabelText   $csharpLabel

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.

Comparación rápida entre OleDb e IronXL

Comparación de características entre OleDb e IronXL para la exportación de DataTable a Excel en C#
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í

¿Cómo se gestionan los tipos de datos de las columnas durante la exportación?

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 conserva los tipos nativos cuando se pasa 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");
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")
$vbLabelText   $csharpLabel

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.

Migración del código de exportación OleDb existente

La migración de OleDb a IronXL suele llevar menos tiempo que un solo sprint. Los cambios estructurales son:

  1. Eliminar todas las referencias using System.Data.OleDb y las referencias NuGet a cualquier paquete de envoltura de controladores ACE.
  2. Sustituya el bloque de inicialización OleDbConnection por WorkBook.Create(ExcelFileFormat.XLSX).
  3. Sustituya el comando CREATE TABLE por workbook.CreateWorkSheet("SheetName").
  4. Sustituya el bucle INSERT INTO por llamadas anidadas SetCellValue(), una por celda.
  5. Sustituya connection.Close() por workbook.SaveAs("output.xlsx").

También puede llamar a workbook.SaveAs() con una extensión .xls para generar archivos en formato heredado si los usuarios finales aún no se han actualizado a Excel 2007 o una versión posterior. La guía de tipos de archivos de hojas de cálculo para convertir enumera todos los formatos de salida compatibles.

¿Cómo se prueba y se obtiene la licencia de IronXL?

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";
IronXl.License.LicenseKey = "YOUR-LICENSE-KEY-HERE";
Imports IronXl

IronXl.License.LicenseKey = "YOUR-LICENSE-KEY-HERE"
$vbLabelText   $csharpLabel

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.

¿Cuales son tus próximos pasos?

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, y luego SaveAs()— se adapta desde una 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.

Preguntas Frecuentes

¿Cuáles son las limitaciones del uso de OleDb para exportar DataTable a Excel en C#?

Usar OleDb para exportar DataTable a Excel en C# puede ser frustrante debido a su naturaleza heredada. Los desarrolladores suelen encontrarse con limitaciones como problemas de compatibilidad, un rendimiento más lento y una gestión de errores más compleja, lo que hace que alternativas modernas como IronXL sean más atractivas.

¿Cómo mejora IronXL el proceso de exportación de DataTable a Excel?

IronXL ofrece un enfoque moderno para exportar DataTable a Excel, ofreciendo un mejor rendimiento, mayor compatibilidad y código simplificado. Elimina las frustraciones comunes de OleDb, facilitando a los desarrolladores .NET la gestión de las exportaciones a Excel.

¿Por qué debería considerar cambiar de OleDb a IronXL para las exportaciones de DataTable?

Cambiar a IronXL para las exportaciones de DataTable ofrece varias ventajas, incluido un mejor rendimiento, una implementación más sencilla y una mayor compatibilidad con las aplicaciones .NET modernas, lo que reduce el tiempo y el esfuerzo necesarios para el desarrollo.

¿Puede IronXL gestionar grandes exportaciones de DataTable de manera más eficiente que OleDb?

Sí, IronXL está diseñado para manejar de manera eficiente grandes exportaciones de DataTable, ofreciendo tiempos de procesamiento más rápidos y reduciendo el uso de memoria en comparación con OleDb, lo que lo hace ideal para aplicaciones que manejan conjuntos de datos sustanciales.

¿IronXL es compatible con las últimas versiones de C# y .NET?

IronXL es totalmente compatible con las últimas versiones de C# y .NET, lo que garantiza una integración perfecta con aplicaciones modernas al tiempo que proporciona actualizaciones continuas para admitir nuevas funciones y mejoras.

¿Qué beneficios ofrecen las alternativas modernas como IronXL sobre el OleDb tradicional?

Las alternativas modernas como IronXL ofrecen beneficios como un rendimiento mejorado, un manejo más sencillo de errores, una mejor compatibilidad con varios formatos de Excel y un código simplificado, lo que puede mejorar enormemente la productividad del desarrollador.

¿Cómo gestiona IronXL la gestión de errores en comparación con OleDb?

IronXL ofrece una gestión de errores simplificada con un manejo claro de excepciones, lo que reduce la complejidad y los problemas potenciales asociados con OleDb, lo que facilita a los desarrolladores la depuración y el mantenimiento de sus aplicaciones.

¿Cuáles son los casos de uso comunes para exportar DataTable a Excel en aplicaciones .NET basadas en UI?

En aplicaciones .NET basadas en UI, la exportación de DataTable a Excel se usa comúnmente para generar informes, análisis de datos y manipulación de datos sencilla, a menudo activada por controladores de eventos que utilizan patrones de remitente de objetos.

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