Intelligentes Importieren und Platzieren von Daten mit intelligenten Markern

Einführung

Intelligente Marker werden verwendet, um Aspose.Cells mitzuteilen, welche Informationen in eine Microsoft Excel-Designer-Tabelle eingegeben werden sollen. Intelligente Marker ermöglichen es Ihnen, Vorlagen zu erstellen, die nur bestimmte Informationen und Formatierungen enthalten.

Designer-Tabelle & Intelligente Marker

Designer-Tabellen sind Standard-Excel-Dateien, die visuelle Formatierungen, Formeln und intelligente Marker enthalten. Sie können intelligente Marker enthalten, die auf eine oder mehrere Datenquellen verweisen, z. B. Informationen aus einem Projekt und Informationen zu relevanten Kontakten. Intelligente Marker werden in die Zellen geschrieben, in denen Sie die Informationen platzieren möchten.

Alle intelligenten Marker beginnen mit &=. Ein Beispiel für einen Datenmarker ist &=Party.FullName. Wenn der Datenmarker zu mehr als einem Element führt, beispielsweise einer vollständigen Zeile, werden die folgenden Zeilen automatisch nach unten verschoben, um Platz für die neuen Informationen zu schaffen. Somit können Zwischensummen und Summen in die Zeile unmittelbar nach dem Datenmarker platziert werden, um Berechnungen auf Basis der eingefügten Daten durchzuführen. Um Berechnungen auf den eingefügten Zeilen durchzuführen, verwenden Sie dynamische Formeln.

Intelligente Marker bestehen aus den Teilen Datenquelle und Feldname für die meisten Informationen. Spezielle Informationen können auch mit Variablen und Variablenarrays übergeben werden. Variablen füllen immer nur eine Zelle aus, während Variablenarrays mehrere Zellen ausfüllen können. Verwenden Sie nur einen Datenmarker pro Zelle. Nicht verwendete intelligente Marker werden entfernt.

Intelligente Marker können auch Parameter enthalten. Parameter ermöglichen es Ihnen, zu ändern, wie die Informationen dargestellt werden. Sie werden am Ende des intelligenten Markers in Klammern als durch Kommas getrennte Liste angehängt.

Intelligente Marker-Optionen

&=Datenquelle.Feldname &=[Datenquelle].[Feldname] &=$Variablenname &=$VariablenArray &==DynamischeFormel &=&=WiederholendeDynamischeFormel

Parameter

Folgende Parameter sind erlaubt:

• noadd - Füge keine zusätzlichen Zeilen hinzu, um Daten anzupassen.
• skip:n - Überspringe n Zeilen für jede Datensatzzeile.
• ascending:n oder descending:n - Sortiere Daten in Smart-Markern. Wenn n 1 ist, ist die Spalte der erste Schlüssel des Sortierers. Die Daten werden nach der Verarbeitung der Datenquelle sortiert. Beispiel: &=Tabelle1.Feld3(aufsteigend:1).
• horizontal - Schreibe Daten von links nach rechts anstatt von oben nach unten.
• numeric - Konvertiere Text in eine Zahl, wenn möglich.
• shift - Verschiebt nach unten oder rechts und erstellt zusätzliche Zeilen oder Spalten, um die Daten anzupassen. Der Shift-Parameter funktioniert auf die gleiche Weise wie in Microsoft Excel. Zum Beispiel, wenn Sie in Microsoft Excel einen Bereich von Zellen auswählen, mit der rechten Maustaste darauf klicken und Einfügen auswählen und Zellen nach unten verschieben oder Zellen nach rechts verschieben oder andere Optionen angeben. Kurz gesagt, der shift-Parameter erfüllt die gleiche Funktion für vertikale/übliche (von oben nach unten) oder horizontale (von links nach rechts) intelligente Markierungen.
• copystyle - Kopiere den Zellstil der Basiszelle in alle Zellen dieser Spalte.

Die Parameter noadd und skip können kombiniert werden, um Daten in alternierende Zeilen einzufügen. Da die Vorlage von unten nach oben verarbeitet wird, sollten Sie noadd in der ersten Zeile hinzufügen, um zu verhindern, dass zusätzliche Zeilen vor der alternierenden Zeile eingefügt werden.

Wenn Sie mehrere Parameter haben, trennen Sie diese mit Kommas, aber ohne Leerzeichen: parameterA,parameterB,parameterC.

