Importera data till kalkylblad

Hur man importerar data till kalkylblad

När du öppnar en Excel-fil med Aspose.Cells importeras automatiskt all data i filen. Aspose.Cells kan också importera data från andra datakällor.

Aspose.Cells tillhandahåller en Workbook-klass som representerar en Microsoft Excel-fil. Workbook-klassen innehåller en Worksheets-kollektion som möjliggör åtkomst till varje kalkylblad i en Excel-fil. Ett kalkylblad representeras av Worksheet-klassen. Worksheet-klassen tillhandahåller en Cells-kollektion. Cells-kollektionen tillhandahåller användbara metoder för att importera data från olika datakällor. Den här artikeln förklarar hur dessa metoder kan användas.

Hur man importerar data till Excel med ICellsDataTable-gränssnittet

Implementera ICellsDataTable för att paketera olika datakällor, använd sedan Cells.ImportData() för att importera data till Excel-kalkylblad.

Exempelkod

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

Implementationen av klasserna CustomerDataSourceCustomer, och CustomerList ges nedan

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

Hur man importerar data till Excel från Array

För att importera data till en kalkylblad från en array, anropa ImportArray-metoden i Cells-kollektionen. Det finns många överbelastade versioner av ImportArray-metoden, men en vanlig överbelastning tar följande parametrar:

  • Array, arrayobjektet som du importerar innehåll från.
  • Radnummer, radnumret för den första cellen som datan kommer att importeras till.
  • Kolumnnummer, kolumnnumret för den första cellen som datan kommer att importeras till.
  • Är vertikal, ett booleskt värde som specificerar om data ska importeras vertikalt eller horisontellt.
// 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");

Hur man importerar data till Excel från ArrayList

För att importera data från en ArrayList till kalkylblad, anropa Cells-kollektionens ImportArrayList-metod. Metoden ImportArray tar följande parametrar:

  • Array list, representerar ArrayList-objektet du importerar.
  • Radnummer, representerar radnumret för den första cellen som datan kommer att importeras till.
  • Kolumnnummer, representerar kolumnnumret för den första cellen som datan kommer att importeras till.
  • Är vertikal, ett booleskt värde som specificerar om data ska importeras vertikalt eller horisontellt.
// 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");

Hur man importerar data till Excel från anpassade objekt

För att importera data från en samling av objekt till en kalkylblad, använd ImportCustomObjects. Tillhandahåll en lista med kolumner/egenskaper till metoden för att visa önskad lista med objekt.

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

Hur man importerar data till Excel från anpassade objekt och kontrollerar sammanslagna områden

För att importera data från en samling av objekt till ett kalkylblad som innehåller sammanfogade celler, använd ImportTableOptions.CheckMergedCells egenskap. Om Excel-mallen har sammanfogade celler, ställ in värdet på ImportTableOptions.CheckMergedCells egenskapen till true. Skicka med objektet ImportTableOptions tillsammans med listan av kolumner/egenskaper till metoden för att visa önskad lista med objekt. Följande kodprov visar användningen av ImportTableOptions.CheckMergedCells egenskapen för att importera data från anpassade objekt till sammanfogade celler. Se den bifogade käll Excel-filen och utdata Excel-filen för referens.

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

Hur man importerar data till Excel från DataTable

För att importera data från en DataTable, anropa Cells kollektionens ImportDataTablemetod. Det finns många överbelastade versioner av ImportDataTable metoden men en vanlig överbelastning tar följande parametrar:

  • Datatabell, DataTable-objektet som du importerar innehållet från.
  • Visa fältnamn, anger om namnen på DataTable-kolumnerna ska importeras till kalkylbladet som en första rad eller inte.
  • Startcell, representerar namnet på startcellen (till exempel “A1”) från vilken du ska importera innehållet från 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");

Hur man importerar data till Excel från dynamiskt objekt som datakälla

Aspose.Cells erbjuder funktioner för att arbeta med dynamiska objekt som datakälla. Det hjälper till att använda en datakälla där egenskaper läggs till dynamiskt till objekten. När egenskaperna har lagts till objektet, betraktar Aspose.Cells första posten som mallen och hanterar resten därefter. Det betyder att om någon dynamisk egenskap läggs till endast i en första post och inte till andra objekt, betraktar Aspose.Cells att alla poster i samlingen ska vara desamma.

