Importare i dati nel foglio di lavoro

Come importare dati nel foglio di lavoro

Quando si apre un file Excel con Aspose.Cells, tutti i dati nel file vengono automaticamente importati. Aspose.Cells può anche importare dati da altre fonti di dati.

Aspose.Cells fornisce una classe che rappresenta un file Microsoft Excel. Tale classe contiene una collezione che consente l’accesso a ciascun foglio di lavoro in un file Excel. Un foglio di lavoro è rappresentato dalla classe. La classe fornisce una collezione che fornisce metodi utili per importare dati da diverse fonti di dati. Questo articolo spiega come utilizzare questi metodi.

Come importare dati in Excel con l’interfaccia ICellsDataTable

Implementare ICellsDataTable per incapsulare varie fonti dati, quindi utilizzare Cells.ImportData() per importare i dati nel foglio di lavoro di Excel.

Codice di Esempio

//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");

Di seguito è riportata l’implementazione delle classi CustomerDataSource, Customer e CustomerList

// 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; }
}
}

Come importare dati in Excel da Array

Per importare dati in un foglio di calcolo da un array, chiamare il metodo ImportArray della collezione Cells. Ci sono molte versioni sovraccaricate del metodo ImportArray ma tipicamente una versione sovraccaricata richiede i seguenti parametri:

  • Array, l’oggetto array da cui si sta importando il contenuto.
  • Numero di riga, il numero di riga della prima cella in cui saranno importati i dati.
  • Numero di colonna, il numero di colonna della prima cella in cui saranno importati i dati.
  • È verticale, un valore booleano che specifica se importare i dati verticalmente o orizzontalmente.
// 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");

Come importare dati in Excel da ArrayList

Per importare dati da un ArrayList nei fogli di lavoro, chiamare il metodo ImportArrayList della collezione Cells. Il metodo ImportArray richiede i seguenti parametri:

  • Array list, rappresenta l’oggetto ArrayList che si sta importando.
  • Numero di riga, rappresenta il numero di riga della prima cella in cui saranno importati i dati.
  • Numero di colonna, rappresenta il numero di colonna della prima cella in cui saranno importati i dati.
  • È verticale, un valore booleano che specifica se importare i dati verticalmente o orizzontalmente.
// 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");

Come importare i dati in Excel da oggetti personalizzati

Per importare i dati da una raccolta di oggetti in un foglio di lavoro, utilizzare ImportCustomObjects. Fornire un elenco di colonne/proprietà al metodo per visualizzare l’elenco desiderato di oggetti.

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;
}
}

Come importare i dati in Excel da oggetti personalizzati e verificare l’area unita

Per importare i dati da una raccolta di oggetti in un foglio di lavoro contenente celle unite, utilizzare la proprietà ImportTableOptions.CheckMergedCells. Se il modello di Excel ha celle unite, impostare il valore della proprietà ImportTableOptions.CheckMergedCells su true. Passare l’oggetto ImportTableOptions insieme all’elenco di colonne/proprietà al metodo per visualizzare l’elenco desiderato di oggetti. Il seguente esempio di codice dimostra l’uso della proprietà ImportTableOptions.CheckMergedCells per importare i dati da oggetti personalizzati in celle unite. Si prega di consultare il file di Excel origine e il file di Excel output per riferimento.

// 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; }
}

Come importare i dati in Excel da un DataTable

Per importare i dati da un DataTable, chiamare il metodo ImportDataTable della raccolta Cells. Ci sono molte versioni sovraccaricate del metodo ImportDataTable ma una tipica sovraccarica i seguenti parametri:

  • Tabella dati, l’oggetto DataTable da cui si sta importando il contenuto.
  • Mostra il nome del campo, specifica se i nomi delle colonne del DataTable dovrebbero essere importati nel foglio di lavoro come prima riga o meno.
  • Cella di inizio, rappresenta il nome della cella di inizio (ad esempio “A1”) da cui importare i contenuti del 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");

Come importare i dati in Excel da un oggetto dinamico come origine dati

Aspose.Cells fornisce funzionalità per lavorare con oggetti dinamici come origine dati. Aiuta nell’uso dell’origine dati in cui le proprietà vengono aggiunte in modo dinamico agli oggetti. Una volta che le proprietà vengono aggiunte all’oggetto, Aspose.Cells considera la prima voce come modello e gestisce il resto di conseguenza. Significa che se una proprietà dinamica viene aggiunta solo a un primo elemento e non agli altri oggetti, Aspose.Cells considera che tutte le voci nella raccolta devono essere uguali.