Die folgenden Screenshots zeigen, wie Daten in jeder zweiten Zeile eingefügt werden.

Vorlagendatei	Ausgabedatei

Dynamische Formeln

Dynamische Formeln ermöglichen es Ihnen, Excel-Formeln in Zellen einzufügen, auch wenn die Formel auf Zeilen verweist, die während des Exportvorgangs eingefügt werden. Dynamische Formeln können für jede eingefügte Zeile wiederholt werden oder nur die Zelle verwenden, in der der Datenmarker platziert ist.

Dynamische Formeln ermöglichen die folgenden zusätzlichen Optionen:

• r - Aktuelle Zeilennummer.
• 2, -1 - Versatz zur aktuellen Zeilennummer.

Zum Beispiel:

 &=&=B{-1}/C{-1}~(skip:1)

Im dynamischen Formelmarker steht “-1” für den Versatz zur aktuellen Zeile in den Spalten B und C, die für die Divisionsoperation festgelegt werden, der Überspringparameter beträgt eine Zeile. Darüber hinaus sollten wir das folgende Zeichen angeben:

 "~"

als Trennzeichen, um weitere Parameter in dynamischen Formeln anzuwenden.

Die folgenden Screenshots veranschaulichen eine wiederholende dynamische Formel und das resultierende Excel-Arbeitsblatt.

Vorlagendatei	Ausgabedatei
Die Zelle “C1” enthält die Formel = A1*B1, die Zelle “C2” enthält = A2*B2 und die Zelle “C3” enthält = A3*B3.

Es ist sehr einfach, die Smart Marker zu verarbeiten. Im folgenden Beispielcode wird gezeigt, wie dynamische Formeln in Smart Markers verwendet werden. Wir laden die Template-Datei und erstellen Testdaten, um die Marker zu verarbeiten, um Daten in die Zellen gegen den Marker einzufügen.

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

//set the file path of designer spreadsheet containing smart markers
string designerFile = "templateDynamicFormulas.xlsx";

//create your data set
DataSet dataset = new DataSet();
DataTable dt = new DataTable("Answer");
dataset.Tables.Add(dt);

DataColumn price = new DataColumn("Price", typeof(double));
DataColumn amount = new DataColumn("Amount", typeof(int));
dt.Columns.Add(price);
dt.Columns.Add(amount);

dt.Rows.Add(100.00, 2);
dt.Rows.Add(75.25, 3);
dt.Rows.Add(25.00, 5);
            
if (designerFile != null)
{

    // Instantiating a WorkbookDesigner object
    WorkbookDesigner designer = new WorkbookDesigner();

    // Open a designer spreadsheet containing smart markers
    designer.Workbook = new Workbook(designerFile);

    // Set the data source for the designer spreadsheet
    designer.SetDataSource(dataset);

    // Process the smart markers
    designer.Process();               
}

Verwendung von Variablen Arrays

Im folgenden Beispielcode wird gezeigt, wie Variable Arrays in Smart Markers verwendet werden. Wir platzieren einen Variablen-Array-Marker in Zelle A1 des ersten Arbeitsblatts der Arbeitsmappe dynamisch, der einen String von Werten enthält, die wir für den Marker festlegen, verarbeiten die Marker, um Daten in die Zellen gegen den Marker einzufügen. Schließlich speichern wir die Excel-Datei.

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

// Instantiate a new Workbook designer.
WorkbookDesigner report = new WorkbookDesigner();

// Get the first worksheet of the workbook.
Worksheet w = report.Workbook.Worksheets[0];

// Set the Variable Array marker to a cell.
// You may also place this Smart Marker into a template file manually in Ms Excel and then open this file via Workbook.
w.Cells["A1"].PutValue("&=$VariableArray");

// Set the DataSource for the marker(s).
report.SetDataSource("VariableArray", new string[] { "English", "Arabic", "Hindi", "Urdu", "French" });

// Process the markers.
report.Process(false);

// Save the Excel file.
report.Workbook.Save(dataDir + "output.xlsx");

Daten gruppieren

In einigen Excel-Berichten ist es möglicherweise erforderlich, die Daten in Gruppen aufzuteilen, um sie einfacher zu lesen und zu analysieren. Ein Hauptzweck, Daten in Gruppen aufzuteilen, besteht darin, Berechnungen (Zusammenfassungsoperationen) für jede Gruppe von Datensätzen auszuführen.

