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

Exportar una tabla de datos de Excel en C# | Convertir datos de Excel

Jordi Bardia
Jordi Bardia
Actualizado:

La exportación de datos de Excel a un DataTable le proporciona acceso estructurado y en memoria al contenido de la hoja de cálculo, que funciona de forma natural con bases de datos, controles de interfaz de usuario y consultas LINQ. La dirección inversa —escribir un DataTable de nuevo en un archivo de Excel— es igual de importante para los flujos de trabajo de generación de informes y almacenamiento de datos. IronXL gestiona ambas direcciones en .NET puro, sin dependencia de Microsoft Office y sin necesidad de configuración de interoperabilidad COM.

Instala IronXL antes de ejecutar cualquiera de los ejemplos siguientes:

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

Una vez instalados, los tipos WorkBook y WorkSheet exponen los métodos ToDataTable y ToDataSet que se asignan directamente a las estructuras System.Data. También puede invertir el proceso escribiendo los valores DataRow de nuevo en una hoja de cálculo y guardando el archivo en formato XLSX o XLS.

¿Cómo se convierte una hoja de cálculo completa en una DataTable?

El método ToDataTable convierte una hoja de cálculo completa —o un rango con nombre— en un System.Data.DataTable. Pase true para tratar la primera fila como encabezados de columna, de modo que los nombres de las columnas de la tabla resultante coincidan exactamente con los encabezados de su hoja de cálculo.

using IronXL;
using System.Data;

// Load the workbook from disk
WorkBook workbook = WorkBook.Load("customers.xlsx");

// Grab the default (first) worksheet
WorkSheet worksheet = workbook.DefaultWorkSheet;

// Convert the entire sheet; first row becomes column headers
DataTable dataTable = worksheet.ToDataTable(true);

// Iterate every row and print each cell value
foreach (DataRow row in dataTable.Rows)
{
    for (int i = 0; i < dataTable.Columns.Count; i++)
    {
        Console.Write(row[i] + "\t");
    }
    Console.WriteLine();
}
using IronXL;
using System.Data;

// Load the workbook from disk
WorkBook workbook = WorkBook.Load("customers.xlsx");

// Grab the default (first) worksheet
WorkSheet worksheet = workbook.DefaultWorkSheet;

// Convert the entire sheet; first row becomes column headers
DataTable dataTable = worksheet.ToDataTable(true);

// Iterate every row and print each cell value
foreach (DataRow row in dataTable.Rows)
{
    for (int i = 0; i < dataTable.Columns.Count; i++)
    {
        Console.Write(row[i] + "\t");
    }
    Console.WriteLine();
}
Imports IronXL
Imports System.Data

' Load the workbook from disk
Dim workbook As WorkBook = WorkBook.Load("customers.xlsx")

' Grab the default (first) worksheet
Dim worksheet As WorkSheet = workbook.DefaultWorkSheet

' Convert the entire sheet; first row becomes column headers
Dim dataTable As DataTable = worksheet.ToDataTable(True)

' Iterate every row and print each cell value
For Each row As DataRow In dataTable.Rows
    For i As Integer = 0 To dataTable.Columns.Count - 1
        Console.Write(row(i) & vbTab)
    Next
    Console.WriteLine()
Next
$vbLabelText   $csharpLabel

Qué hace el código

WorkBook.Load lee el archivo XLSX sin ninguna automatización de Office. worksheet.ToDataTable(true) recorre cada celda de la hoja y la asigna a un DataRow, utilizando la primera fila como nombres de DataColumn. El resultado DataTable es un objeto estándar System.Data: puede vincularlo a un DataGridView, pasarlo a un SqlBulkCopy o ejecutar consultas LINQ sobre él inmediatamente.

La llamada ToDataTable es compatible con los formatos XLS y XLSX, por lo que el mismo código funciona para hojas de cálculo heredadas sin necesidad de modificaciones. Consulte la documentación de IronXL DataTable y DataSet para obtener la referencia completa de la API.

¿Cómo se exporta un rango de celdas específico a una tabla de datos?

Cuando una hoja de cálculo contiene varias regiones de datos, o cuando solo necesitas un subconjunto de filas y columnas, puedes exportar un rango de celdas específico en lugar de la hoja completa. Este enfoque es más eficiente para archivos grandes, ya que IronXL solo procesa las celdas seleccionadas.

