Í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

Cómo exportar Excel a DataTable C# con IronXL

Jordi Bardia
Jordi Bardia
Publicado:

La conversión de datos de Excel a una DataTable proporciona datos estructurados ideales para operaciones de bases de datos, vinculación de datos a controles de UI e integración perfecta con .NET. La operación inversa, exportar una DataTable a un archivo Excel, es igualmente valiosa para generar informes y soluciones de almacenamiento de datos. Ya sea que necesite exportar Excel a aplicaciones DataTable C# o importar datos desde hojas de cálculo, IronXL maneja ambas direcciones de manera eficiente.

IronXL es una biblioteca .NET que simplifica estas conversiones sin dependencias de Microsoft Office. El método ToDataTable transforma una hoja de cálculo de Excel en un objeto DataTable, mientras que la biblioteca también admite la creación de nuevos archivos de libros de trabajo a partir de fuentes DataTable. Esta biblioteca compatible con .NET Framework y .NET Core funciona en Windows, Linux y macOS. Comience su prueba gratuita para explorar estas capacidades.

¿Cómo convierto una hoja de cálculo completa de Excel en una tabla de datos?

El método ToDataTable (que funciona como un método ExportDataTable) convierte una hoja de cálculo completa o un rango específico en una System.Data.DataTable. Pase verdadero como parámetro para utilizar la primera fila como encabezado de columna, garantizando que los nombres de las columnas coincidan con la estructura de datos de Excel.

El siguiente código muestra cómo convertir Excel a DataTable en C#:

using IronXL;
using System;
using System.Data;
class Program
{
    static void Main(string[] args)
    {
        // Load the Excel file workbook using string filepath
        string filepath = "customers.xlsx";
        WorkBook workbook = WorkBook.Load(filepath);
        // Access the first worksheet (default sheet)
        WorkSheet worksheet = workbook.DefaultWorkSheet;
        // Convert Excel to DataTable with first row as column headers
        DataTable dataTable = worksheet.ToDataTable(true);
        // Iterate through rows and columns to read Excel data
        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;
using System.Data;
class Program
{
    static void Main(string[] args)
    {
        // Load the Excel file workbook using string filepath
        string filepath = "customers.xlsx";
        WorkBook workbook = WorkBook.Load(filepath);
        // Access the first worksheet (default sheet)
        WorkSheet worksheet = workbook.DefaultWorkSheet;
        // Convert Excel to DataTable with first row as column headers
        DataTable dataTable = worksheet.ToDataTable(true);
        // Iterate through rows and columns to read Excel data
        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
Imports System.Data

Class Program
    Shared Sub Main(args As String())
        ' Load the Excel file workbook using string filepath
        Dim filepath As String = "customers.xlsx"
        Dim workbook As WorkBook = WorkBook.Load(filepath)
        ' Access the first worksheet (default sheet)
        Dim worksheet As WorkSheet = workbook.DefaultWorkSheet
        ' Convert Excel to DataTable with first row as column headers
        Dim dataTable As DataTable = worksheet.ToDataTable(True)
        ' Iterate through rows and columns to read Excel data
        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
    End Sub
End Class
$vbLabelText   $csharpLabel

Resultado

Cómo exportar Excel a DataTable en C# con IronXL: Imagen 1 - Salida para convertir datos de Excel a DataTable

Este código carga un archivo Excel utilizando WorkBook.Load y luego accede a la hoja de cálculo predeterminada. La llamada ToDataTable(true) realiza la conversión de datos de Excel a un objeto DataTable, tratando la primera fila como nombres de columna. El bucle foreach demuestra cómo leer datos de Excel desde el DataTable resultante iterando a través de cada fila de DataRow y accediendo a las celdas por índice. También puedes consultar estos datos usando LINQ una vez convertidos.

IronXL admite archivos XLSX sin necesidad de instalar Microsoft Office. Instale la biblioteca .NET a través del Administrador de paquetes NuGet en Visual Studio con el comando Install-Package IronXL.Excel.

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

Cuando solo necesita una parte de los datos de su hoja de Excel, utilice la selección de rango para convertir un rango específico de celdas. Este enfoque es eficaz para archivos grandes de Excel donde solo se necesitan determinadas filas y columnas de la hoja de cálculo de Excel.

using IronXL;
using System;
using System.Data;
class Program
{
    static void Main(string[] args)
    {
        string filepath = "financial_report.xlsx";
        WorkBook workbook = WorkBook.Load(filepath);
        // Get worksheet by sheet name
        string sheetName = "Summary";
        WorkSheet worksheet = workbook.GetWorkSheet(sheetName);
        // Export specific range to new DataTable
        DataTable dt = worksheet["A1:D20"].ToDataTable(true);
        // Process the structured data and return dt reference
        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;
using System.Data;
class Program
{
    static void Main(string[] args)
    {
        string filepath = "financial_report.xlsx";
        WorkBook workbook = WorkBook.Load(filepath);
        // Get worksheet by sheet name
        string sheetName = "Summary";
        WorkSheet worksheet = workbook.GetWorkSheet(sheetName);
        // Export specific range to new DataTable
        DataTable dt = worksheet["A1:D20"].ToDataTable(true);
        // Process the structured data and return dt reference
        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
Imports System.Data

Class Program
    Shared Sub Main(args As String())
        Dim filepath As String = "financial_report.xlsx"
        Dim workbook As WorkBook = WorkBook.Load(filepath)
        ' Get worksheet by sheet name
        Dim sheetName As String = "Summary"
        Dim worksheet As WorkSheet = workbook.GetWorkSheet(sheetName)
        ' Export specific range to new DataTable
        Dim dt As DataTable = worksheet("A1:D20").ToDataTable(True)
        ' Process the structured data and return dt reference
        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
    End Sub
End Class
$vbLabelText   $csharpLabel

Resultado

Cómo exportar Excel a DataTable en C# con IronXL: Imagen 2 - Exportación de un rango de celdas a DataTable

La sintaxis de rango de la hoja de cálculo ["A1:D20"] selecciona celdas desde A1 a D20, luego el método ExportDataTable convierte solo esa sección de la hoja de cálculo de la tabla de datos. Esto es particularmente útil cuando su hoja de cálculo de Excel contiene múltiples regiones de datos o cuando necesita importar datos de un rango específico. La documentación de la clase Range proporciona métodos adicionales para trabajar con selecciones de celdas y operaciones de consulta.

¿Cómo convierto un libro de trabajo completo de Excel en un conjunto de datos?

Para los archivos de Excel que contienen varias hojas, el método ToDataSet convierte todo el libro en un nuevo DataSet donde cada hoja de Excel se convierte en una DataTable independiente. Esto es útil para operaciones de consulta en múltiples hojas de cálculo.

using IronXL;
using System;
using System.Data;
class Program
{
    static void Main(string[] args)
    {
        // Load Excel file with multiple sheets
        WorkBook workbook = WorkBook.Load("multi_sheet.xlsx");
        // Convert entire workbook to new DataSet
        DataSet dataSet = workbook.ToDataSet();
        // Iterate through each DataTable (Excel sheet)
        foreach (DataTable table in dataSet.Tables)
        {
            Console.WriteLine($"Sheet: {table.TableName}");
            Console.WriteLine($"Row count: {table.Rows.Count}");
        }
    }
}
using IronXL;
using System;
using System.Data;
class Program
{
    static void Main(string[] args)
    {
        // Load Excel file with multiple sheets
        WorkBook workbook = WorkBook.Load("multi_sheet.xlsx");
        // Convert entire workbook to new DataSet
        DataSet dataSet = workbook.ToDataSet();
        // Iterate through each DataTable (Excel sheet)
        foreach (DataTable table in dataSet.Tables)
        {
            Console.WriteLine($"Sheet: {table.TableName}");
            Console.WriteLine($"Row count: {table.Rows.Count}");
        }
    }
}
Imports IronXL
Imports System
Imports System.Data

Class Program
    Shared Sub Main(args As String())
        ' Load Excel file with multiple sheets
        Dim workbook As WorkBook = WorkBook.Load("multi_sheet.xlsx")
        ' Convert entire workbook to new DataSet
        Dim dataSet As DataSet = workbook.ToDataSet()
        ' Iterate through each DataTable (Excel sheet)
        For Each table As DataTable In dataSet.Tables
            Console.WriteLine($"Sheet: {table.TableName}")
            Console.WriteLine($"Row count: {table.Rows.Count}")
        Next
    End Sub
End Class
$vbLabelText   $csharpLabel

Salida de consola

Cómo exportar Excel a DataTable en C# con IronXL: Imagen 3: Salida de consola para convertir un archivo de Excel de varias páginas a un conjunto de datos

Este enfoque es ideal cuando necesita consultar datos en varias hojas de trabajo o crear una fuente de datos unificada para informes. Cada DataTable del DataSet conserva el nombre de la hoja original, lo que facilita la referencia a hojas específicas mediante programación. Obtenga más información sobre las operaciones de DataSet en la documentación de IronXL.

¿Cómo puedo exportar DataTable a un archivo Excel?

La conversión de datos de Excel funciona en ambas direcciones. Para exportar el contenido de DataTable a un nuevo archivo de Excel, cree un nuevo libro, rellene las celdas con las filas de DataTable y guarde el archivo. El siguiente ejemplo muestra el proceso:

using IronXL;
using System;
using System.Data;
class Program
{
    static void Main(string[] args)
    {
        // Create sample DataTable with new string column names
        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("Price", typeof(decimal)));
        dt.Rows.Add(1, "Widget", 29.99m);
        dt.Rows.Add(2, "Gadget", 49.99m);
        // Create new workbook and first worksheet
        WorkBook workbook = WorkBook.Create();
        WorkSheet worksheet = workbook.CreateWorkSheet("Products");
        // Write column headers from DataTable columns
        for (int i = 0; i < dt.Columns.Count; i++)
        {
            worksheet.SetCellValue(0, i, dt.Columns[i].ColumnName);
        }
        // Write data rows from DataTable
        for (int rowIndex = 0; rowIndex < dt.Rows.Count; rowIndex++)
        {
            DataRow row = dt.Rows[rowIndex];
            for (int colIndex = 0; colIndex < dt.Columns.Count; colIndex++)
            {
                worksheet.SetCellValue(rowIndex + 1, colIndex, row[colIndex]);
            }
        }
        // Save as XLSX file
        workbook.SaveAs("output.xlsx");
        Console.WriteLine("Export complete!");
    }
}
using IronXL;
using System;
using System.Data;
class Program
{
    static void Main(string[] args)
    {
        // Create sample DataTable with new string column names
        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("Price", typeof(decimal)));
        dt.Rows.Add(1, "Widget", 29.99m);
        dt.Rows.Add(2, "Gadget", 49.99m);
        // Create new workbook and first worksheet
        WorkBook workbook = WorkBook.Create();
        WorkSheet worksheet = workbook.CreateWorkSheet("Products");
        // Write column headers from DataTable columns
        for (int i = 0; i < dt.Columns.Count; i++)
        {
            worksheet.SetCellValue(0, i, dt.Columns[i].ColumnName);
        }
        // Write data rows from DataTable
        for (int rowIndex = 0; rowIndex < dt.Rows.Count; rowIndex++)
        {
            DataRow row = dt.Rows[rowIndex];
            for (int colIndex = 0; colIndex < dt.Columns.Count; colIndex++)
            {
                worksheet.SetCellValue(rowIndex + 1, colIndex, row[colIndex]);
            }
        }
        // Save as XLSX file
        workbook.SaveAs("output.xlsx");
        Console.WriteLine("Export complete!");
    }
}
Imports IronXL
Imports System
Imports System.Data

Class Program
    Shared Sub Main(ByVal args As String())
        ' Create sample DataTable with new string column names
        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("Price", GetType(Decimal)))
        dt.Rows.Add(1, "Widget", 29.99D)
        dt.Rows.Add(2, "Gadget", 49.99D)

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

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

        ' Write data rows from DataTable
        For rowIndex As Integer = 0 To dt.Rows.Count - 1
            Dim row As DataRow = dt.Rows(rowIndex)
            For colIndex As Integer = 0 To dt.Columns.Count - 1
                worksheet.SetCellValue(rowIndex + 1, colIndex, row(colIndex))
            Next
        Next

        ' Save as XLSX file
        workbook.SaveAs("output.xlsx")
        Console.WriteLine("Export complete!")
    End Sub
End Class
$vbLabelText   $csharpLabel

Resultado

Cómo exportar Excel a DataTable en C# con IronXL: Imagen 4: Archivo de Excel generado a partir de nuestro DataTable

Este código crea una nueva DataTable con columnas y filas, luego escribe esos datos de Excel en una hoja de cálculo. El código escribe primero los encabezados de columna y luego itera a través de cada fila de DataRow para completar las celdas. El archivo de salida admite clasificación, filtrado y todas las funciones estándar de Excel.

Se requieren los siguientes espacios de nombres: IronXL, System y System.Data. Para las aplicaciones que utilizan .NET Framework o .NET Core, IronXL se integra perfectamente como una fuente de datos para DataGridView y otros controles de UI a través de patrones de enlace de datos estándar. Puede utilizar DataTable en aplicaciones C# para almacenar datos de manera eficiente y hacer referencia a ellos en todo su código.

Conclusión

IronXL simplifica la conversión de datos de Excel a DataTable en C# con métodos intuitivos como ToDataTable y ToDataSet. Ya sea que necesite leer archivos de Excel en datos estructurados para operaciones de base de datos, exportar contenido de DataTable a nuevos archivos de Excel o importar datos de rangos específicos, esta biblioteca maneja estas tareas de manera eficiente sin dependencias de Microsoft Office.

La biblioteca admite los formatos XLS y XLSX, proporciona métodos para toda la hoja de cálculo o selecciones de rangos específicos y se integra naturalmente con objetos System.Data. Compre una licencia para implementar IronXL en entornos de producción o chatee con nuestro equipo para obtener orientación técnica.

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