Aspose.Cells Smart Marker ermöglicht es Ihnen, Daten nach Feldern zu gruppieren und Zusammenfassungszeilen zwischen Datensätzen oder Datengruppen zu platzieren. Wenn beispielsweise die Daten nach Kunden.CustomerID gruppiert werden, können Sie jedes Mal einen Zusammenfassungsdatensatz hinzufügen, wenn sich die Gruppe ändert.

Parameter

Im Folgenden sind einige der Smart-Marker-Parameter aufgeführt, die für die Gruppierung von Daten verwendet werden.

group:normal/merge/repeat

Wir unterstützen drei Arten von Gruppen, zwischen denen Sie wählen können.

• normal - Der Gruppenwert wird nicht für die entsprechenden Datensätze in der Spalte wiederholt; stattdessen wird er einmal pro Datengruppe gedruckt.
• merge - Das gleiche Verhalten wie beim normalen Parameter, außer dass die Zellen im Gruppenwert für jede Gruppeneinstellung zusammengeführt werden.
• repeat - Der Gruppenwert wird für die entsprechenden Datensätze wiederholt.

Zum Beispiel: &=Kunden.KundenID(group:merge)

skip

Überspringt eine bestimmte Anzahl von Zeilen nach jeder Gruppe.

Zum Beispiel: &=Mitarbeiter.MitarbeiterID(group:normal,skip:1)

subtotalN

Führt eine Zusammenfassungsoperation für ein spezifisches Felddatum in Bezug auf ein Gruppenfeld durch. Das N stellt Zahlen zwischen 1 und 11 dar, die die Funktion spezifizieren, die beim Berechnen von Zwischensummen innerhalb einer Liste von Daten verwendet wird. (1=DURCHSCHNITT, 2=ANZAHL, 3=ANZAHL2, 4=MAX, 5=MIN,…9=SUMME usw.) Siehe die Zwischensumme-Referenz in der Hilfe von Microsoft Excel für weitere Details.

Das Format gibt tatsächlich an: subtotalN:Verweis, wobei Verweis sich auf die Gruppierungs-Spalte bezieht.

Zum Beispiel,

• &=Products.Units(subtotal9:Products.ProductID) legt die Zusammenfassungsfunktion auf das Units Feld in Bezug auf das ProductID Feld in der Tabelle Products fest.
• &=Tabx.Col3(subtotal9:Tabx.Col1) legt die Zusammenfassungsfunktion auf das Col3 Feld gruppiert nach Col1 in der Tabelle Tabx fest.
• &=Table1.ColumnD(subtotal9:Table1.ColumnA&Table1.ColumnB) legt die Zusammenfassungsfunktion auf das ColumnD Feld gruppiert nach ColumnA und ColumnB in der Tabelle Table1 fest.

Dieses Beispiel zeigt einige der Gruppierungsparameter in Aktion. Es verwendet die Microsoft Access-Datenbank Northwind.mdb und extrahiert Daten aus der Tabelle “Order Details”. Wir erstellen eine Designer-Datei namens SmartMarker_Designer.xls in Microsoft Excel und fügen Smart Marker in verschiedene Zellen in Arbeitsblättern ein. Die Marker werden verarbeitet, um die Arbeitsblätter auszufüllen. Die Daten werden anhand eines Gruppenfelds platziert und organisiert.

Die Designer-Datei hat zwei Arbeitsblätter. Im ersten Arbeitsblatt fügen wir Smart Marker mit Gruppierungsparametern gemäß dem untenstehenden Screenshot ein. Drei Smart Marker (mit Gruppierungsparametern) werden platziert: &=[Order Details].OrderID(group:merge,skip:1), &=[Order Details].Quantity(subtotal9:Order Details.OrderID), und &=[Order Details].UnitPrice(subtotal9:Order Details.OrderID) gehen in A5, B5 und C5 jeweils.

Das erste Arbeitsblatt in der Datei SmartMarker_Designer.xls, komplett mit Smart Markern
Im zweiten Arbeitsblatt der Designer-Datei fügen wir einige weitere Smart Marker ein, wie in der Abbildung unten gezeigt. Wir platzieren die folgenden Smart Marker:
&=[Order Details].OrderID(group:normal),
&=[Order Details].Quantity,
&=[Order Details].UnitPrice,
&=&=B(r)*C(r), und
&=subtotal9:Order Details.OrderID in A5, B5, C5, D5 und C6 jeweils.