I det här exemplet används en mallmodell som inledningsvis innehåller endast två variabler. Denna lista konverteras till lista med dynamiska objekt. Sedan läggs några ytterligare fält till den och slutligen laddas den in i arbetsboken. Arbetsboken hämtar endast de värden som finns i mall-XLSX-filen. Denna mallarbetsbok använder även Smarta Markeringar som också innehåller parametrar. Det går att få detaljer om Smarta Markeringar från följande artikel:

Användning av Smarta Markeringar

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

Hur man importerar DataColumn till Excel

En DataTable eller DataView-objekt består av en eller flera kolumner. Utvecklare kan också importera data från en eller flera kolumner i DataTable eller DataView genom att anropa ImportData metoden för Cells kollektionen. ImportData metoden accepterar en parameter av typ ImportTableOptionsImportTableOptions klassen tillhandahåller en ColumnIndexes egenskap som accepterar en array av kolumnindex.

Det angivna kodexemplet nedan visar användningen av ImportTableOptions.ColumnIndexes för att importera selektiva kolumner.

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

Hur man importerar DataView till Excel

För att importera data från en DataView, anropa Cells kollektionens ImportData metod. Det finns många överbelastade versioner av ImportData metoden men den för DataView tar följande parametrar:

  • DataView: DataView-objektet som du ska importera innehåll från.
  • Första rad: radnumret för den första cellen som datan ska importeras till.
  • Första kolumn: kolumnnumret för den första cellen som datan ska importeras till.
  • ImportTableOptions: importalternativen.
// 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");

Hur man importerar DataGrid till Excel

Det går att importera data från en DataGrid genom att anropa ImportDataGrid metoden för Cells kollektionen. Det finns många överbelastade versioner av ImportDataGrid metoden men en vanlig överbelastning tar följande parametrar:

  • Datagrid, DataGrid-objektet som du importerar innehåll från.
  • Radnummer, radnumret för den första cellen som datan ska importeras till.
  • Kolumnnummer, kolumnnumret för den första cellen som datan ska importeras till.
  • Infoga rader, en boolesk egenskap som anger om extra rader ska läggas till kalkylbladet för att passa datan eller inte.
// 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");

Hur man importerar GridView till Excel

För att importera data från en GridView-kontroll, anropa ImportGridView metoden för Cells kollektionen.

Aspose.Cells tillåter oss att respektera HTML-formaterade värden vid import av data till kalkylarket. När HTML-tolkning är aktiverad vid import av data, konverterar Aspose.Cells HTML till motsvarande cellformatering.

Hur man importerar HTML-formaterade data till Excel

Aspose.Cells tillhandahåller en Cells klass som har mycket användbara metoder för att importera data från externa datakällor. Den här artikeln visar hur man tolkar HTML-formaterad text vid import av data och konverterar HTML till formaterade cellvärden.

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

Hur man importerar data till Excel från JSON

Aspose.Cells tillhandahåller en JsonUtility klass för bearbetning av JSON. JsonUtility klass har en ImportData metod för att importera JSON-data. Aspose.Cells tillhandahåller också en JsonLayoutOptions klass som representerar alternativen för JSON-layout. Metoden ImportData accepterar JsonLayoutOptions som parameter. JsonLayoutOptions klassen tillhandahåller följande egenskaper.

  • ArrayAsTable: Anger om arrayen ska behandlas som en tabell eller inte.
  • ConvertNumericOrDate: Får eller ställer in ett värde som indikerar om strängen i JSON ska konverteras till numeriska eller datum.
  • DateFormat: Hämtar och anger formatet för datumvärdet.
  • IgnoreArrayTitle: Indikerar om titeln ska ignoreras om objektets egenskap är en array
  • IgnoreNull: Indikerar om nullvärdet ska ignoreras eller inte.
  • IgnoreObjectTitle: Indikerar om titeln ska ignoreras om objektets egenskap är ett objekt.
  • NumberFormat: Hämtar och anger formatet för numeriska värden.
  • TitleStyle: Hämtar och anger stilen för titeln.

Det givna kodexemplet nedan visar användningen av JsonUtility och JsonLayoutOptions klasserna för att importera JSON-data.

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

Fortsatta ämnen