using IronXL;
using System.Data;

WorkBook workbook = WorkBook.Load("financial_report.xlsx");

// Access a named worksheet
WorkSheet worksheet = workbook.GetWorkSheet("Summary");

// Select only the region A1:D20 and convert it
DataTable dt = worksheet["A1:D20"].ToDataTable(true);

Console.WriteLine($"Rows: {dt.Rows.Count}, Columns: {dt.Columns.Count}");

foreach (DataRow row in dt.Rows)
{
    foreach (var item in row.ItemArray)
    {
        Console.Write(item + "\t");
    }
    Console.WriteLine();
}
using IronXL;
using System.Data;

WorkBook workbook = WorkBook.Load("financial_report.xlsx");

// Access a named worksheet
WorkSheet worksheet = workbook.GetWorkSheet("Summary");

// Select only the region A1:D20 and convert it
DataTable dt = worksheet["A1:D20"].ToDataTable(true);

Console.WriteLine($"Rows: {dt.Rows.Count}, Columns: {dt.Columns.Count}");

foreach (DataRow row in dt.Rows)
{
    foreach (var item in row.ItemArray)
    {
        Console.Write(item + "\t");
    }
    Console.WriteLine();
}
Imports IronXL
Imports System.Data

Dim workbook As WorkBook = WorkBook.Load("financial_report.xlsx")

' Access a named worksheet
Dim worksheet As WorkSheet = workbook.GetWorkSheet("Summary")

' Select only the region A1:D20 and convert it
Dim dt As DataTable = worksheet("A1:D20").ToDataTable(True)

Console.WriteLine($"Rows: {dt.Rows.Count}, Columns: {dt.Columns.Count}")

For Each row As DataRow In dt.Rows
    For Each item In row.ItemArray
        Console.Write(item & vbTab)
    Next
    Console.WriteLine()
Next
$vbLabelText   $csharpLabel

Por qué es importante la selección de rangos

La sintaxis entre corchetes worksheet["A1:D20"] devuelve un objeto IronXl.Range. Llamar a ToDataTable en ese rango limita el procesamiento exactamente a esas celdas, lo que significa una ejecución más rápida y un menor consumo de memoria cuando el archivo de origen tiene decenas de miles de filas.

También puede especificar rangos con nombre o construir la cadena de rango dinámicamente en tiempo de ejecución —por ejemplo, $"A1:D{lastRow}"—, lo que hace que el enfoque sea flexible para exportaciones de datos de longitud variable. La referencia de la API de la clase Range documenta todos los métodos de selección y consulta disponibles.

¿Cómo se convierte un libro de varias hojas en un conjunto de datos?

Los libros de trabajo con varias hojas se asignan de forma natural a System.Data.DataSet, donde cada hoja se convierte en un DataTable independiente. El método ToDataSet realiza esta conversión en una sola llamada.

using IronXL;
using System.Data;

WorkBook workbook = WorkBook.Load("multi_sheet.xlsx");

// Each worksheet becomes a DataTable inside the DataSet
DataSet dataSet = workbook.ToDataSet();

foreach (DataTable table in dataSet.Tables)
{
    Console.WriteLine($"Sheet: {table.TableName}");
    Console.WriteLine($"Rows:  {table.Rows.Count}");
    Console.WriteLine();
}
using IronXL;
using System.Data;

WorkBook workbook = WorkBook.Load("multi_sheet.xlsx");

// Each worksheet becomes a DataTable inside the DataSet
DataSet dataSet = workbook.ToDataSet();

foreach (DataTable table in dataSet.Tables)
{
    Console.WriteLine($"Sheet: {table.TableName}");
    Console.WriteLine($"Rows:  {table.Rows.Count}");
    Console.WriteLine();
}
Imports IronXL
Imports System.Data

Dim workbook As WorkBook = WorkBook.Load("multi_sheet.xlsx")

' Each worksheet becomes a DataTable inside the DataSet
Dim dataSet As DataSet = workbook.ToDataSet()

For Each table As DataTable In dataSet.Tables
    Console.WriteLine($"Sheet: {table.TableName}")
    Console.WriteLine($"Rows:  {table.Rows.Count}")
    Console.WriteLine()
Next
$vbLabelText   $csharpLabel

Acceder a hojas por nombre