Das zweite Arbeitsblatt der Datei SmartMarker_Designer.xls, zeigt gemischte Smart Marker.
Hier ist der im Beispiel verwendete Quellcode.

private void SmartMarkers_GroupingData()
{
    //Examples-CSharp-SmartMarkers-GroupingData-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 a connection object, specify the provider info and set the data source.
    OleDbConnection con = new OleDbConnection("provider=microsoft.jet.oledb.4.0;data source=" + dataDir + "Northwind.mdb");

    // Open the connection object.
    con.Open();

    // Create a command object and specify the SQL query.
    OleDbCommand cmd = new OleDbCommand("Select * from [Order Details]", con);

    // Create a data adapter object.
    OleDbDataAdapter da = new OleDbDataAdapter();

    // Specify the command.
    da.SelectCommand = cmd;

    // Create a dataset object.
    DataSet ds = new DataSet();

    // Fill the dataset with the table records.
    da.Fill(ds, "Order Details");

    // Create a datatable with respect to dataset table.
    DataTable dt = ds.Tables["Order Details"];

    // Create WorkbookDesigner object.
    WorkbookDesigner wd = new WorkbookDesigner();

    // Open the template file (which contains smart markers).
    wd.Workbook = new Workbook(dataDir + "Designer.xlsx");

    // Set the datatable as the data source.
    wd.SetDataSource(dt);

    // Process the smart markers to fill the data into the worksheets.
    wd.Process(true);

    // Save the excel file.
    wd.Workbook.Save(dataDir + "output.xlsx");
}


class OleDbCommand
{
    private string p;
    private OleDbConnection con;

    public OleDbCommand(string p, OleDbConnection con)
    {
        // TODO: Complete member initialization
        this.p = p;
        this.con = con;
    }
}

class OleDbConnection
{
    private string p;

    public OleDbConnection(string p)
    {
        // TODO: Complete member initialization
        this.p = p;
    }

    internal void Open()
    {

    }
}

class OleDbDataAdapter
{
    public OleDbCommand SelectCommand { get; set; }

    internal void Fill(System.Data.DataSet ds, string p)
    {

    }
}

Wenn Sie eigene benutzerdefinierte Bezeichnungen zu den Zwischensummenzeilen hinzufügen möchten oder das Feld mit einer Bezeichnung verketten möchten, z.B. “Gesamtsumme der Bestellungen”, bietet Aspose.Cells die Attribute Label und LabelPosition, damit Sie Ihre benutzerdefinierten Bezeichnungen in den Smart Markern platzieren können, während Sie mit den Zwischensummenzeilen in Gruppendaten verketten. Lesen Sie das Dokument, wie benutzerdefinierte Bezeichnungen hinzugefügt werden können, um mit den Zwischensummenzeilen in Smart Markern zu verketten, als Referenz.

Verwendung anonymer Typen oder benutzerdefinierter Objekte

Aspose.Cells unterstützt auch anonyme Typen oder benutzerdefinierte Objekte in Smart Markern. Das folgende Beispiel zeigt, wie dies funktioniert. Für den Import von Daten aus dynamischen Objekten mithilfe von Smart Markern besuchen Sie den folgenden Artikel:

Importieren aus dynamischem Objekt als Datenquelle

private void SmartMarkers_UsingAnonymousTypes()
{
    // 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);

    // Instantiate the workbookdesigner object.
    WorkbookDesigner report = new WorkbookDesigner();
    // Get the first worksheet(default sheet) in the workbook.
    Aspose.Cells.Worksheet sheet = report.Workbook.Worksheets[0];

    // Input some markers to the cells.
    sheet.Cells["A1"].PutValue("Name");
    sheet.Cells["B1"].PutValue("Age");
    sheet.Cells["A2"].PutValue("&=MyProduct.Name");
    sheet.Cells["B2"].PutValue("&=MyProduct.Age");

    // Instantiate the list collection based on the custom class.
    IList<Person> list = new List<Person>();
    // Provide values for the markers using the custom class object.
    list.Add(new Person("Simon", 30));
    list.Add(new Person("Johnson", 33));

    // Set the data source.
    report.SetDataSource("MyProduct", list);

    // Process the markers.
    report.Process(false);

    // Save the excel file.
    report.Workbook.Save(dataDir + "Smart Marker Customobjects.xls");
}


// Definition of Custom class.
public class Person
{
    private string m_Name;

    public string Name
    {
        get { return m_Name; }
        set { m_Name = value; }
    }
    private int m_Age;

