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 CustomerDataSource, Customer, 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 ImportTableOptions. ImportTableOptions 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"); |