Cada DataTable en el DataSet devuelto utiliza el nombre original de la hoja de cálculo como su propiedad TableName, por lo que puede recuperar una hoja específica con dataSet.Tables["Summary"] en lugar de iterar por la colección. Esto facilita la creación de lógica de generación de informes en varias hojas o la combinación de datos de varias hojas de cálculo antes de escribir los resultados en una base de datos.

Para conocer más formas de trabajar con varias hojas y navegar por la estructura del libro, consulta cómo abrir y gestionar hojas de cálculo de Excel.

¿Cómo se exporta una tabla de datos (DataTable) a un archivo de Excel?

La dirección "importar a DataTable" es solo la mitad de la historia. Cuando necesites volver a escribir datos estructurados en una hoja de cálculo —para informes, descargas o archivo—, crea un nuevo libro, rellena las celdas a partir del DataTable y ahorra.

using IronXL;
using System.Data;

// Build a sample DataTable
DataTable dt = new DataTable();
dt.Columns.Add(new DataColumn("ProductID", typeof(int)));
dt.Columns.Add(new DataColumn("ProductName", typeof(string)));
dt.Columns.Add(new DataColumn("UnitPrice", typeof(decimal)));
dt.Rows.Add(1, "Widget Pro", 29.99m);
dt.Rows.Add(2, "Gadget Max", 49.99m);
dt.Rows.Add(3, "Sensor Kit", 14.50m);

// Create a new workbook and worksheet
WorkBook workbook = WorkBook.Create();
WorkSheet worksheet = workbook.CreateWorkSheet("Products");

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

// Write data rows
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]);
    }
}

// Save as XLSX
workbook.SaveAs("products_export.xlsx");
Console.WriteLine("Export complete.");
using IronXL;
using System.Data;

// Build a sample DataTable
DataTable dt = new DataTable();
dt.Columns.Add(new DataColumn("ProductID", typeof(int)));
dt.Columns.Add(new DataColumn("ProductName", typeof(string)));
dt.Columns.Add(new DataColumn("UnitPrice", typeof(decimal)));
dt.Rows.Add(1, "Widget Pro", 29.99m);
dt.Rows.Add(2, "Gadget Max", 49.99m);
dt.Rows.Add(3, "Sensor Kit", 14.50m);

// Create a new workbook and worksheet
WorkBook workbook = WorkBook.Create();
WorkSheet worksheet = workbook.CreateWorkSheet("Products");

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

// Write data rows
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]);
    }
}

// Save as XLSX
workbook.SaveAs("products_export.xlsx");
Console.WriteLine("Export complete.");
Imports IronXL
Imports System.Data

' Build a sample DataTable
Dim dt As New DataTable()
dt.Columns.Add(New DataColumn("ProductID", GetType(Integer)))
dt.Columns.Add(New DataColumn("ProductName", GetType(String)))
dt.Columns.Add(New DataColumn("UnitPrice", GetType(Decimal)))
dt.Rows.Add(1, "Widget Pro", 29.99D)
dt.Rows.Add(2, "Gadget Max", 49.99D)
dt.Rows.Add(3, "Sensor Kit", 14.50D)

' Create a new workbook and worksheet
Dim workbook As WorkBook = WorkBook.Create()
Dim worksheet As WorkSheet = workbook.CreateWorkSheet("Products")

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

' Write data rows
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))
    Next
Next

' Save as XLSX
workbook.SaveAs("products_export.xlsx")
Console.WriteLine("Export complete.")
$vbLabelText   $csharpLabel

Cómo funciona el bucle de escritura de celdas

SetCellValue(rowIndex, columnIndex, value) acepta valores object, por lo que se pasan los nombres de las columnas para la fila de encabezado y los valores de las celdas sin formato para las filas de datos sin necesidad de conversión de tipos. El desplazamiento de fila de row + 1 reserva la fila 0 para los encabezados. El archivo XLSX resultante es una hoja de cálculo totalmente válida: sin marcadores de posición ni archivos temporales.

Para tablas de datos más grandes, considere aplicar el ajuste automático del tamaño de las columnas después de escribir los datos, de modo que el contenido se muestre de forma clara sin necesidad de formateo manual.

¿Cómo se vincula la DataTable a un DataGridView?

