Importer des données dans la feuille de calcul

Comment importer des données dans une feuille de calcul

Lorsque vous ouvrez un fichier Excel avec Aspose.Cells, toutes les données du fichier sont automatiquement importées. Aspose.Cells peut également importer des données à partir d’autres sources de données.

Aspose.Cells fournit une classe Workbook qui représente un fichier Microsoft Excel. La classe Workbook contient une collection Worksheets qui permet d’accéder à chaque feuille de calcul dans un fichier Excel. Une feuille de calcul est représentée par la classe Worksheet. La classe Worksheet fournit une collection Cells. La collection Cells fournit des méthodes utiles pour importer des données à partir de différentes sources de données. Cet article explique comment ces méthodes peuvent être utilisées.

Comment importer des données dans Excel avec l’interface ICellsDataTable

Implémentez ICellsDataTable pour encapsuler vos diverses sources de données, puis utilisez Cells.ImportData() pour importer des données dans une feuille de calcul Excel.

Code d’exemple

//Init data source
CustomerList customers = new CustomerList();
customers.Add(new Customer("Thomas Hardy", "120 Hanover Sq., London"));
customers.Add(new Customer("Paolo Accorti", "Via Monte Bianco 34, Torino"));
//Create a new file.
var wb = new Workbook();
ImportTableOptions options = new ImportTableOptions();
options.IsFieldNameShown = true;
//Import ICellsDataTable with options
wb.Worksheets[0].Cells.ImportData(new CustomerDataSource(customers), 0, 0, options);
wb.Save("ICellsDataTable.xlsx");

L’implémentation des classes CustomerDataSource, Customer et CustomerList est donnée ci-dessous

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-.NET
public class CustomerDataSource : ICellsDataTable
{
public CustomerDataSource(CustomerList customers)
{
this.m_DataSource = customers;
this.m_Properties = customers[0].GetType().GetProperties();
this.m_Columns = new string[this.m_Properties.Length];
this.m_PropHash = new Hashtable(this.m_Properties.Length);
for (int i = 0; i < m_Properties.Length; i++)
{
this.m_Columns[i] = m_Properties[i].Name;
this.m_PropHash.Add(m_Properties[i].Name, m_Properties[i]);
}
this.m_IEnumerator = this.m_DataSource.GetEnumerator();
}
internal string[] m_Columns;
internal ICollection m_DataSource;
private Hashtable m_PropHash;
private IEnumerator m_IEnumerator;
private System.Reflection.PropertyInfo[] m_Properties;
public string[] Columns
{
get
{
return this.m_Columns;
}
}
public int Count
{
get
{
return this.m_DataSource.Count;
}
}
public void BeforeFirst()
{
this.m_IEnumerator = this.m_DataSource.GetEnumerator();
}
public object this[int index]
{
get
{
return this.m_Properties[index].GetValue(this.m_IEnumerator.Current, null);
}
}
public object this[string columnName]
{
get
{
return ((System.Reflection.PropertyInfo)this.m_PropHash[columnName]).GetValue(this.m_IEnumerator.Current, null);
}
}
public bool Next()
{
if (this.m_IEnumerator == null)
return false;
return this.m_IEnumerator.MoveNext();
}
}
public class Customer
{
public Customer(string aFullName, string anAddress)
{
FullName = aFullName;
Address = anAddress;
}
public string FullName { get; set; }
public string Address { get; set; }
}
public class CustomerList : ArrayList
{
public new Customer this[int index]
{
get { return (Customer)base[index]; }
set { base[index] = value; }
}
}

Comment importer des données dans Excel à partir d’un tableau

Pour importer des données dans une feuille de calcul à partir d’un tableau, appelez la méthode ImportArray de la collection Cells. Il existe de nombreuses versions surchargées de la méthode ImportArray mais une surcharge typique prend les paramètres suivants:

  • Tableau, l’objet tableau à partir duquel vous importez le contenu.
  • Numéro de ligne, le numéro de ligne de la première cellule dans laquelle les données seront importées.
  • Numéro de colonne, le numéro de colonne de la première cellule dans laquelle les données seront importées.
  • Est vertical, une valeur booléenne qui spécifie si les données doivent être importées verticalement ou horizontalement.
// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-.NET
// The path to the documents directory.
string dataDir = RunExamples.GetDataDir(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
// Create directory if it is not already present.
bool IsExists = System.IO.Directory.Exists(dataDir);
if (!IsExists)
System.IO.Directory.CreateDirectory(dataDir);
// Instantiating a Workbook object
Workbook workbook = new Workbook();
// Obtaining the reference of the worksheet
Worksheet worksheet = workbook.Worksheets[0];
// Creating an array containing names as string values
string[] names = new string[] { "laurence chen", "roman korchagin", "kyle huang" };
// Importing the array of names to 1st row and first column vertically
worksheet.Cells.ImportArray(names, 0, 0, true);
// Saving the Excel file
workbook.Save(dataDir + "DataImport.out.xls");

Comment importer des données dans Excel à partir d’un ArrayList

Pour importer des données d’un ArrayList dans des feuilles de calcul, appelez la méthode ImportArrayList de la collection Cells. La méthode ImportArray prend les paramètres suivants:

  • Liste de tableaux, représente l’objet ArrayList que vous importez.
  • Numéro de ligne, représente le numéro de ligne de la première cellule dans laquelle les données seront importées.
  • Numéro de colonne, représente le numéro de colonne de la première cellule dans laquelle les données seront importées.
  • Est vertical, une valeur booléenne qui spécifie si les données doivent être importées verticalement ou horizontalement.
// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-.NET
// The path to the documents directory.
string dataDir = RunExamples.GetDataDir(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
// Create directory if it is not already present.
bool IsExists = System.IO.Directory.Exists(dataDir);
if (!IsExists)
System.IO.Directory.CreateDirectory(dataDir);
// Instantiating a Workbook object
Workbook workbook = new Workbook();
// Obtaining the reference of the worksheet
Worksheet worksheet = workbook.Worksheets[0];
// Instantiating an ArrayList object
ArrayList list = new ArrayList();
// Add few names to the list as string values
list.Add("laurence chen");
list.Add("roman korchagin");
list.Add("kyle huang");
list.Add("tommy wang");
// Importing the contents of ArrayList to 1st row and first column vertically
worksheet.Cells.ImportArrayList(list, 0, 0, true);
// Saving the Excel file
workbook.Save(dataDir + "DataImport.out.xls");

Comment importer des données dans Excel à partir d’objets personnalisés

Pour importer des données à partir d’une collection d’objets dans une feuille de calcul, utilisez ImportCustomObjects. Fournissez une liste de colonnes/propriétés à la méthode pour afficher la liste d’objets souhaitée.

private void TestImportingFromCustomObject()
{
//Examples-CSharp-Data-Handling-Importing-ImportingFromCustomObject-1.cs
// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-.NET
// The path to the documents directory.
string dataDir = RunExamples.GetDataDir(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
// Create directory if it is not already present.
bool IsExists = System.IO.Directory.Exists(dataDir);
if (!IsExists)
System.IO.Directory.CreateDirectory(dataDir);
// Instantiate a new Workbook
Workbook book = new Workbook();
Worksheet sheet = book.Worksheets[0];
// Define List
List<Person> list = new List<Person>();
list.Add(new Person("Mike", 25));
list.Add(new Person("Steve", 30));
list.Add(new Person("Billy", 35));
ImportTableOptions imp = new ImportTableOptions();
imp.InsertRows = true;
// We pick a few columns not all to import to the worksheet
// We pick a few columns not all to import to the worksheet
sheet.Cells.ImportCustomObjects((System.Collections.ICollection)list,
new string[] { "Name", "Age" },
true,
0,
0,
list.Count,
true,
"dd/mm/yyyy",
false);
// Auto-fit all the columns
book.Worksheets[0].AutoFitColumns();
// Save the Excel file
book.Save(dataDir + "ImportedCustomObjects.out.xls");
}
class Person
{
int _age;
string _name;
public int Age
{
get
{
return _age;
}
set
{
_age = value;
}
}
public string Name
{
get
{
return _name;
}
set
{
_name = value;
}
}
public Person(string name, int age)
{
Age = age;
Name = name;
}
}

Comment importer des données dans Excel à partir d’objets personnalisés et vérifier la zone fusionnée

Pour importer des données à partir d’une collection d’objets dans une feuille de calcul contenant des cellules fusionnées, utilisez la propriété ImportTableOptions.CheckMergedCells. Si le modèle Excel comporte des cellules fusionnées, définissez la valeur de la propriété ImportTableOptions.CheckMergedCells sur vrai. Transmettez l’objet ImportTableOptions avec la liste de colonnes/propriétés à la méthode pour afficher la liste d’objets souhaitée. L’exemple de code suivant montre l’utilisation de la propriété ImportTableOptions.CheckMergedCells pour importer des données à partir d’objets personnalisés dans des cellules fusionnées. Veuillez consulter le fichier Excel source (90112033.xlsx) et le fichier Excel de sortie (90112034.xlsx) pour référence.

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-.NET
public class ImportCustomObjectsToMergedArea
{
public static void Run()
{
//Source directory
string sourceDir = RunExamples.Get_SourceDirectory();
//Output directory
string outputDir = RunExamples.Get_OutputDirectory();
Workbook workbook = new Workbook(sourceDir + "sampleMergedTemplate.xlsx");
List<Product> productList = new List<Product>();
//Creating collection of test items
for (int i = 0; i < 3; i++)
{
Product product = new Product
{
ProductId = i,
ProductName = "Test Product - " + i
};
productList.Add(product);
}
ImportTableOptions tableOptions = new ImportTableOptions();
tableOptions.CheckMergedCells = true;
tableOptions.IsFieldNameShown = false;
//Insert data to excel template
workbook.Worksheets[0].Cells.ImportCustomObjects((ICollection)productList, 1, 0, tableOptions);
workbook.Save(outputDir + "sampleMergedTemplate_out.xlsx", SaveFormat.Xlsx);
Console.WriteLine("ImportCustomObectsToMergedArea executed successfully.\r\n");
}
}
public class Product
{
public int ProductId { get; set; }
public string ProductName { get; set; }
}

Comment importer des données dans Excel à partir d’un DataTable

Pour importer des données à partir d’un DataTable, appelez la méthode ImportDataTable de la collection Cells. Il existe de nombreuses versions surchargées de la méthode ImportDataTable, mais une surcharge typique prend les paramètres suivants :

  • Data table, l’objet DataTable à partir duquel vous importez le contenu.
  • Is field name shown, spécifie si les noms des colonnes du DataTable doivent être importés dans la feuille de calcul en tant que première ligne ou non.
  • Start cell, représente le nom de la cellule de départ (par exemple “A1”) à partir de laquelle importer le contenu du DataTable.
// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-.NET
// The path to the documents directory.
string dataDir = RunExamples.GetDataDir(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
// Create directory if it is not already present.
bool IsExists = System.IO.Directory.Exists(dataDir);
if (!IsExists)
System.IO.Directory.CreateDirectory(dataDir);
// Instantiating a Workbook object
Workbook workbook = new Workbook();
// Obtaining the reference of the worksheet
Worksheet worksheet = workbook.Worksheets[0];
// Instantiating a "Products" DataTable object
DataTable dataTable = new DataTable("Products");
// Adding columns to the DataTable object
dataTable.Columns.Add("Product ID", typeof(Int32));
dataTable.Columns.Add("Product Name", typeof(string));
dataTable.Columns.Add("Units In Stock", typeof(Int32));
// Creating an empty row in the DataTable object
DataRow dr = dataTable.NewRow();
// Adding data to the row
dr[0] = 1;
dr[1] = "Aniseed Syrup";
dr[2] = 15;
// Adding filled row to the DataTable object
dataTable.Rows.Add(dr);
// Creating another empty row in the DataTable object
dr = dataTable.NewRow();
// Adding data to the row
dr[0] = 2;
dr[1] = "Boston Crab Meat";
dr[2] = 123;
// Adding filled row to the DataTable object
dataTable.Rows.Add(dr);
ImportTableOptions tableOptions = new ImportTableOptions();
// Importing the contents of DataTable to the worksheet starting from "A1" cell,
// Where true specifies that the column names of the DataTable would be added to
// The worksheet as a header row
tableOptions.IsFieldNameShown = true;
worksheet.Cells.ImportData(dataTable, 0, 0, tableOptions);
// Saving the Excel file
workbook.Save(dataDir + "DataImport.out.xls");

Comment importer des données dans Excel à partir d’un objet dynamique en tant que source de données

Aspose.Cells fournit des fonctionnalités pour travailler avec des objets dynamiques en tant que source de données. Cela aide à utiliser une source de données où les propriétés sont ajoutées dynamiquement aux objets. Une fois que les propriétés sont ajoutées à l’objet, Aspose.Cells considère la première entrée comme le modèle et gère le reste en conséquence. Cela signifie que si une propriété dynamique est ajoutée à un seul élément et pas aux autres objets, Aspose.Cells considère que tous les éléments de la collection doivent être identiques.

Dans cet exemple, un modèle de formulaire est utilisé qui contient initialement uniquement deux variables. Cette liste est convertie en liste d’objets dynamiques. Ensuite, un champ supplémentaire y est ajouté et finalement chargé dans le classeur. Le classeur ne prend que les valeurs qui se trouvent dans le fichier XLSX modèle. Ce classeur modèle utilise des marqueurs intelligents qui contiennent également des paramètres. Les paramètres vous permettent de modifier la disposition des informations. Des détails sur les marqueurs intelligents peuvent être obtenus dans l’article suivant :

Utilisation des marqueurs intelligents

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-.NET
using System.Collections.Generic;
using System.Dynamic;
using System.ComponentModel;
using System.Linq;
namespace Aspose.Cells.Examples.CSharp.Data.Handling.Importing
{
public class ImportingFromDynamicDataTable
{
//Source directory
static string sourceDir = RunExamples.Get_SourceDirectory();
//Output directory
static string outputDir = RunExamples.Get_OutputDirectory();
public static void Run()
{
// ExStart:1
// Here data is filled into a list of Model class containing two fields only
var data = GetData();
// Based upon business some additional fields e.g. unique id is added
var modifiedData = new Converter().GetModifiedData(data);
// Modified data is still an object but it is a dynamic one now
modifiedData.First().Id = 20;
// Following field is added in the dynamic objects list, but it will not be added to workbook as template file does not have this field
modifiedData.First().Id2 = 200;
// Create workbook and fill it with the data
Workbook workbook = new Workbook(sourceDir + @"ExcelTemplate.xlsx");
WorkbookDesigner designer = new WorkbookDesigner(workbook);
designer.SetDataSource("modifiedData", modifiedData);
designer.Process();
designer.Workbook.Save(outputDir + @"ModifiedData.xlsx");
// Base Model does work but doesn't have the Id
Workbook workbookRegular = new Workbook(sourceDir + @"ExcelTemplate.xlsx");
WorkbookDesigner designerRegular = new WorkbookDesigner(workbookRegular);
designerRegular.SetDataSource("ModifiedData", data);
designerRegular.Process();
designerRegular.Workbook.Save(outputDir + @"ModifiedDataRegular.xlsx");
// ExEnd:1
}
private static List<Model> GetData()
{
return new List<Model>
{
new Model{ Code = 1 , Name = "One" },
new Model{ Code = 2 , Name = "Two" },
new Model{ Code = 3 , Name = "Three" },
new Model{ Code = 4 , Name = "Four" },
new Model{ Code = 5 , Name = "Five" }
};
}
}
public class Model
{
public string Name { get; internal set; }
public int Code { get; internal set; }
}
public class Converter
{
private int _uniqueNumber;
public List<dynamic> GetModifiedData(List<Model> data)
{
var result = new List<dynamic>();
result.AddRange(data.ConvertAll<dynamic>(i => AddId(i)));
return result;
}
private dynamic AddId(Model i)
{
var result = TransformToDynamic(i);
result.Id = GetUniqueNumber();
return result;
}
private int GetUniqueNumber()
{
var result = _uniqueNumber;
_uniqueNumber++;
return result;
}
private dynamic TransformToDynamic(object dataObject)
{
IDictionary<string, object> expando = new ExpandoObject();
foreach (PropertyDescriptor property in TypeDescriptor.GetProperties(dataObject.GetType()))
expando.Add(property.Name, property.GetValue(dataObject));
return expando as dynamic;
}
}
}

Comment importer DataColumn dans Excel

Un objet DataTable ou DataView est composé d’une ou plusieurs colonnes. Les développeurs peuvent également importer des données de n’importe quelle colonne/des colonnes du DataTable ou DataView en appelant la méthode ImportData de la collection Cells. La méthode ImportData accepte un paramètre de type ImportTableOptions. La classe ImportTableOptions fournit une propriété ColumnIndexes qui accepte un tableau d’index de colonnes.

Le code d’exemple ci-dessous démontre l’utilisation de ImportTableOptions.ColumnIndexes pour importer des colonnes sélectives.

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-.NET
// The path to the documents directory.
string dataDir = RunExamples.GetDataDir(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
// Create directory if it is not already present.
bool IsExists = System.IO.Directory.Exists(dataDir);
if (!IsExists)
System.IO.Directory.CreateDirectory(dataDir);
// Instantiating a "Products" DataTable object
DataTable dataTable = new DataTable("Products");
// Adding columns to the DataTable object
dataTable.Columns.Add("Product ID", typeof(Int32));
dataTable.Columns.Add("Product Name", typeof(string));
dataTable.Columns.Add("Units In Stock", typeof(Int32));
// Creating an empty row in the DataTable object
DataRow dr = dataTable.NewRow();
// Adding data to the row
dr[0] = 1;
dr[1] = "Aniseed Syrup";
dr[2] = 15;
// Adding filled row to the DataTable object
dataTable.Rows.Add(dr);
// Creating another empty row in the DataTable object
dr = dataTable.NewRow();
// Adding data to the row
dr[0] = 2;
dr[1] = "Boston Crab Meat";
dr[2] = 123;
// Adding filled row to the DataTable object
dataTable.Rows.Add(dr);
// Instantiate a new Workbook
Workbook book = new Workbook();
Worksheet sheet = book.Worksheets[0];
// Create import options
ImportTableOptions importOptions = new ImportTableOptions();
importOptions.IsFieldNameShown = true;
importOptions.IsHtmlString = true;
// Importing the values of 2nd column of the data table
sheet.Cells.ImportData(dataTable, 1, 1, importOptions);
// Save workbook
book.Save(dataDir + "DataImport.out.xls");

Comment importer DataView dans Excel

Pour importer des données à partir d’un DataView, appelez la méthode ImportData de la collection Cells. Il existe de nombreuses versions surchargées de la méthode ImportData, mais celle pour le DataView prend les paramètres suivants :

  • DataView: L’objet DataView à partir duquel vous êtes sur le point d’importer le contenu.
  • First Row: le numéro de ligne de la première cellule où les données seront importées.
  • First Column: le numéro de colonne de la première cellule où les données seront importées.
  • ImportTableOptions: Les options d’importation.
// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-.NET
// The path to the documents directory.
string dataDir = RunExamples.GetDataDir(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
// Instantiating a Workbook object
Workbook workbook = new Workbook();
// Obtaining the reference of the worksheet
Worksheet worksheet = workbook.Worksheets[0];
// Instantiating a "Products" DataTable object
DataTable dataTable = new DataTable("Products");
// Adding columns to the DataTable object
dataTable.Columns.Add("Product ID", typeof(Int32));
dataTable.Columns.Add("Product Name", typeof(string));
dataTable.Columns.Add("Units In Stock", typeof(Int32));
// Creating an empty row in the DataTable object
DataRow dr = dataTable.NewRow();
// Adding data to the row
dr[0] = 1;
dr[1] = "Aniseed Syrup";
dr[2] = 15;
// Adding filled row to the DataTable object
dataTable.Rows.Add(dr);
// Creating another empty row in the DataTable object
dr = dataTable.NewRow();
// Adding data to the row
dr[0] = 2;
dr[1] = "Boston Crab Meat";
dr[2] = 123;
// Adding filled row to the DataTable object
dataTable.Rows.Add(dr);
// Importing the contents of the data view to the worksheet
ImportTableOptions options = new ImportTableOptions();
options.IsFieldNameShown = true;
worksheet.Cells.ImportData(dataTable.DefaultView, 0, 0, options);
// Saving the Excel file
workbook.Save(dataDir + "output.xls");

Comment importer DataGrid dans Excel

Il est possible d’importer des données à partir d’un DataGrid en appelant la méthode ImportDataGrid de la collection Cells. Il existe de nombreuses versions surchargées de la méthode ImportDataGrid, mais une surcharge typique prend les paramètres suivants :

  • Data grid, l’objet DataGrid à partir duquel vous importez le contenu.
  • Numéro de ligne, le numéro de ligne de la première cellule dans laquelle les données seront importées.
  • Numéro de colonne, le numéro de colonne de la première cellule dans laquelle les données seront importées.
  • Insérer des lignes, une propriété booléenne qui indique si des lignes supplémentaires doivent être ajoutées à la feuille de calcul pour ajuster les données ou non.
// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-.NET
// The path to the documents directory.
string dataDir = RunExamples.GetDataDir(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
// Create a DataTable object and set it as DataSource of DataGrid.
DataTable dataTable = new DataTable("Products");
dataTable.Columns.Add("Product ID", typeof(Int32));
dataTable.Columns.Add("Product Name", typeof(string));
dataTable.Columns.Add("Units In Stock", typeof(Int32));
DataRow dr = dataTable.NewRow();
dr[0] = 1;
dr[1] = "Aniseed Syrup";
dr[2] = 15;
dataTable.Rows.Add(dr);
dr = dataTable.NewRow();
dr[0] = 2;
dr[1] = "Boston Crab Meat";
dr[2] = 123;
dataTable.Rows.Add(dr);
// Now take care of DataGrid
System.Web.UI.WebControls.DataGrid dg = new System.Web.UI.WebControls.DataGrid();
dg.DataSource = dataTable;
dg.DataBind();
// We have a DataGrid object with some data in it.
// Lets import it into our spreadsheet
// Creat a new workbook
Workbook workbook = new Workbook();
Worksheet worksheet = workbook.Worksheets[0];
// Importing the contents of the data grid to the worksheet
worksheet.Cells.ImportDataGrid(dg, 0, 0, false);
// Save it as Excel file
workbook.Save(dataDir + "output.xlsx");

Comment importer GridView dans Excel

Pour importer des données à partir d’un contrôle GridView, appelez la méthode ImportGridView de la collection Cells.

Aspose.Cells nous permet de conserver les valeurs formatées en HTML lors de l’importation des données dans la feuille de calcul. Lorsque l’analyse HTML est activée lors de l’importation des données, Aspose.Cells convertit le HTML en formatage de cellule correspondant.

Comment importer des données au format HTML dans Excel

Aspose.Cells fournit une classe Cells qui propose des méthodes très utiles pour importer des données à partir de sources de données externes. Cet article montre comment analyser du texte formaté en HTML lors de l’importation des données et convertir le HTML en valeurs de cellule formatées.

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-.NET
// The path to the documents directory.
string dataDir = RunExamples.GetDataDir(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
string output1Path = dataDir + "Output.out.xlsx";
string output2Path = dataDir + "Output.out.ods";
// Prepare a DataTable with some HTML formatted values
DataTable dataTable = new DataTable("Products");
dataTable.Columns.Add("Product ID", typeof(Int32));
dataTable.Columns.Add("Product Name", typeof(string));
dataTable.Columns.Add("Units In Stock", typeof(Int32));
DataRow dr = dataTable.NewRow();
dr[0] = 1;
dr[1] = "<i>Aniseed</i> Syrup";
dr[2] = 15;
dataTable.Rows.Add(dr);
dr = dataTable.NewRow();
dr[0] = 2;
dr[1] = "<b>Boston Crab Meat</b>";
dr[2] = 123;
dataTable.Rows.Add(dr);
// Create import options
ImportTableOptions importOptions = new ImportTableOptions();
importOptions.IsFieldNameShown = true;
importOptions.IsHtmlString = true;
// Create workbook
Workbook workbook = new Workbook();
Worksheet worksheet = workbook.Worksheets[0];
worksheet.Cells.ImportData(dataTable, 0, 0, importOptions);
worksheet.AutoFitRows();
worksheet.AutoFitColumns();
workbook.Save(output1Path);
workbook.Save(output2Path);

Comment importer des données dans Excel à partir de JSON

Aspose.Cells fournit une classe JsonUtility pour le traitement JSON. La classe JsonUtility dispose d’une méthode ImportData pour l’importation de données JSON. Aspose.Cells fournit également une classe JsonLayoutOptions qui représente les options de la disposition JSON. La méthode ImportData accepte JsonLayoutOptions en tant que paramètre. La classe JsonLayoutOptions propose les propriétés suivantes.

  • ArrayAsTable : Indique si le tableau doit être traité comme un tableau ou non.
  • ConvertNumericOrDate : Obtient ou définit une valeur qui indique si la chaîne en JSON doit être convertie en numérique ou en date.
  • DateFormat : Obtient et définit le format de la valeur de date.
  • IgnoreArrayTitle : Indique s’il faut ignorer le titre si la propriété de l’objet est un tableau.
  • IgnoreNull : Indique si la valeur nulle doit être ignorée ou non.
  • IgnoreObjectTitle : Indique s’il faut ignorer le titre si la propriété de l’objet est un objet.
  • NumberFormat: Obtient et définit le format de la valeur numérique.
  • TitleStyle: Obtient et définit le style du titre.

Le code d’exemple ci-dessous démontre l’utilisation des classes JsonUtility et JsonLayoutOptions pour importer des données JSON.

// For complete examples and data files, please go to https://github.com/aspose-cells/Aspose.Cells-for-.NET
// The path to the documents directory.
string dataDir = RunExamples.GetDataDir(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
// Instantiating a Workbook object
Workbook workbook = new Workbook();
Worksheet worksheet = workbook.Worksheets[0];
// Read File
string jsonInput = File.ReadAllText(dataDir + "Test.json");
// Set Styles
CellsFactory factory = new CellsFactory();
Style style = factory.CreateStyle();
style.HorizontalAlignment = TextAlignmentType.Center;
style.Font.Color = System.Drawing.Color.BlueViolet;
style.Font.IsBold = true;
// Set JsonLayoutOptions
JsonLayoutOptions options = new JsonLayoutOptions();
options.TitleStyle = style;
options.ArrayAsTable = true;
// Import JSON Data
JsonUtility.ImportData(jsonInput, worksheet.Cells, 0, 0, options);
// Save Excel file
workbook.Save(dataDir + "ImportingFromJson.out.xlsx");

Sujets avancés