    public int Age
    {
        get { return m_Age; }
        set { m_Age = value; }
    }
    internal Person(string name, int age)
    {
        this.m_Name = name;
        this.m_Age = age;
    }
}      

Bildmarkierungen

Aspose.Cells Smart Marker unterstützt auch Bild-Marker. In diesem Abschnitt wird gezeigt, wie Sie Bilder mithilfe von Smart Markern einfügen.

Bildparameter

Smart Marker-Parameter zur Verwaltung von Bildern.

• Bild:PassendZurZelle - Das Bild automatisch an die Zeilenhöhe und Spaltenbreite der Zelle anpassen.
• Bild:Skalierung N - Höhe und Breite auf N Prozent skalieren.
• Bild:Breite:Nin&Höhe:Nin - Das Bild N Zoll hoch und N Zoll breit darstellen. Sie können auch die Positionen Links und Oben angeben (in Punkten).

Hier ist der im Beispiel verwendete Quellcode.

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

// Get the image data.
byte[] imageData = File.ReadAllBytes(dataDir+ "aspose-logo.jpg");
// Create a datatable.
DataTable t = new DataTable("Table1");
// Add a column to save pictures.
DataColumn dc = t.Columns.Add("Picture");
// Set its data type.
dc.DataType = typeof(object);

// Add a new new record to it.
DataRow row = t.NewRow();
row[0] = imageData;
t.Rows.Add(row);

// Add another record (having picture) to it.
imageData = File.ReadAllBytes(dataDir+ "image2.jpg");
row = t.NewRow();
row[0] = imageData;
t.Rows.Add(row);

// Create WorkbookDesigner object.
WorkbookDesigner designer = new WorkbookDesigner();
// Open the template Excel file.
designer.Workbook = new Workbook(dataDir+ "TestSmartMarkers.xlsx");
// Set the datasource.
designer.SetDataSource(t);
// Process the markers.
designer.Process();
// Save the Excel file.
designer.Workbook.Save(dataDir+ "output.xls");

Verwendung von verschachtelten Objekten

Aspose.Cells unterstützt verschachtelte Objekte in Smart Markern, die verschachtelten Objekte sollten einfach sein. Wir verwenden eine einfache Vorlagendatei. Sehen Sie die Designer-Tabelle, die einige verschachtelte Smart Marker enthält.

Die erste Arbeitsmappe der SM_NestedObjects.xlsx Datei zeigt verschachtelte Smart Marker.
Das folgende Beispiel zeigt, wie dies funktioniert.

private void SmartMarkers_UsingNestedObjects()
{
    // 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);

    // ****** Program ******

    // Initialize WorkbookDesigner object
    WorkbookDesigner designer = new WorkbookDesigner();
    // Load the template file
    designer.Workbook = new Workbook(dataDir + "SM_NestedObjects.xlsx");
    // Instantiate the List based on the class
    System.Collections.Generic.ICollection<Individual> list = new System.Collections.Generic.List<Individual>();
    // Create an object for the Individual class
    Individual p1 = new Individual("Damian", 30);
    // Create the relevant Wife class for the Individual
    p1.Wife = new Wife("Dalya", 28);
    // Create another object for the Individual class
    Individual p2 = new Individual("Mack", 31);
    // Create the relevant Wife class for the Individual
    p2.Wife = new Wife("Maaria", 29);
    // Add the objects to the list
    list.Add(p1);
    list.Add(p2);
    // Specify the DataSource
    designer.SetDataSource("Individual", list);
    // Process the markers
    designer.Process(false);
    // Save the Excel file.
    designer.Workbook.Save(dataDir + "output.xlsx");
}

class Individual
{

    private String m_Name;

    public String Name
    {
        get { return m_Name; }
        set { m_Name = value; }
    }
    private int m_Age;

    public int Age
    {
        get { return m_Age; }
        set { m_Age = value; }
    }
    internal Individual(string name, int age)
    {
        this.Name = name;
        this.Age = age;
    }
    private Wife m_Wife;

    public Wife Wife
    {
        get { return m_Wife; }
        set { m_Wife = value; }
    }

}
public class Wife
{
    public Wife(string name, int age)
    {
        this.m_name = name;
        this.m_age = age;
    }

    private string m_name;

    public string Name
    {
        get { return m_name; }
        set { m_name = value; }
    }
    private int m_age;