Una de las razones más comunes para exportar una hoja de Excel a un DataTable es mostrarla en un Windows Forms DataGridView. Una vez que tengas un DataTable, la vinculación se realiza con una sola línea de código.

using IronXL;
using System.Data;
using System.Windows.Forms;

WorkBook workbook = WorkBook.Load("inventory.xlsx");
WorkSheet worksheet = workbook.DefaultWorkSheet;
DataTable dataTable = worksheet.ToDataTable(true);

// Bind directly to a DataGridView
dataGridViewInventory.DataSource = dataTable;
using IronXL;
using System.Data;
using System.Windows.Forms;

WorkBook workbook = WorkBook.Load("inventory.xlsx");
WorkSheet worksheet = workbook.DefaultWorkSheet;
DataTable dataTable = worksheet.ToDataTable(true);

// Bind directly to a DataGridView
dataGridViewInventory.DataSource = dataTable;
Imports IronXL
Imports System.Data
Imports System.Windows.Forms

Dim workbook As WorkBook = WorkBook.Load("inventory.xlsx")
Dim worksheet As WorkSheet = workbook.DefaultWorkSheet
Dim dataTable As DataTable = worksheet.ToDataTable(True)

' Bind directly to a DataGridView
dataGridViewInventory.DataSource = dataTable
$vbLabelText   $csharpLabel

¿Qué ocurre en el momento de la vinculación?

Al establecer DataSource, se activa DataGridView para leer los nombres de las columnas y los datos de las filas de DataTable. Cada DataColumn se convierte en una columna de la cuadrícula, y cada DataRow se convierte en una fila visible. Puede aplicar comportamientos de ordenación, filtrado y selección a través de los controles integrados de la cuadrícula sin necesidad de código adicional.

Este patrón funciona igual de bien con WPF DataGrid, ASP.NET GridView y cualquier otra infraestructura de enlace de datos de .NET. Para obtener una guía paso a paso, consulte cómo exportar un DataGridView a Excel en la dirección inversa.

¿Cómo se utilizan las consultas LINQ en una DataTable exportada?

Después de convertir una hoja de cálculo a un DataTable, puede ejecutar consultas LINQ utilizando el método de extensión AsEnumerable(), que transforma cada DataRow en un elemento consultable.

using IronXL;
using System.Data;
using System.Linq;

WorkBook workbook = WorkBook.Load("sales.xlsx");
DataTable dt = workbook.DefaultWorkSheet.ToDataTable(true);

// Filter rows where the "Revenue" column exceeds 10000
var highRevenue = dt.AsEnumerable()
    .Where(row => row.Field<double>("Revenue") > 10000)
    .OrderByDescending(row => row.Field<double>("Revenue"))
    .ToList();

Console.WriteLine($"High-revenue records: {highRevenue.Count}");
foreach (var row in highRevenue)
{
    Console.WriteLine($"{row["Product"]}: {row["Revenue"]:C}");
}
using IronXL;
using System.Data;
using System.Linq;

WorkBook workbook = WorkBook.Load("sales.xlsx");
DataTable dt = workbook.DefaultWorkSheet.ToDataTable(true);

// Filter rows where the "Revenue" column exceeds 10000
var highRevenue = dt.AsEnumerable()
    .Where(row => row.Field<double>("Revenue") > 10000)
    .OrderByDescending(row => row.Field<double>("Revenue"))
    .ToList();

Console.WriteLine($"High-revenue records: {highRevenue.Count}");
foreach (var row in highRevenue)
{
    Console.WriteLine($"{row["Product"]}: {row["Revenue"]:C}");
}
Imports IronXL
Imports System.Data
Imports System.Linq

Dim workbook As WorkBook = WorkBook.Load("sales.xlsx")
Dim dt As DataTable = workbook.DefaultWorkSheet.ToDataTable(True)

' Filter rows where the "Revenue" column exceeds 10000
Dim highRevenue = dt.AsEnumerable() _
    .Where(Function(row) row.Field(Of Double)("Revenue") > 10000) _
    .OrderByDescending(Function(row) row.Field(Of Double)("Revenue")) _
    .ToList()

Console.WriteLine($"High-revenue records: {highRevenue.Count}")
For Each row In highRevenue
    Console.WriteLine($"{row("Product")}: {row("Revenue"):C}")
Next
$vbLabelText   $csharpLabel

Por qué es útil LINQ en DataTable

