Daten in Arbeitsblatt importieren
Wie man Daten in das Arbeitsblatt importiert
Wenn Sie eine Excel-Datei mit Aspose.Cells öffnen, werden alle Daten in der Datei automatisch importiert. Aspose.Cells kann auch Daten aus anderen Datenquellen importieren.
Aspose.Cells stellt eine Workbook-Klasse bereit, die eine Microsoft Excel-Datei repräsentiert. Die Workbook-Klasse enthält eine Worksheets-Sammlung, die den Zugriff auf jedes Arbeitsblatt in einer Excel-Datei ermöglicht. Ein Arbeitsblatt wird von der Worksheet-Klasse dargestellt. Die Worksheet-Klasse bietet eine Cells-Sammlung. Die Cells-Sammlung bietet nützliche Methoden zum Importieren von Daten aus verschiedenen Datenquellen. In diesem Artikel wird erläutert, wie diese Methoden verwendet werden können.
Wie man Daten mit der ICellsDataTable-Schnittstelle in Excel importiert
Implementieren Sie ICellsDataTable, um verschiedene Ihrer Datenquellen zu kapseln, und verwenden Sie dann Cells.ImportData(), um Daten in das Excel-Arbeitsblatt zu importieren.
Beispielcode
//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"); |
Die Implementierung der Klassen CustomerDataSource, Customer und CustomerList ist unten aufgeführt
// 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; } | |
} | |
} |
Wie man Daten aus einem Array in Excel importiert
Um Daten aus einem Array in ein Tabellenblatt zu importieren, rufen Sie die Methode ImportArray der Cells-Sammlung auf. Es gibt viele überladene Versionen der ImportArray-Methode, aber eine typische Überladung benötigt die folgenden Parameter:
- Array, das Array-Objekt, aus dem Sie Inhalte importieren.
- Reihennummer, die Reihennummer der ersten Zelle, in die die Daten importiert werden.
- Spaltennummer, die Spaltennummer der ersten Zelle, in die die Daten importiert werden.
- Ist vertikal, ein Boolescher Wert, der angibt, ob Daten vertikal oder horizontal importiert werden sollen.
// 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"); |
Wie man Daten aus einer ArrayList in Excel importiert
Um Daten aus einer ArrayList in Arbeitsblätter zu importieren, rufen Sie die Methode ImportArrayList der ArrayList-Sammlung auf. Die ImportArray-Methode nimmt die folgenden Parameter an:
- Array-Liste, repräsentiert das ArrayList-Objekt, das importiert wird.
- Zeilennummer, stellt die Zeilennummer der ersten Zelle dar, in die die Daten importiert werden sollen.
- Spaltennummer, stellt die Spaltennummer der ersten Zelle dar, in die die Daten importiert werden sollen.
- Ist vertikal, ein Boolescher Wert, der angibt, ob Daten vertikal oder horizontal importiert werden sollen.
// 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"); |
Wie man Daten aus benutzerdefinierten Objekten in Excel importiert
Um Daten aus einer Objektsammlung in ein Arbeitsblatt zu importieren, verwenden Sie ImportCustomObjects. Geben Sie eine Liste von Spalten/Eigenschaften an die Methode, um Ihre gewünschte Objektliste anzuzeigen.
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; | |
} | |
} |
Wie man Daten aus benutzerdefinierten Objekten in Excel importiert und einen zusammengeführten Bereich überprüft
Um Daten aus einer Objektsammlung in ein Arbeitsblatt mit zusammengeführten Zellen zu importieren, verwenden Sie das ImportTableOptions.CheckMergedCells-Eigenschaft. Wenn die Excel-Vorlage zusammengeführte Zellen enthält, setzen Sie den Wert des ImportTableOptions.CheckMergedCells-Eigenschaft auf true. Geben Sie das ImportTableOptions-Objekt zusammen mit der Liste von Spalten/Eigenschaften an die Methode, um Ihre gewünschte Objektliste anzuzeigen. Der folgende Code-Auszug zeigt die Verwendung des ImportTableOptions.CheckMergedCells-Eigenschaft zum Importieren von Daten aus benutzerdefinierten Objekten in zusammengeführte Zellen. Bitte beachten Sie die angehängte Quell-Excel und die Ausgabe-Excel Datei zur Referenz.
// 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; } | |
} |
Wie man Daten aus einer DataTable in Excel importiert
Um Daten aus einer DataTable zu importieren, rufen Sie die Methode ImportDataTable der DataTable-Sammlung auf. Es gibt viele überladene Versionen der ImportDataTable-Methode, aber eine typische Überladung nimmt die folgenden Parameter an:
- Daten-Tabelle, das DataTable-Objekt, von dem der Inhalt importiert wird.
- Sind Feldnamen angezeigt, gibt an, ob die Namen der DataTable-Spalten als erste Zeile in das Arbeitsblatt importiert werden sollen oder nicht.
- Startzelle, stellt den Namen der Startzelle (z.B. “A1”) dar, von der aus der Inhalt der DataTable importiert wird.
// 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"); |
Wie man Daten aus einem dynamischen Objekt als Datenquelle in Excel importiert
Aspose.Cells bietet Funktionen zum Arbeiten mit dynamischen Objekten als Datenquelle. Es hilft bei der Verwendung einer Datenquelle, bei der Eigenschaften dynamisch zu den Objekten hinzugefügt werden. Sobald die Eigenschaften dem Objekt hinzugefügt werden, betrachtet Aspose.Cells den ersten Eintrag als Vorlage und verarbeitet die restlichen entsprechend. Das bedeutet, wenn einer ersten Einheit dynamisch eine Eigenschaft hinzugefügt wird und nicht zu anderen Objekten, betrachtet Aspose.Cells alle Einheiten in der Sammlung als identisch.
In diesem Beispiel wird ein Vorlagenmodell verwendet, das zunächst nur zwei Variablen enthält. Diese Liste wird in eine Liste von dynamischen Objekten konvertiert. Dann wird ein zusätzliches Feld hinzugefügt und schließlich in die Arbeitsmappe geladen. Die Arbeitsmappe nimmt nur diejenigen Werte auf, die in der Vorlagen-XLSX-Datei enthalten sind. Diese Vorlagenarbeitsmappe verwendet Smart-Marker, die auch Parameter enthalten. Parameter ermöglichen es Ihnen, zu ändern, wie die Informationen angeordnet sind. Details zu den Smart-Markern können dem folgenden Artikel entnommen werden:
// 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; | |
} | |
} | |
} |
Wie importiere ich DataColumn in Excel
Ein DataTable oder DataView Objekt besteht aus einer oder mehreren Spalten. Entwickler können auch Daten aus einer oder mehreren Spalten des DataTable oder DataView importieren, indem sie die Methode ImportData der Cells Sammlung aufrufen. Die Methode ImportData akzeptiert einen Parameter vom Typ ImportTableOptions. Die Klasse ImportTableOptions stellt eine ColumnIndexes Eigenschaft bereit, die ein Array von Spaltenindizes akzeptiert.
Der unten gegebene Beispielcode demonstriert die Verwendung von ImportTableOptions.ColumnIndexes zum Importieren ausgewählter Spalten.
// 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"); |
Wie importiere ich DataView in Excel
Um Daten aus einem DataView zu importieren, rufen Sie die Methode ImportData der Cells Sammlung auf. Es gibt verschiedene überladene Versionen der ImportData Methode, aber die für DataView nimmt die folgenden Parameter an:
- DataView: Das DataView Objekt, von dem Sie Inhalte importieren möchten.
- Erste Zeile: die Zeilennummer der ersten Zelle, in die die Daten importiert werden sollen.
- Erste Spalte: die Spaltennummer der ersten Zelle, in die die Daten importiert werden sollen.
- ImportTableOptions: Die Importoptionen.
// 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"); |
Wie importiere ich DataGrid in Excel
Es ist möglich, Daten aus einem DataGrid zu importieren, indem Sie die Methode ImportDataGrid der Cells Sammlung aufrufen. Es gibt viele überladene Versionen der ImportDataGrid Methode, aber eine typische Überladung nimmt die folgenden Parameter an:
- DataGrid: Das DataGrid Objekt, aus dem Sie Inhalte importieren.
- Zeilennummer: die Zeilennummer der ersten Zelle, in die die Daten importiert werden sollen.
- Spaltennummer: die Spaltennummer der ersten Zelle, in die die Daten importiert werden sollen.
- Zeilen einfügen: eine boolesche Eigenschaft, die angibt, ob zusätzliche Zeilen zum Arbeitsblatt hinzugefügt werden sollen, um die Daten anzupassen oder nicht.
// 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"); |
Wie importiere ich GridView in Excel
Um Daten aus einem GridView Steuerelement zu importieren, rufen Sie die Methode ImportGridView der Cells Sammlung auf.
Aspose.Cells ermöglicht es uns, HTML formatierte Werte beim Importieren von Daten in die Tabellenkalkulation zu respektieren. Wenn das HTML-Parsing beim Importieren von Daten aktiviert ist, konvertiert Aspose.Cells das HTML in entsprechende Zellformatierungen.
Wie importiere ich HTML formatierte Daten in Excel
Aspose.Cells bietet eine Cells Klasse, die sehr nützliche Methoden zum Importieren von Daten aus externen Datenquellen bereitstellt. Dieser Artikel zeigt, wie man HTML formatierten Text beim Importieren von Daten analysiert und das HTML in formatierte Zellwerte konvertiert.
// 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); |
Wie man Daten aus JSON in Excel importiert
Aspose.Cells bietet eine JsonUtility-Klasse zur Verarbeitung von JSON. Die JsonUtility-Klasse verfügt über eine ImportData-Methode zum Importieren von JSON-Daten. Aspose.Cells bietet auch eine JsonLayoutOptions-Klasse, die die Optionen des JSON-Layouts repräsentiert. Die ImportData-Methode akzeptiert JsonLayoutOptions als Parameter. Die JsonLayoutOptions-Klasse bietet die folgenden Eigenschaften.
- ArrayAsTable: Gibt an, ob das Array als Tabelle verarbeitet werden soll oder nicht.
- ConvertNumericOrDate: Gibt einen Wert an, der angibt, ob der String in JSON in numerische oder Datumsangaben konvertiert werden soll.
- DateFormat: Ruft das Format des Datumswerts ab und legt es fest.
- IgnoreArrayTitle: Gibt an, ob der Titel ignoriert werden soll, wenn das Eigenschaft des Objekts ein Array ist.
- IgnoreNull: Gibt an, ob der Nullwert ignoriert werden soll oder nicht.
- IgnoreObjectTitle: Gibt an, ob der Titel ignoriert werden soll, wenn das Eigenschaft des Objekts ein Objekt ist.
- NumberFormat: Ruft das Format des numerischen Werts ab und legt es fest.
- TitleStyle: Ruft den Stil des Titels ab und legt ihn fest.
Der unten stehende Beispielcode demonstriert die Verwendung der Klassen JsonUtility und JsonLayoutOptions zum Importieren von JSON-Daten.
// 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"); |