Comment importer et exporter DataTable en C
IronXL permet de convertir des classeurs Excel en DataSets à l'aide d'appels de méthode uniques : utilisez LoadWorkSheetsFromDataSet() pour importer des DataSets dans des classeurs et ToDataSet() pour exporter des classeurs au format DataSet avec un mappage automatique des feuilles vers les tableaux.
Un DataSet est une représentation en mémoire de données contenant plusieurs tables, relations et contraintes associées. Utilisé pour travailler avec des données provenant de bases de données, de fichiers XML et d'autres sources. Lors de l'utilisation de fichiers Excel en C#, DataSet offre une structure .NET familière qui s'intègre aux applications pilotées par les données.
Un DataTable représente un tableau unique comportant des lignes et des colonnes à l'intérieur d'un DataSet. IronXL mappe automatiquement chaque feuille de calcul Excel à un DataTable correspondant, en conservant les en-têtes de colonnes et les types de données lors de la conversion.
Guide de démarrage rapide : Exporter le classeur en System.Data.DataSet instantanément
La conversion d'un classeur en DataSet nécessite un seul appel de méthode. Cet exemple exporte l'intégralité de votre classeur — chaque feuille sous la forme DataTable — en utilisant ToDataSet avec une reconnaissance facultative des en-têtes de la première ligne.
-
Installez IronXL avec le Gestionnaire de Packages NuGet
PM > Install-Package IronXL.Excel -
Copiez et exécutez cet extrait de code.
DataSet ds = WorkBook.Create().ToDataSet(useFirstRowAsColumnNames: true); -
Déployez pour tester sur votre environnement de production.
Commencez à utiliser IronXL dans votre projet dès aujourd'hui avec un essai gratuit
Workflow minimal (5 étapes)
- Télécharger la bibliothèque C# pour l'importation et l'exportation sous forme de DataSet
- Préparez le
DataSetà importer dans un objet feuille de calcul - Utilisez la
LoadWorkSheetsFromDataSetméthode pour importer leDataSetdans le classeur - Utilisez la
ToDataSetméthode pour exporter le classeur au formatDataSet - Vérifier le résultat de la conversion
Comment charger un fichier DataSet dans un classeur ?
Utilisez la méthode statique LoadWorkSheetsFromDataSet pour importer un DataSet dans un classeur. Cette méthode nécessite à la fois les objets DataSet et Workbook. Elle accepte également des paramètres optionnels via DataSet. Commencez par créer le classeur à l'aide de la méthode Create. Passez les objets DataSet et workbook à la méthode.
:path=/static-assets/excel/content-code-examples/how-to/export-dataset-datatable-load.cs
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)
Chaque DataTable situé dans le DataSet devient une feuille de calcul distincte. Le nom du tableau devient le nom de la feuille de calcul, ce qui permet de conserver l'organisation des données. Pour les sources de données multiples, combinez cela avec la création de nouvelles feuilles de calcul ou la gestion des feuilles de calcul existantes.
Voici un exemple complet de chargement d'un DataSet contenant plusieurs tables :
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.Co/lumns.Add("ProductID", typeof(int));
productsTable.Co/lumns.Add("ProductName", typeof(string));
productsTable.Co/lumns.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.Co/lumns.Add("SaleID", typeof(int));
salesTable.Co/lumns.Add("ProductID", typeof(int));
salesTable.Co/lumns.Add("Quantity", typeof(int));
salesTable.Co/lumns.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.Co/lumns.Add("ProductID", typeof(int));
productsTable.Co/lumns.Add("ProductName", typeof(string));
productsTable.Co/lumns.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.Co/lumns.Add("SaleID", typeof(int));
salesTable.Co/lumns.Add("ProductID", typeof(int));
salesTable.Co/lumns.Add("Quantity", typeof(int));
salesTable.Co/lumns.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")
Cette approche fonctionne bien lors de l'exportation de données depuis des bases de données SQL ou de la consolidation de données provenant de plusieurs sources au format Excel.
Consultez la section " Comment charger des feuilles de calcul existantes " pour en savoir plus sur l'importation de feuilles de calcul à partir de différents formats de fichiers.
Comment exporter un classeur au format DataSet ?
La méthode ToDataSet convertit le classeur en un System.Data.DataSet, où chaque feuille de calcul devient un System.Data.DataTable. Appelez cette méthode sur le classeur Excel pour le convertir en un objet DataSet. Le paramètre useFirstRowAsColumnNames détermine s'il faut utiliser la première ligne comme noms de colonnes.
:path=/static-assets/excel-content-code-examples/how-to/export-dataset-datatable-export.cs
// CET EXTRAIT DE CODE N'EST PAS DISPONIBLE !
' CET EXTRAIT DE CODE N'EST PAS DISPONIBLE !
IronXL gère automatiquement la conversion des types de données et conserve la structure des feuilles de calcul lors de l'exportation vers des DataSets. Cela facilite l'intégration de données Excel dans des bases de données SQL ou l'utilisation de données dans d'autres applications .NET.
Exemple avancé illustrant l'exportation d'un classeur et le traitement d'un DataSet :
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.Co/lumns.Count}, Rows: {table.Rows.Co/unt}");
// Iterate through columns
foreach (DataColumn column in table.Co/lumns)
{
Console.WriteLine($" Column: {column.Co/lumnName} ({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.Co/lumns)
{
Console.WriteLine($" {col.Co/lumnName}: {row[col]}");
}
}
}
// You can also export specific worksheets as DataTables
WorkSheet specificSheet = workBook.WorkSheets["Q1Sales"];
DataTable q1Data = specificSheet.ToDataTable(useFirstRowAsColumnNames: true);
// Use the DataTable with other .NET components
// For example, bind to a DataGridView or save to database
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.Co/lumns.Count}, Rows: {table.Rows.Co/unt}");
// Iterate through columns
foreach (DataColumn column in table.Co/lumns)
{
Console.WriteLine($" Column: {column.Co/lumnName} ({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.Co/lumns)
{
Console.WriteLine($" {col.Co/lumnName}: {row[col]}");
}
}
}
// You can also export specific worksheets as DataTables
WorkSheet specificSheet = workBook.WorkSheets["Q1Sales"];
DataTable q1Data = specificSheet.ToDataTable(useFirstRowAsColumnNames: true);
// Use the DataTable with other .NET components
// For example, bind to a DataGridView or save to database
Imports 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.WorkSheets("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 database
Le fichier DataSet exporté conserve les relations et les contraintes définies dans Excel, ce qui est idéal pour travailler avec des structures de données Excel complexes sans dépendances Excel Interop.
Fonctionnalités supplémentaires de DataSet/DataTable
IronXL offre des fonctionnalités avancées lors de l'utilisation de DataSet et DataTable :
Gestion des types de données
IronXL effectue un mappage intelligent des types de données lors de la conversion Excel-DataSet. Les cellules numériques deviennent des types numériques appropriés (Int32, Double, Decimal), les cellules de date deviennent des objets DateTime, les cellules de texte deviennent des String. Personnalisez ce document en définissant les formats des données des cellules avant la conversion.
Optimisation des performances
IronXL optimise l'utilisation de la mémoire et la vitesse de traitement pour les grands ensembles de données. La bibliothèque diffuse efficacement les données plutôt que de tout charger en mémoire. Convient aux applications d'Enterprise traitant de grands volumes de données.
Intégration avec d'autres fonctionnalités
Les fonctionnalités DataSet/DataTables s'intègrent aux autres fonctionnalités d'IronXL :
- Appliquer les formules et les calculs avant l'exportation vers un
DataSet - Utilisez la mise en forme conditionnelle pour mettre en évidence les données avant la conversion
- À combiner avec la création de graphiques pour un reporting visuel
- Prise en charge de la sérialisation personnalisée à l'aide de
int - Inclure les règles de validation des données via
decimal - Traiter les valeurs manquantes avec
double - Gérer les métadonnées des feuilles de calcul via
DateTime - Conserver les types de mise en forme des cellules à l'aide de
string
Consultez la page Comment économiser ou exporter des feuilles de calcul pour en savoir plus sur l'exportation de feuilles de calcul vers différents formats de fichiers.
Questions Fréquemment Posées
Comment convertir un classeur Excel en DataSet en C# ?
Avec IronXL, vous pouvez convertir un classeur Excel en un ensemble de données à l'aide de la méthode ToDataSet(). Appelez simplement WorkBook.ToDataSet(useFirstRowAsColumnNames : true) pour exporter votre classeur entier où chaque feuille devient une DataTable dans le DataSet résultant.
Puis-je importer un ensemble de données dans un classeur Excel par programme ?
Oui, IronXL fournit la méthode LoadWorkSheetsFromDataSet() pour importer un ensemble de données dans un classeur. Créez un classeur en utilisant WorkBook.Create(), puis passez l'ensemble de données et le classeur à cette méthode statique. Chaque tableau de données devient une feuille de calcul distincte.
Qu'advient-il des noms des tableaux de données lors de l'importation dans Excel ?
Lorsque vous utilisez la méthode LoadWorkSheetsFromDataSet() d'IronXL, chaque nom de table de données devient automatiquement le nom de la feuille de calcul dans Excel, ce qui permet de conserver l'organisation de vos données et d'identifier facilement les différentes sources de données.
La bibliothèque préserve-t-elle les en-têtes de colonnes lors de la conversion des jeux de données ?
Oui, IronXL préserve les en-têtes de colonnes et les types de données lors de la conversion entre Excel et les DataSets. Lors de l'utilisation de ToDataSet() avec useFirstRowAsColumnNames réglé sur true, la première ligne de chaque feuille de calcul est reconnue comme en-tête de colonne.
Comment les tableaux multiples sont-ils gérés lors de la conversion entre Excel et DataSets ?
IronXL fait automatiquement correspondre chaque feuille de calcul Excel à une DataTable correspondante lors de la conversion en DataSet, et vice versa. Lors de l'importation d'un DataSet avec plusieurs tables, chaque DataTable crée une feuille de travail séparée dans le classeur.
Quel est le code minimal nécessaire pour exporter Excel vers DataSet ?
Le code minimal pour exporter un classeur Excel vers un DataSet à l'aide d'IronXL.Excel ne comporte qu'une seule ligne : DataSet ds = WorkBook.Create().ToDataSet(useFirstRowAsColumnNames : true) ; Ceci convertit votre classeur entier avec un mappage automatique de la feuille à la table.