Las consultas LINQ le ofrecen una forma legible y fuertemente tipada de filtrar, ordenar, agrupar y proyectar datos de una hoja de cálculo convertida. row.Field<t>(columnName) gestiona la coerción de tipos de forma limpia, lanzando un InvalidCastException si un valor no se puede convertir, en lugar de devolver un null silencioso. Esto facilita la detección temprana de problemas de calidad de los datos.

Combine este enfoque con la exportación basada en rangos de la sección anterior para consultar regiones específicas de la hoja en lugar de hojas de cálculo completas, lo que mantiene bajo el uso de memoria en archivos de gran tamaño.

¿Cómo se gestionan las celdas nulas y vacías durante la exportación?

Las hojas de cálculo de Excel suelen tener huecos: celdas vacías, regiones fusionadas o texto de marcador de posición. IronXL asigna las celdas vacías a DBNull.Value en el DataTable exportado, lo que se ajusta al comportamiento estándar de ADO.NET para que su código de gestión de valores nulos existente funcione sin modificaciones.

Cómo IronXL asigna los estados de las celdas de Excel a los valores de DataTable
Estado de la celda de Excel Valor de DataTable Notas
Valor del texto Cadena Devuelto tal cual
Valor numérico Doble o Decimal Depende del formato de la celda
Valor de fecha DateTime Analizado a partir del número de serie
Valor booleano Booleano VERDADERO/FALSO en Excel
Celdilla vacía DBNull.Value Nulo estándar de ADO.NET Standard
Celdas de fórmula Resultado calculado IronXL evalúa primero la fórmula

Al escribir un DataTable de vuelta a Excel, los campos DBNull.Value producen celdas vacías, preservando la fidelidad de ida y vuelta. Si necesitas una cadena predeterminada para los campos nulos, sustituye DBNull.Value por tu marcador de posición antes de llamar a SetCellValue.

Para obtener más orientación sobre la preparación de datos, la documentación de la clase DataTable de Microsoft trata en profundidad el manejo de valores nulos, la gestión de restricciones y los estados de las filas.

¿Cómo se ahorra memoria al exportar hojas de cálculo de gran tamaño?

En el caso de hojas de cálculo con muchos miles de filas, al exportar toda la hoja de una sola vez se asignan todos los datos a la memoria simultáneamente. Dos patrones de IronXL reducen el pico de uso de memoria:

  • Exportación de rango: Utilice worksheet["A1:D5000"].ToDataTable(true) para procesar una región delimitada en lugar de la hoja completa.
  • Procesamiento por lotes: Calcule la última fila utilizada con worksheet.RowCount, luego recorra rangos de tamaño fijo —por ejemplo, 1000 filas a la vez— y procese cada lote antes de pasar al siguiente.

Las propiedades worksheet.RowCount y worksheet.ColumnCount te permiten crear cadenas de rango dinámico sin codificar las dimensiones de forma rígida:

using IronXL;
using System.Data;

WorkBook workbook = WorkBook.Load("large_dataset.xlsx");
WorkSheet worksheet = workbook.DefaultWorkSheet;

int batchSize = 1000;
int totalRows = worksheet.RowCount;

for (int startRow = 1; startRow <= totalRows; startRow += batchSize)
{
    int endRow = Math.Min(startRow + batchSize - 1, totalRows);
    string rangeAddress = $"A{startRow}:Z{endRow}";

    DataTable batch = worksheet[rangeAddress].ToDataTable(false);
    // Process each batch -- write to database, transform, etc.
    Console.WriteLine($"Processed rows {startRow} to {endRow}");
}
using IronXL;
using System.Data;

WorkBook workbook = WorkBook.Load("large_dataset.xlsx");
WorkSheet worksheet = workbook.DefaultWorkSheet;

int batchSize = 1000;
int totalRows = worksheet.RowCount;

for (int startRow = 1; startRow <= totalRows; startRow += batchSize)
{
    int endRow = Math.Min(startRow + batchSize - 1, totalRows);
    string rangeAddress = $"A{startRow}:Z{endRow}";

    DataTable batch = worksheet[rangeAddress].ToDataTable(false);
    // Process each batch -- write to database, transform, etc.
    Console.WriteLine($"Processed rows {startRow} to {endRow}");
}
Imports IronXL
Imports System.Data