In questo esempio, viene utilizzato un modello di template che inizialmente contiene solo due variabili. Questo elenco viene convertito in elenco di oggetti dinamici. Quindi alcuni campi aggiuntivi vengono aggiunti e infine caricati nel foglio di lavoro. Il foglio di lavoro rileva solo quei valori che sono nel file XLSX template. Questo foglio di lavoro modello utilizza Smart Markers che contengono anche parametri. I parametri ti consentono di modificare come le informazioni sono disposte. I dettagli sui Smart Markers possono essere ottenuti dal seguente articolo:

Utilizzo dei Smart Markers

// 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;
}
}
}

Come importare una DataColumn in Excel

Un oggetto DataTable o DataView è composto da una o più colonne. Gli sviluppatori possono anche importare dati da qualsiasi colonna/colonne del DataTable o DataView chiamando il metodo ImportData della raccolta Cells. Il metodo ImportData accetta un parametro di tipo ImportTableOptions. La classe ImportTableOptions fornisce una proprietà ColumnIndexes che accetta un array di indici di colonne.

Il codice di esempio fornito di seguito dimostra l’uso di ImportTableOptions.ColumnIndexes per importare colonne selettive.

// 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");

Come importare un DataView in Excel

Per importare i dati da un DataView, chiamare il metodo ImportData della raccolta Cells. Ci sono molte versioni sovraccaricate del metodo ImportData ma quella per DataView prende i seguenti parametri:

  • DataView: L’oggetto DataView da cui stai per importare il contenuto.
  • Prima riga: il numero di riga della prima cella in cui i dati verranno importati.
  • Prima colonna: il numero di colonna della prima cella in cui i dati verranno importati.
  • OpzioniImportaTabella: Le opzioni di importazione.
// 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");

Come importare DataGrid in Excel

È possibile importare i dati da un DataGrid chiamando il metodo ImportDataGrid della collezione Cells. Ci sono molte versioni sovraccaricate del metodo ImportDataGrid, ma un sovraccarico tipico richiede i seguenti parametri:

  • Data grid, l’oggetto DataGrid da cui si sta importando il contenuto.
  • Numero di riga, il numero di riga della prima cella in cui i dati verranno importati.
  • Numero di colonna, il numero di colonna della prima cella in cui i dati verranno importati.
  • Inserisci righe, una proprietà booleana che indica se devono essere aggiunte righe aggiuntive al foglio di lavoro per adattare i dati o meno.
// 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");

Come importare GridView in Excel

Per importare i dati da un controllo GridView, chiamare il metodo ImportGridView della collezione Cells.

Aspose.Cells ci consente di rispettare valori formattati in HTML durante l’importazione dei dati nel foglio di calcolo. Quando il parsing HTML è abilitato durante l’importazione dei dati, Aspose.Cells converte l’HTML in formattazione di celle corrispondenti.

Come importare dati formattati in HTML in Excel

Aspose.Cells fornisce una classe Cells che fornisce metodi molto utili per l’importazione di dati da fonti di dati esterne. Questo articolo mostra come analizzare il testo formattato in HTML durante l’importazione dei dati e convertire l’HTML in valori di celle formattati.

// 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);

Come importare i dati in Excel da JSON

Aspose.Cells fornisce una classe JsonUtility per l’elaborazione di JSON. La classe JsonUtility ha un metodo ImportData per l’importazione di dati JSON. Aspose.Cells fornisce anche una classe JsonLayoutOptions che rappresenta le opzioni di layout JSON. Il metodo ImportData accetta JsonLayoutOptions come parametro. La classe JsonLayoutOptions fornisce le seguenti proprietà:

  • ArrayAsTable: Indica se l’array deve essere elaborato come una tabella o meno.
  • ConvertNumericOrDate: Ottiene o imposta un valore che indica se la stringa in JSON deve essere convertita in numerico o data.
  • DateFormat: Ottiene e imposta il formato del valore della data.
  • IgnoreArrayTitle: Indica se ignorare il titolo se la proprietà dell’oggetto è un array.
  • IgnoreNull: Indica se il valore nullo deve essere ignorato o meno.
  • IgnoreObjectTitle: Indica se ignorare il titolo se la proprietà dell’oggetto è un oggetto.
  • NumberFormat: Ottiene e imposta il formato del valore numerico.
  • TitleStyle: Ottiene e imposta lo stile del titolo.

Il codice di esempio riportato di seguito dimostra l’uso delle classi JsonUtility e JsonLayoutOptions per importare i dati 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");

Argomenti avanzati