    public int Age
    {
        get { return m_age; }
        set { m_age = value; }
    }
}

Verwendung von generischer Liste als verschachteltes Objekt

Aspose.Cells unterstützt nun auch die Verwendung einer generischen Liste als verschachteltes Objekt. Bitte überprüfen Sie den Screenshot der generierten Ausgabee Excel-Datei mit dem folgenden Code. Wie im Screenshot zu sehen ist, enthält ein Lehrerobjekt mehrere verschachtelte Schülerobjekte.

// 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);
            Workbook workbook = new Workbook();

            // Create a designer workbook

            // Workbook workbook = new Workbook();
            Worksheet worksheet = workbook.Worksheets[0];

            worksheet.Cells["A1"].PutValue("Teacher Name");
            worksheet.Cells["A2"].PutValue("&=Teacher.Name");

            worksheet.Cells["B1"].PutValue("Teacher Age");
            worksheet.Cells["B2"].PutValue("&=Teacher.Age");

            worksheet.Cells["C1"].PutValue("Student Name");
            worksheet.Cells["C2"].PutValue("&=Teacher.Students.Name");

            worksheet.Cells["D1"].PutValue("Student Age");
            worksheet.Cells["D2"].PutValue("&=Teacher.Students.Age");

            // Apply Style to A1:D1
            Range range = worksheet.Cells.CreateRange("A1:D1");
            Style style = workbook.CreateStyle();
            style.Font.IsBold = true;
            style.ForegroundColor = Color.Yellow;
            style.Pattern = BackgroundType.Solid;
            StyleFlag flag = new StyleFlag();
            flag.All = true;
            range.ApplyStyle(style, flag);

            // Initialize WorkbookDesigner object
            WorkbookDesigner designer = new WorkbookDesigner();

            // Load the template file
            designer.Workbook = workbook;

            System.Collections.Generic.List<Teacher> list = new System.Collections.Generic.List<Teacher>();

            // Create an object for the Teacher class
            Teacher h1 = new Teacher("Mark John", 30);

            // Create the relevant student objects for the Teacher object
            h1.Students = new List<Person>();
            h1.Students.Add(new Person("Chen Zhao", 14));
            h1.Students.Add(new Person("Jamima Winfrey", 18));
            h1.Students.Add(new Person("Reham Smith", 15));

            // Create another object for the Teacher class
            Teacher h2 = new Teacher("Masood Shankar", 40);

            // Create the relevant student objects for the Teacher object
            h2.Students = new List<Person>();
            h2.Students.Add(new Person("Karishma Jathool", 16));
            h2.Students.Add(new Person("Angela Rose", 13));
            h2.Students.Add(new Person("Hina Khanna", 15));

            // Add the objects to the list
            list.Add(h1);
            list.Add(h2);

            // Specify the DataSource
            designer.SetDataSource("Teacher", list);

            // Process the markers
            designer.Process();

            // Autofit columns
            worksheet.AutoFitColumns();

            // Save the Excel file.
            designer.Workbook.Save(dataDir + "output.xlsx");

Verwendung der HTML-Eigenschaften von Smart Markern

The following sample code explains the use of HTML property of the Smart Markers. When it will be processed, it will show “World” in “Hello World” as bold because of HTML tag.

// 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);
Workbook workbook = new Workbook();
WorkbookDesigner designer = new WorkbookDesigner();
designer.Workbook = workbook;
workbook.Worksheets[0].Cells["A1"].PutValue("&=$VariableArray(HTML)");
designer.SetDataSource("VariableArray", new String[] { "Hello <b>World</b>", "Arabic", "Hindi", "Urdu", "French" });
designer.Process();
workbook.Save(dataDir + "output.xls");

Nicht Zeile für Zeile

Die derzeitige Standardverarbeitungsmethode besteht darin, Smartmaker Zeile für Zeile zu verarbeiten. Manchmal müssen jedoch die Smart Marker derselben Datentabelle zusammen verarbeitet werden, unabhängig Wenn sie sich in der gleichen Zeile befinden oder nicht, müssen Sie einen benannten Bereich “_CellsSmartMarkers” angeben und WorkbookDesigner.LineByLine als falsch festlegen, bevor Sie die Verarbeitung aufrufen.

||