Dim workbook As WorkBook = WorkBook.Load("large_dataset.xlsx")
Dim worksheet As WorkSheet = workbook.DefaultWorkSheet

Dim batchSize As Integer = 1000
Dim totalRows As Integer = worksheet.RowCount

For startRow As Integer = 1 To totalRows Step batchSize
    Dim endRow As Integer = Math.Min(startRow + batchSize - 1, totalRows)
    Dim rangeAddress As String = $"A{startRow}:Z{endRow}"

    Dim batch As DataTable = worksheet(rangeAddress).ToDataTable(False)
    ' Process each batch -- write to database, transform, etc.
    Console.WriteLine($"Processed rows {startRow} to {endRow}")
Next
$vbLabelText   $csharpLabel

Este patrón es especialmente relevante para leer archivos Excel de gran tamaño en C#, donde existen limitaciones de memoria.

¿Cómo se escribe la tabla de datos en una base de datos?

Una vez que se dispone de un DataTable, insertarlo en SQL Server mediante SqlBulkCopy es la forma más rápida de trabajar con grandes conjuntos de datos. SqlBulkCopy acepta un DataTable directamente y transmite filas por lotes sin crear sentencias INSERT individuales.

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

WorkBook workbook = WorkBook.Load("orders.xlsx");
DataTable dataTable = workbook.DefaultWorkSheet.ToDataTable(true);

string connectionCadena = "Server=.;Database=OrdersDB;Trusted_Connection=True;";

using SqlConnection connection = new(connectionCadena);
connection.Open();

using SqlBulkCopy bulkCopy = new(connection);
bulkCopy.DestinationTableName = "dbo.Orders";
bulkCopy.BatchSize = 500;
bulkCopy.BulkCopyTimeout = 60;

// Map DataTable columns to database columns
bulkCopy.ColumnMappings.Add("OrderID", "OrderID");
bulkCopy.ColumnMappings.Add("CustomerName", "CustomerName");
bulkCopy.ColumnMappings.Add("TotalAmount", "TotalAmount");

bulkCopy.WriteToServer(dataTable);
Console.WriteLine("Bulk insert complete.");
using IronXL;
using System.Data;
using Microsoft.Data.SqlClient;

WorkBook workbook = WorkBook.Load("orders.xlsx");
DataTable dataTable = workbook.DefaultWorkSheet.ToDataTable(true);

string connectionCadena = "Server=.;Database=OrdersDB;Trusted_Connection=True;";

using SqlConnection connection = new(connectionCadena);
connection.Open();

using SqlBulkCopy bulkCopy = new(connection);
bulkCopy.DestinationTableName = "dbo.Orders";
bulkCopy.BatchSize = 500;
bulkCopy.BulkCopyTimeout = 60;

// Map DataTable columns to database columns
bulkCopy.ColumnMappings.Add("OrderID", "OrderID");
bulkCopy.ColumnMappings.Add("CustomerName", "CustomerName");
bulkCopy.ColumnMappings.Add("TotalAmount", "TotalAmount");

bulkCopy.WriteToServer(dataTable);
Console.WriteLine("Bulk insert complete.");
Imports IronXL
Imports System.Data
Imports Microsoft.Data.SqlClient

Dim workbook As WorkBook = WorkBook.Load("orders.xlsx")
Dim dataTable As DataTable = workbook.DefaultWorkSheet.ToDataTable(True)

Dim connectionCadena As String = "Server=.;Database=OrdersDB;Trusted_Connection=True;"

Using connection As New SqlConnection(connectionCadena)
    connection.Open()

    Using bulkCopy As New SqlBulkCopy(connection)
        bulkCopy.DestinationTableName = "dbo.Orders"
        bulkCopy.BatchSize = 500
        bulkCopy.BulkCopyTimeout = 60

        ' Map DataTable columns to database columns
        bulkCopy.ColumnMappings.Add("OrderID", "OrderID")
        bulkCopy.ColumnMappings.Add("CustomerName", "CustomerName")
        bulkCopy.ColumnMappings.Add("TotalAmount", "TotalAmount")

        bulkCopy.WriteToServer(dataTable)
    End Using
End Using

Console.WriteLine("Bulk insert complete.")
$vbLabelText   $csharpLabel

Consideraciones sobre la asignación de columnas

