Cómo importar y exportar DataSet/DataTable en C#
IronXL convierte entre libros de Excel y DataSet con llamadas a métodos individuales: use LoadWorkSheetsFromDataSet() para importar DataSet en libros de trabajo y ToDataSet() para exportar libros de trabajo como DataSet con mapeo automático de hoja a tabla.
Un DataSet es una representación en memoria de datos que contiene múltiples tablas relacionadas, relaciones y restricciones. Se utiliza para trabajar con datos de bases de datos, XML y otras fuentes. Cuando se trabaja con archivos Excel en C#, los DataSet proporcionan una estructura familiar de .NET que se integra con aplicaciones impulsadas por datos.
Un DataTable representa una sola tabla con filas y columnas dentro de un DataSet. IronXL mapea automáticamente cada hoja de Excel a un DataTable correspondiente, preservando los encabezados de columna y tipos de datos durante la conversión.
System.Data.DataSet al instante
Convertir un libro de trabajo en un DataSet requiere una llamada a un método. Este ejemplo exporta todo su libro de trabajo, cada hoja como un DataTable, utilizando ToDataSet con reconocimiento opcional de encabezados de la primera fila.
-
1Instalar IronXL con NuGet Package Manager
-
2Copie y ejecute este fragmento de código.
DataSet ds = WorkBook.Create().ToDataSet(useFirstRowAsColumnNames: true);Dim ds As DataSet = WorkBook.Create().ToDataSet(useFirstRowAsColumnNames:=True)Dim ds As DataSet = WorkBook.Create().ToDataSet(useFirstRowAsColumnNames:=True) -
3Despliegue para probar en su entorno real
Empiece a usar IronXL en su proyecto hoy con una prueba gratuita
Flujo de trabajo mínimo (5 pasos)
- Descargar la biblioteca de C# para importar y exportar como un DataSet
- Preparar el
DataSetpara importarlo a un objeto de hoja de cálculo - Utilice el método
LoadWorkSheetsFromDataSetpara importar elDataSetal libro de trabajo - Utilice el método
ToDataSetpara exportar el libro de trabajo como unDataSet - Verifique el resultado de la conversión
¿Cómo cargo un DataSet en un libro de trabajo?
Use el método estático LoadWorkSheetsFromDataSet para importar un DataSet en un libro de trabajo. Este método requiere objetos DataSet y Workbook. También acepta configuraciones opcionales a través de DataSet. Cree primero el libro de trabajo usando el método Create. Pase el objeto DataSet y el objeto workbook al método.
using IronXL;
using System.Data;
// Create dataset
DataSet dataSet = new DataSet();
// Create workbook
WorkBook workBook = WorkBook.Create();
// Load DataSet to workBook
WorkBook.LoadWorkSheetsFromDataSet(dataSet, workBook);using IronXL;
using System.Data;
// Create dataset
DataSet dataSet = new DataSet();
// Create workbook
WorkBook workBook = WorkBook.Create();
// Load DataSet to workBook
WorkBook.LoadWorkSheetsFromDataSet(dataSet, workBook);Imports IronXL
Imports System.Data
' Create dataset
Private dataSet As New DataSet()
' Create workbook
Private workBook As WorkBook = WorkBook.Create()
' Load DataSet to workBook
WorkBook.LoadWorkSheetsFromDataSet(dataSet, workBook)Imports IronXL
Imports System.Data
' Create dataset
Private dataSet As New DataSet()
' Create workbook
Private workBook As WorkBook = WorkBook.Create()
' Load DataSet to workBook
WorkBook.LoadWorkSheetsFromDataSet(dataSet, workBook)Cada DataTable dentro del DataSet se convierte en una hoja de cálculo separada. El nombre de la tabla se convierte en el nombre de la hoja de cálculo, manteniendo la organización de los datos. Para múltiples fuentes de datos, combine esto con crear nuevas hojas de cálculo o gestionar hojas de cálculo existentes.
Aquí hay un ejemplo completo cargando un DataSet con múltiples tablas:
using IronXL;
using System.Data;
// Create a DataSet with multiple tables
DataSet salesData = new DataSet("CompanySales");
// Create and populate a products table
DataTable productsTable = new DataTable("Products");
productsTable.Columns.Add("ProductID", typeof(int));
productsTable.Columns.Add("ProductName", typeof(string));
productsTable.Columns.Add("Price", typeof(decimal));
// Add sample data
productsTable.Rows.Add(1, "Laptop", 999.99m);
productsTable.Rows.Add(2, "Mouse", 19.99m);
productsTable.Rows.Add(3, "Keyboard", 49.99m);
// Create and populate a sales table
DataTable salesTable = new DataTable("Sales");
salesTable.Columns.Add("SaleID", typeof(int));
salesTable.Columns.Add("ProductID", typeof(int));
salesTable.Columns.Add("Quantity", typeof(int));
salesTable.Columns.Add("Date", typeof(DateTime));
// Add sample sales data
salesTable.Rows.Add(1, 1, 5, DateTime.Now);
salesTable.Rows.Add(2, 2, 25, DateTime.Now.AddDays(-1));
salesTable.Rows.Add(3, 3, 10, DateTime.Now.AddDays(-2));
// Add tables to DataSet
salesData.Tables.Add(productsTable);
salesData.Tables.Add(salesTable);
// Create workbook and load DataSet
WorkBook workBook = WorkBook.Create();
WorkBook.LoadWorkSheetsFromDataSet(salesData, workBook);
// Save the workbook with all imported data
workBook.SaveAs("SalesReport.xlsx");using IronXL;
using System.Data;
// Create a DataSet with multiple tables
DataSet salesData = new DataSet("CompanySales");
// Create and populate a products table
DataTable productsTable = new DataTable("Products");
productsTable.Columns.Add("ProductID", typeof(int));
productsTable.Columns.Add("ProductName", typeof(string));
productsTable.Columns.Add("Price", typeof(decimal));
// Add sample data
productsTable.Rows.Add(1, "Laptop", 999.99m);
productsTable.Rows.Add(2, "Mouse", 19.99m);
productsTable.Rows.Add(3, "Keyboard", 49.99m);
// Create and populate a sales table
DataTable salesTable = new DataTable("Sales");
salesTable.Columns.Add("SaleID", typeof(int));
salesTable.Columns.Add("ProductID", typeof(int));
salesTable.Columns.Add("Quantity", typeof(int));
salesTable.Columns.Add("Date", typeof(DateTime));
// Add sample sales data
salesTable.Rows.Add(1, 1, 5, DateTime.Now);
salesTable.Rows.Add(2, 2, 25, DateTime.Now.AddDays(-1));
salesTable.Rows.Add(3, 3, 10, DateTime.Now.AddDays(-2));
// Add tables to DataSet
salesData.Tables.Add(productsTable);
salesData.Tables.Add(salesTable);
// Create workbook and load DataSet
WorkBook workBook = WorkBook.Create();
WorkBook.LoadWorkSheetsFromDataSet(salesData, workBook);
// Save the workbook with all imported data
workBook.SaveAs("SalesReport.xlsx");Imports IronXL
Imports System.Data
' Create a DataSet with multiple tables
Dim salesData As New DataSet("CompanySales")
' Create and populate a products table
Dim productsTable As New DataTable("Products")
productsTable.Columns.Add("ProductID", GetType(Integer))
productsTable.Columns.Add("ProductName", GetType(String))
productsTable.Columns.Add("Price", GetType(Decimal))
' Add sample data
productsTable.Rows.Add(1, "Laptop", 999.99D)
productsTable.Rows.Add(2, "Mouse", 19.99D)
productsTable.Rows.Add(3, "Keyboard", 49.99D)
' Create and populate a sales table
Dim salesTable As New DataTable("Sales")
salesTable.Columns.Add("SaleID", GetType(Integer))
salesTable.Columns.Add("ProductID", GetType(Integer))
salesTable.Columns.Add("Quantity", GetType(Integer))
salesTable.Columns.Add("Date", GetType(DateTime))
' Add sample sales data
salesTable.Rows.Add(1, 1, 5, DateTime.Now)
salesTable.Rows.Add(2, 2, 25, DateTime.Now.AddDays(-1))
salesTable.Rows.Add(3, 3, 10, DateTime.Now.AddDays(-2))
' Add tables to DataSet
salesData.Tables.Add(productsTable)
salesData.Tables.Add(salesTable)
' Create workbook and load DataSet
Dim workBook As WorkBook = WorkBook.Create()
WorkBook.LoadWorkSheetsFromDataSet(salesData, workBook)
' Save the workbook with all imported data
workBook.SaveAs("SalesReport.xlsx")Imports IronXL
Imports System.Data
' Create a DataSet with multiple tables
Dim salesData As New DataSet("CompanySales")
' Create and populate a products table
Dim productsTable As New DataTable("Products")
productsTable.Columns.Add("ProductID", GetType(Integer))
productsTable.Columns.Add("ProductName", GetType(String))
productsTable.Columns.Add("Price", GetType(Decimal))
' Add sample data
productsTable.Rows.Add(1, "Laptop", 999.99D)
productsTable.Rows.Add(2, "Mouse", 19.99D)
productsTable.Rows.Add(3, "Keyboard", 49.99D)
' Create and populate a sales table
Dim salesTable As New DataTable("Sales")
salesTable.Columns.Add("SaleID", GetType(Integer))
salesTable.Columns.Add("ProductID", GetType(Integer))
salesTable.Columns.Add("Quantity", GetType(Integer))
salesTable.Columns.Add("Date", GetType(DateTime))
' Add sample sales data
salesTable.Rows.Add(1, 1, 5, DateTime.Now)
salesTable.Rows.Add(2, 2, 25, DateTime.Now.AddDays(-1))
salesTable.Rows.Add(3, 3, 10, DateTime.Now.AddDays(-2))
' Add tables to DataSet
salesData.Tables.Add(productsTable)
salesData.Tables.Add(salesTable)
' Create workbook and load DataSet
Dim workBook As WorkBook = WorkBook.Create()
WorkBook.LoadWorkSheetsFromDataSet(salesData, workBook)
' Save the workbook with all imported data
workBook.SaveAs("SalesReport.xlsx")Este enfoque funciona bien al exportar datos de bases de datos SQL o consolidar datos de múltiples fuentes en formato Excel.
Visite Cómo cargar hojas de cálculo existentes para aprender sobre la importación de hojas de cálculo desde varios formatos de archivo.
¿Cómo exporto un libro de trabajo como un DataSet?
El método ToDataSet convierte el libro de trabajo a un System.Data.DataSet, donde cada hoja de cálculo se convierte en un System.Data.DataTable. Llame a este método en el libro de Excel para convertirlo en un objeto DataSet. El parámetro useFirstRowAsColumnNames determina si se usa la primera fila como nombres de columna.
using IronXL;
using System.Data;
// Create new Excel WorkBook document
WorkBook workBook = WorkBook.Create();
// Create a blank WorkSheet
WorkSheet workSheet = workBook.CreateWorkSheet("new_sheet");
// Export as DataSet
DataSet dataSet = workBook.ToDataSet();using IronXL;
using System.Data;
// Create new Excel WorkBook document
WorkBook workBook = WorkBook.Create();
// Create a blank WorkSheet
WorkSheet workSheet = workBook.CreateWorkSheet("new_sheet");
// Export as DataSet
DataSet dataSet = workBook.ToDataSet();Imports IronXL
Imports System.Data
' Create new Excel WorkBook document
Private workBook As WorkBook = WorkBook.Create()
' Create a blank WorkSheet
Private workSheet As WorkSheet = workBook.CreateWorkSheet("new_sheet")
' Export as DataSet
Private dataSet As DataSet = workBook.ToDataSet()Imports IronXL
Imports System.Data
' Create new Excel WorkBook document
Private workBook As WorkBook = WorkBook.Create()
' Create a blank WorkSheet
Private workSheet As WorkSheet = workBook.CreateWorkSheet("new_sheet")
' Export as DataSet
Private dataSet As DataSet = workBook.ToDataSet()IronXL maneja automáticamente la conversión de tipos de datos y mantiene la estructura de la hoja de cálculo al exportar a DataSets. Esto ayuda al integrar datos de Excel con bases de datos SQL o al usar datos en otras aplicaciones .NET.
Ejemplo avanzado de exportación de libros de trabajo y procesamiento de DataSets:
using IronXL;
using System;
using System.Data;
// Load an existing Excel file
WorkBook workBook = WorkBook.Load("FinancialData.xlsx");
// Export to DataSet with column headers from first row
DataSet financialDataSet = workBook.ToDataSet(useFirstRowAsColumnNames: true);
// Process each DataTable in the DataSet
foreach (DataTable table in financialDataSet.Tables)
{
Console.WriteLine($"Processing table: {table.TableName}");
Console.WriteLine($"Columns: {table.Columns.Count}, Rows: {table.Rows.Count}");
// Iterate through columns
foreach (DataColumn column in table.Columns)
{
Console.WriteLine($" Column: {column.ColumnName} ({column.DataType})");
}
// Process first 5 rows as example
int rowCount = 0;
foreach (DataRow row in table.Rows)
{
if (rowCount++ >= 5) break;
// Access data by column name
foreach (DataColumn col in table.Columns)
{
Console.WriteLine($" {col.ColumnName}: {row[col]}");
}
}
}
// You can also export specific worksheets as DataTables
WorkSheet specificSheet = workBook.GetWorkSheet("Q1Sales");
DataTable q1Data = specificSheet.ToDataTable(useFirstRowAsColumnNames: true);
// Use the DataTable with other .NET components
// For example, bind to a DataGridView or save to databaseusing IronXL;
using System;
using System.Data;
// Load an existing Excel file
WorkBook workBook = WorkBook.Load("FinancialData.xlsx");
// Export to DataSet with column headers from first row
DataSet financialDataSet = workBook.ToDataSet(useFirstRowAsColumnNames: true);
// Process each DataTable in the DataSet
foreach (DataTable table in financialDataSet.Tables)
{
Console.WriteLine($"Processing table: {table.TableName}");
Console.WriteLine($"Columns: {table.Columns.Count}, Rows: {table.Rows.Count}");
// Iterate through columns
foreach (DataColumn column in table.Columns)
{
Console.WriteLine($" Column: {column.ColumnName} ({column.DataType})");
}
// Process first 5 rows as example
int rowCount = 0;
foreach (DataRow row in table.Rows)
{
if (rowCount++ >= 5) break;
// Access data by column name
foreach (DataColumn col in table.Columns)
{
Console.WriteLine($" {col.ColumnName}: {row[col]}");
}
}
}
// You can also export specific worksheets as DataTables
WorkSheet specificSheet = workBook.GetWorkSheet("Q1Sales");
DataTable q1Data = specificSheet.ToDataTable(useFirstRowAsColumnNames: true);
// Use the DataTable with other .NET components
// For example, bind to a DataGridView or save to databaseImports IronXL
Imports System
Imports System.Data
' Load an existing Excel file
Dim workBook As WorkBook = WorkBook.Load("FinancialData.xlsx")
' Export to DataSet with column headers from first row
Dim financialDataSet As DataSet = workBook.ToDataSet(useFirstRowAsColumnNames:=True)
' Process each DataTable in the DataSet
For Each table As DataTable In financialDataSet.Tables
Console.WriteLine($"Processing table: {table.TableName}")
Console.WriteLine($"Columns: {table.Columns.Count}, Rows: {table.Rows.Count}")
' Iterate through columns
For Each column As DataColumn In table.Columns
Console.WriteLine($" Column: {column.ColumnName} ({column.DataType})")
Next
' Process first 5 rows as example
Dim rowCount As Integer = 0
For Each row As DataRow In table.Rows
If rowCount >= 5 Then Exit For
rowCount += 1
' Access data by column name
For Each col As DataColumn In table.Columns
Console.WriteLine($" {col.ColumnName}: {row(col)}")
Next
Next
Next
' You can also export specific worksheets as DataTables
Dim specificSheet As WorkSheet = workBook.GetWorkSheet("Q1Sales")
Dim q1Data As DataTable = specificSheet.ToDataTable(useFirstRowAsColumnNames:=True)
' Use the DataTable with other .NET components
' For example, bind to a DataGridView or save to databaseImports IronXL
Imports System
Imports System.Data
' Load an existing Excel file
Dim workBook As WorkBook = WorkBook.Load("FinancialData.xlsx")
' Export to DataSet with column headers from first row
Dim financialDataSet As DataSet = workBook.ToDataSet(useFirstRowAsColumnNames:=True)
' Process each DataTable in the DataSet
For Each table As DataTable In financialDataSet.Tables
Console.WriteLine($"Processing table: {table.TableName}")
Console.WriteLine($"Columns: {table.Columns.Count}, Rows: {table.Rows.Count}")
' Iterate through columns
For Each column As DataColumn In table.Columns
Console.WriteLine($" Column: {column.ColumnName} ({column.DataType})")
Next
' Process first 5 rows as example
Dim rowCount As Integer = 0
For Each row As DataRow In table.Rows
If rowCount >= 5 Then Exit For
rowCount += 1
' Access data by column name
For Each col As DataColumn In table.Columns
Console.WriteLine($" {col.ColumnName}: {row(col)}")
Next
Next
Next
' You can also export specific worksheets as DataTables
Dim specificSheet As WorkSheet = workBook.GetWorkSheet("Q1Sales")
Dim q1Data As DataTable = specificSheet.ToDataTable(useFirstRowAsColumnNames:=True)
' Use the DataTable with other .NET components
' For example, bind to a DataGridView or save to databaseEl DataSet exportado mantiene relaciones y restricciones definidas en Excel, perfecto para trabajar con estructuras de datos complejas de Excel sin dependencias de Interop de Excel.
Características adicionales de DataSet/DataTable
IronXL proporciona características avanzadas al trabajar con DataSet y DataTable:
Manejo de tipos de datos
IronXL asigna de forma inteligente los tipos de datos durante la conversión Excel-DataSet. Las celdas numéricas se convierten en tipos numéricos apropiados (Int32, Double, Decimal), las celdas de fecha se convierten en objetos DateTime, las celdas de texto se convierten en Strings. Personalice esto configurando formatos de datos de celda antes de la conversión.
Optimización del rendimiento
IronXL optimiza el uso de memoria y la velocidad de procesamiento de grandes conjuntos de datos. La biblioteca transmite datos de forma eficiente en lugar de cargar todo en la memoria. Adecuado para aplicaciones empresariales que procesan grandes volúmenes de datos.
Integración con otras funciones
La funcionalidad DataSet/DataTable se integra con otras características de IronXL:
- Aplique fórmulas y cálculos antes de exportar a un
DataSet - Utilice formato condicional para resaltar datos antes de la conversión
- Combine con creación de gráficos para informes visuales
- Soporte para serialización personalizada usando
int - Incluya reglas de validación de datos mediante
decimal - Maneje valores faltantes con
double - Gestione metadatos de la hoja de cálculo a través de
DateTime - Preserve los tipos de formato de celda usando
string
Visite Cómo guardar o exportar hojas de cálculo para aprender sobre la exportación de hojas de cálculo a varios formatos de archivo.
Preguntas frecuentes
¿Cómo puedo importar un DataSet en un libro de Excel usando C#?
Puede usar el método LoadWorkSheetsFromDataSet de IronXL para importar un DataSet en un libro de Excel en C#. Esto implica crear objetos de DataSet y Workbook y pasarlos al método. Cada DataTable en el DataSet se convierte en una hoja de trabajo en el libro.
¿Cuál es el proceso para exportar un libro de Excel como un DataSet en C#?
Para exportar un libro de Excel como un DataSet usando C#, IronXL ofrece el método ToDataSet. Este método convierte cada hoja de trabajo en un DataTable y devuelve el DataSet, asegurando que se preserven los tipos de datos y las estructuras.
¿Cuáles son los beneficios de usar IronXL para operaciones con DataSet y DataTable?
IronXL proporciona una conversión fluida entre archivos de Excel y DataSets/DataTables con mapeo automático y conversión de tipos. Optimiza el rendimiento para grandes conjuntos de datos e integra con otras características como fórmulas, formato condicional y gráficos.
¿Puede IronXL manejar diferentes tipos de datos durante la conversión de Excel?
Sí, IronXL mapea inteligentemente los tipos de datos durante la conversión de Excel a DataSet. Las celdas numéricas se convierten en Int32, Double o Decimal, las celdas de fecha en objetos DateTime y las celdas de texto en Strings.
¿Es posible usar la integración de Excel DataSet con bases de datos SQL en C#?
Efectivamente, IronXL facilita esto permitiendo la exportación de datos de Excel a DataSets, que luego pueden usarse con bases de datos SQL. Esto es útil para la manipulación e integración de datos en aplicaciones .NET.
¿Cómo puedo aplicar fórmulas y cálculos antes de exportar un libro de trabajo a un DataSet?
Con IronXL, puede editar fórmulas y aplicar cálculos a su libro de Excel antes de usar el método ToDataSet. Esto asegura que sus cálculos estén incluidos en el DataSet exportado.
¿Qué optimizaciones de rendimiento incluye IronXL para manejar grandes conjuntos de datos?
IronXL está optimizado para alto rendimiento, utilizando técnicas eficientes de transmisión para gestionar la memoria y la velocidad al trabajar con grandes volúmenes de datos, haciéndolo adecuado para aplicaciones de nivel empresarial.
¿Cómo mantiene IronXL la estructura de datos al convertir un libro de trabajo a un DataSet?
IronXL mantiene la estructura organizativa convirtiendo cada hoja de trabajo en un DataTable. Las relaciones, restricciones, encabezados de columna y tipos de datos se preservan durante la conversión, permitiendo interacciones de datos complejas.
¿Puedo usar IronXL para crear informes visuales usando datos de Excel?
Sí, IronXL admite la creación de gráficos e informes visuales integrando su funcionalidad de DataSet/DataTable con sus características de creación de gráficos, permitiendo una visualización de datos comprensiva directamente desde datos de Excel.
¿IronXL admite la integración de serialización personalizada en operaciones de DataSet?
IronXL permite la serialización personalizada, lo que puede mejorar la manipulación de DataSet y DataTable de acuerdo a requisitos específicos de la aplicación, proporcionando mayor flexibilidad en el manejo de datos serializados.
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.