Daten in Arbeitsblatt importieren

In diesem Artikel werden einige Datenimporttechniken erläutert, auf die Entwickler über Aspose.Cells Zugriff haben.

Daten in Arbeitsblatt importieren

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 bietet eineArbeitsmappeKlasse, die eine Microsoft Excel-Datei darstellt. DasArbeitsmappeKlasse enthält aArbeitsblätterSammlung, die den Zugriff auf jedes Arbeitsblatt in einer Excel-Datei ermöglicht. Ein Arbeitsblatt wird durch dargestelltArbeitsblatt Klasse. DasArbeitsblatt Klasse bietet aCellsSammlung.CellsCollection bietet nützliche Methoden zum Importieren von Daten aus verschiedenen Datenquellen. In diesem Artikel wird erläutert, wie diese Methoden verwendet werden können.

Importieren von Daten in Excel mit ICellsDataTable-Schnittstelle

ImplementierenICellsDataTable Um Ihre verschiedenen Datenquellen zu umschließen, verwenden Sie dannCells.ImportData() um Daten in ein 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 vonKundendatenquelle, Kunde, undKundenliste Klassen ist unten angegeben

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

Import aus Array

Um Daten aus einem Array in eine Tabelle zu importieren, rufen Sie die aufImportArray Methode derCells Sammlung. Es gibt viele überladene Versionen derImportArray-Methode, aber eine typische Überladung nimmt die folgenden Parameter an:

• Array, das Array-Objekt, aus dem Sie Inhalte importieren.
• Zeilennummerdie Zeilennummer 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");

Importieren aus ArrayList

Zum Importieren von Daten aus einerAnordnungsliste zu Arbeitsblättern rufen Sie die aufCells SammlungArrayListe importierenMethode. Die ImportArray-Methode übernimmt die folgenden Parameter:

• Anordnungsliste , repräsentiert dieAnordnungslisteObjekt, das Sie importieren.
• Zeilennummer, stellt die Zeilennummer der ersten Zelle dar, in die die Daten importiert werden.
• Spaltennummer, stellt die Spaltennummer der ersten Zelle dar, 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];

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

Importieren von benutzerdefinierten Objekten

Um Daten aus einer Sammlung von Objekten in ein Arbeitsblatt zu importieren, verwenden SieBenutzerdefinierte Objekte importieren. Stellen Sie der Methode eine Liste mit Spalten/Eigenschaften zur Verfügung, um die 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;
    }
}

Importieren von benutzerdefinierten Objekten in den zusammengeführten Bereich

Verwenden Sie zum Importieren von Daten aus einer Sammlung von Objekten in ein Arbeitsblatt mit verbundenen ZellenImportTableOptions.CheckMergedCells Eigentum. Wenn die Excel-Vorlage verbundene Zellen enthält, legen Sie den Wert von festImportTableOptions.CheckMergedCellsEigenschaft auf wahr. Übergeben Sie dieImportTableOptions Objekt zusammen mit der Liste der Spalten/Eigenschaften an die Methode, um die gewünschte Liste der Objekte anzuzeigen. Das folgende Codebeispiel veranschaulicht die Verwendung vonImportTableOptions.CheckMergedCells -Eigenschaft zum Importieren von Daten aus benutzerdefinierten Objekten in verbundene Zellen. Bitte beachten Sie das angehängteQuelle Excel Datei und dieExcel ausgeben Datei als 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; }
}

Importieren aus DataTable

So importieren Sie Daten aus einerDatentabelle , Ruf den … anCells SammlungDatentabelle importieren Methode. Es gibt viele überladene Versionen derDatentabelle importieren-Methode, aber eine typische Überladung nimmt die folgenden Parameter an:

• Datentabelle , DieDatentabelle Objekt, aus dem Sie den Inhalt importieren.
• Feldname wird angezeigt , gibt an, ob die Namen derDatentabelleSpalten als erste Zeile in das Arbeitsblatt importiert werden sollen oder nicht.
• Zelle starten , steht für den Namen der Startzelle (z. B. “A1”), aus der der Inhalt der importiert werden sollDatentabelle.

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

Import aus dynamischem Objekt als Datenquelle

Aspose.Cells bietet Funktionen zum Arbeiten mit dynamischen Objekten als Datenquelle. Es hilft bei der Verwendung von Datenquellen, bei denen Eigenschaften dynamisch zu den Objekten hinzugefügt werden. Sobald die Eigenschaften zum Objekt hinzugefügt wurden, betrachtet Aspose.Cells den ersten Eintrag als Vorlage und behandelt den Rest entsprechend. Das heißt, wenn eine dynamische Eigenschaft nur zu einem ersten Element und nicht zu anderen Objekten hinzugefügt wird, geht Aspose.Cells davon aus, dass alle Elemente in der Sammlung gleich sein sollten.