La colección ColumnMappings hace coincidir los nombres de las columnas DataTable con los nombres de las columnas de la base de datos. Si ambos nombres son idénticos, puede omitir las asignaciones individuales y SqlBulkCopy se emparejará automáticamente por el nombre. Las asignaciones explícitas son más seguras cuando el orden de las columnas de la hoja de cálculo difiere del esquema de la base de datos.

Para obtener más información sobre cómo combinar IronXL con flujos de trabajo de bases de datos, la guía de importación de Excel en C# cubre escenarios de importación adicionales, incluida la validación previa a la inserción.

Para proyectos basados en Entity Framework, convierta primero sus filas DataTable en objetos de modelo tipados y, a continuación, utilice DbContext.BulkInsert de una biblioteca como EFCore.BulkExtensions para la inserción por lotes compatible con ORM. La documentación de SqlBulkCopy de Microsoft explica en detalle las opciones de procesamiento por lotes y la compatibilidad con transacciones.

¿Cuales son tus próximos pasos?

Ahora dispone de un conjunto completo de herramientas para transferir datos entre Excel y DataTable en ambas direcciones utilizando IronXL:

  • Convertir una hoja de cálculo completa con worksheet.ToDataTable(true) para exportaciones que tengan en cuenta los encabezados
  • Exportar un rango de celdas específico con la sintaxis worksheet["A1:D20"].ToDataTable(true)
  • Convierte libros de varias hojas con workbook.ToDataSet() para obtener acceso completo a DataSet
  • Escribir el contenido de DataTable de nuevo en XLSX iterando los valores de DataRow con SetCellValue
  • Vincular DataTable a controles de la interfaz de usuario como DataGridView con una única asignación DataSource
  • Alimentar SqlBulkCopy directamente desde un DataTable para inserciones en bases de datos de alto rendimiento

Para profundizar en tus conocimientos de IronXL, explora estos temas relacionados:

Empieza con una licencia de prueba gratuita de IronXL para ejecutar estos ejemplos en tus propios proyectos. Cuando esté listo para la implementación, adquiera una licencia de producción o póngase en contacto con el equipo para obtener orientación sobre las licencias.

Empiece con IronXL ahora.
green arrow pointer

Preguntas Frecuentes

¿Cómo puedo exportar datos de Excel a una DataTable en C# usando IronXL?

Puede exportar datos de Excel a una DataTable en C# usando IronXL cargando el archivo de Excel en IronXL, seleccionando la hoja de cálculo o el rango y luego usando el método ExportToDataTable para convertir los datos en un objeto DataTable.

¿Cuáles son los beneficios de convertir datos de Excel a una DataTable?

La conversión de datos de Excel a una DataTable proporciona datos estructurados ideales para operaciones de bases de datos, la vinculación de datos a controles de interfaz de usuario y una integración fluida con .NET. Además, facilita la manipulación y el procesamiento de datos en aplicaciones de C#.

¿Puede IronXL gestionar tanto la importación como la exportación de datos entre Excel y DataTable?

Sí, IronXL maneja de manera eficiente tanto la importación de datos de Excel a una DataTable como la exportación de datos de una DataTable a Excel, lo que lo convierte en una herramienta versátil para administrar el intercambio de datos en aplicaciones C#.

¿Es posible convertir rangos específicos dentro de una hoja de Excel a una DataTable usando IronXL?

Sí, IronXL le permite seleccionar rangos específicos dentro de una hoja de Excel y convertirlos en una DataTable, lo que le brinda flexibilidad en la manipulación y extracción de datos.

¿Necesito tener instalado Microsoft Office para usar IronXL para la conversión de datos de Excel?

No, no necesita tener Microsoft Office instalado en su equipo para usar IronXL y convertir datos de Excel a DataTable o viceversa. IronXL funciona independientemente de Microsoft Office.

¿Qué tipos de datos se pueden convertir de Excel a DataTable usando IronXL?

IronXL puede convertir varios tipos de datos de Excel, incluidos números, texto, fechas y fórmulas, a un formato DataTable, preservando la integridad y la estructura de los datos.

¿Puede IronXL exportar un DataTable a un archivo Excel?

Sí, IronXL puede exportar una DataTable a un archivo Excel, lo que le permite generar informes o crear soluciones de almacenamiento de datos directamente desde sus aplicaciones C#.

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