string dataDir = RunExamples.GetDataDir(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
Workbook workbook = new Workbook();
Style style = workbook.CreateStyle();
style.Pattern = BackgroundType.Solid;
style.ForegroundColor = Color.Black;
style.Font.Color = Color.White;
// Create a designer workbook

// Workbook workbook = new Workbook();
Worksheet worksheet = workbook.Worksheets[0];

worksheet.Cells["A1"].PutValue("Teacher Name");
worksheet.Cells["A1"].SetStyle(style);
worksheet.Cells["A2"].PutValue("&=Teacher.Name");

worksheet.Cells["B1"].PutValue("Teacher Age");
worksheet.Cells["B1"].SetStyle(style);
worksheet.Cells["B2"].PutValue("&=Teacher.Age");

worksheet.Cells["A3"].PutValue("Student Name");
worksheet.Cells["A3"].SetStyle(style);
worksheet.Cells["A4"].PutValue("&=Teacher.Students.Name");

worksheet.Cells["B3"].PutValue("Student Age");
worksheet.Cells["B3"].SetStyle(style);
worksheet.Cells["B4"].PutValue("&=Teacher.Students.Age");
worksheet.AutoFitColumns();
//A named range "_CellsSmartMarkers" must be added for checking which range contains all smart markers about a table.
worksheet.Cells.CreateRange("A1:B4").Name = "_CellsSmartMarkers";
// Initialize WorkbookDesigner object
WorkbookDesigner designer = new WorkbookDesigner();

// Load the template file
designer.Workbook = workbook;

System.Collections.Generic.List<Teacher> list = new System.Collections.Generic.List<Teacher>();

// Create an object for the Teacher class
Teacher h1 = new Teacher("Mark John", 30);

// Create the relevant student objects for the Teacher object
h1.Students = new List<Person>();
h1.Students.Add(new Person("Chen Zhao", 14));
h1.Students.Add(new Person("Jamima Winfrey", 18));
h1.Students.Add(new Person("Reham Smith", 15));

// Create another object for the Teacher class
Teacher h2 = new Teacher("Masood Shankar", 40);

// Create the relevant student objects for the Teacher object
h2.Students = new List<Person>();
h2.Students.Add(new Person("Karishma Jathool", 16));
h2.Students.Add(new Person("Angela Rose", 13));
h2.Students.Add(new Person("Hina Khanna", 15));

// Add the objects to the list
list.Add(h1);
list.Add(h2);

// Specify the DataSource
designer.SetDataSource("Teacher", list);
designer.LineByLine = false;
// Process the markers
designer.Process();

// Autofit columns
worksheet.AutoFitColumns();

// Save the Excel file.
designer.Workbook.Save(dataDir + "output.xlsx");


public class Person
{
    private string m_Name;

    public string Name
    {
        get { return m_Name; }
        set { m_Name = value; }
    }
    private int m_Age;

    public int Age
    {
        get { return m_Age; }
        set { m_Age = value; }
    }
    internal Person(string name, int age)
    {
        this.m_Name = name;
        this.m_Age = age;
    }
}

public class Teacher
{
    private string m_Name;

    public string Name
    {
        get { return m_Name; }
        set { m_Name = value; }
    }
    private int m_Age;

    public int Age
    {
        get { return m_Age; }
        set { m_Age = value; }
    }

    private List<Person> mStudents;
    public List<Person> Students
    {
        get { return mStudents; }
        set { mStudents = value; }
    }
    public Teacher(string name, int age)
    {
        this.Name = name;
        this.Age = age;
    }
}

Benachrichtigungen beim Zusammenführen von Daten mit Smart Markern erhalten

Manchmal ist es erforderlich, Benachrichtigungen über den Zellenverweis oder den speziellen Smart Marker zu erhalten, der vor Abschluss verarbeitet wird. Dies kann mit der Eigenschaft WorkbookDesigner.CallBack und ISmartMarkerCallBack erreicht werden.

Erweiterte Themen

• Anonymes oder benutzerdefiniertes Objekt zu SmartMarkern hinzufügen
• Automatisches Ausfüllen von Smart Marker-Daten in anderen Arbeitsblättern, wenn die Daten zu groß sind
• Formatierung von Smart Markers
• Benachrichtigungen beim Zusammenführen von Daten mit Smart Markern erhalten
• Benutzerdefinierte Datenquelle für WorkbookDesigner festlegen
• Führende Apostrophzeichen in Zellen anzeigen
• Verwenden des Formelparameters im Smart Marker-Feld
• Verwenden von Bildmarkern beim Gruppieren von Daten in Smart Markern