In diesem Beispiel wird ein Vorlagenmodell verwendet, das zunächst nur zwei Variablen enthält. Diese Liste wird in eine Liste dynamischer Objekte umgewandelt. Dann wird ein zusätzliches Feld hinzugefügt und schließlich in die Arbeitsmappe geladen. Die Arbeitsmappe wählt nur die Werte aus, die in der Vorlagendatei XLSX enthalten sind. Diese Vorlagenarbeitsmappe verwendet intelligente Markierungen, die auch Parameter enthalten. Mit Parametern können Sie die Anordnung der Informationen ändern. Details zu den Smart Markern können folgendem Artikel entnommen werden:

Verwenden von Smart-Markern

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

        }
    }

}

Importieren aus DataColumn (.NET)

EINDatentabelleoderDatenansichtObjekt besteht aus einer oder mehreren Spalten. Entwickler können auch Daten aus jeder Spalte/Spalten der importierenDatentabelleoderDatenansichtdurch Anruf beimDaten importieren Methode derCellsSammlung. DasDaten importierenDie Methode akzeptiert einen Parameter vom TypImportTableOptions. DasImportTableOptions Klasse bietet aSpaltenindizes-Eigenschaft, die ein Array von Spaltenindizes akzeptiert.

Der unten angegebene Beispielcode demonstriert die Verwendung vonImportTableOptions.ColumnIndexes um ausgewählte Spalten zu importieren.

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

Importieren aus DataView (.NET)

So importieren Sie Daten aus einerDatenansicht , Ruf den … anCells SammlungDaten importieren Methode. Es gibt viele überladene Versionen derDaten importieren-Methode, aber die für DataView nimmt die folgenden Parameter an:

• Datenansicht: DasDatenansichtObjekt, aus dem Sie Inhalte importieren möchten.
• **Erste Reihe:**die Zeilennummer der ersten Zelle, in die die Daten importiert werden.
• **Erste Spalte:**die Spaltennummer der ersten Zelle, in die die Daten importiert werden.
• **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");

Importieren aus DataGrid (.NET)

Es ist möglich, Daten aus einem zu importierenDataGrid durch Anruf beimImportDataGrid Methode derCells Sammlung. Es gibt viele überladene Versionen derImportDataGrid-Methode, aber eine typische Überladung nimmt die folgenden Parameter an:

• Datenraster , DieDataGridObjekt, aus dem Sie Inhalte importieren.
• Zeilennummerdie Zeilennummer der ersten Zelle, in die die Daten importiert werden.
• Spaltennummer, die Spaltennummer der ersten Zelle, in die die Daten importiert werden.
• Zeilen einfügen, eine boolesche Eigenschaft, die angibt, ob zusätzliche Zeilen zum Arbeitsblatt hinzugefügt werden sollen, um 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");

Importieren aus GridView

So importieren Sie Daten aus einerRasteransicht Kontrolle, rufen Sie dieGridView importieren Methode derCellsSammlung.

Aspose.Cells ermöglicht es uns, HTML formatierte Werte beim Importieren von Daten in die Tabelle zu respektieren. Wenn die HTML-Analyse beim Importieren von Daten aktiviert ist, konvertiert Aspose.Cells die HTML in die entsprechende Zellenformatierung.

Importieren von HTML formatierten Daten

Aspose.Cells bietet eineCellsKlasse, die sehr nützliche Methoden zum Importieren von Daten aus externen Datenquellen bereitstellt. Dieser Artikel zeigt, wie Sie HTML formatierten Text beim Importieren von Daten parsen und HTML in formatierte Zellenwerte konvertieren.

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

Importieren von Daten von JSON

Aspose.Cells bietet eineJsonUtility Klasse für die Verarbeitung JSON.JsonUtility Klasse hat eineDaten importieren Methode zum Importieren von JSON-Daten. Aspose.Cells bietet auch eineJsonLayoutOptions Klasse, die die Optionen des JSON-Layouts darstellt. DasDaten importierenMethode akzeptiertJsonLayoutOptionsals Parameter. DasJsonLayoutOptionsKlasse bietet die folgenden Eigenschaften.

• ArrayAsTable: Gibt an, ob das Array als Tabelle verarbeitet werden soll oder nicht.
• ConvertNumericOderDate: Ruft einen Wert ab oder legt einen Wert fest, der angibt, ob die Zeichenfolge in JSON in eine Zahl oder ein Datum konvertiert werden soll.
• Datumsformat: Ruft das Format des Datumswerts ab und legt es fest.
• ArrayTitle ignorieren: Gibt an, ob der Titel ignoriert werden soll, wenn die Eigenschaft des Objekts ein Array ist
• Null ignorieren: Gibt an, ob der Nullwert ignoriert werden soll oder nicht.
• Objekttitel ignorieren: Gibt an, ob der Titel ignoriert werden soll, wenn die Eigenschaft des Objekts ein Objekt ist.
• Zahlenformat: Ruft das Format des numerischen Werts ab und legt es fest.
• Titelstil: Ruft den Stil des Titels ab und legt ihn fest.

Der unten angegebene Beispielcode demonstriert die Verwendung vonJsonUtility undJsonLayoutOptions Klassen 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");

Themen vorantreiben

• Geben Sie beim Importieren von Daten in ein Arbeitsblatt Formelfelder an
• Verschieben Sie die erste Zeile nach unten, wenn Sie Cells Datentabellenzeilen einfügen