Intelligentes Importieren und Platzieren von Daten mit Smart Markern

Einführung

Intelligente Markierungenwerden verwendet, um Aspose.Cells mitzuteilen, welche Informationen in einer Microsoft Excel-Designertabelle platziert werden sollen. Mit intelligenten Markierungen können Sie Vorlagen erstellen, die nur bestimmte Informationen und Formatierungen enthalten.

Designer-Tabellenkalkulation und intelligente Markierungen

Designer-Arbeitsblätter sind standardmäßige Excel-Dateien, die visuelle Formatierungen, Formeln und intelligente Markierungen enthalten. Sie können intelligente Markierungen enthalten, die auf eine oder mehrere Datenquellen verweisen, z. B. Informationen aus einem Projekt und Informationen zu verwandten Kontakten. Intelligente Markierungen werden in die Zellen geschrieben, in denen Sie die Informationen wünschen.

Alle intelligenten Markierungen beginnen mit &=. Ein Beispiel für eine Datenmarkierung ist &=Party.FullName. Wenn die Datenmarkierung mehr als ein Element ergibt, z. B. eine vollständige Zeile, werden die folgenden Zeilen automatisch nach unten verschoben, um Platz für die neuen Informationen zu schaffen. Somit können Zwischensummen und Gesamtsummen unmittelbar nach der Datenmarkierung in die Zeile eingefügt werden, um Berechnungen basierend auf den eingefügten Daten durchzuführen. Um Berechnungen für die eingefügten Zeilen durchzuführen, verwenden Siedynamische Formeln.

Intelligente Markierungen bestehen aus derDatenquelle undFeldnameTeile für die meisten Informationen. Bei Variablen und Variablenarrays können auch spezielle Informationen übergeben werden. Variablen füllen immer nur eine Zelle, während Variablenarrays mehrere füllen können. Verwenden Sie nur einen Datenmarker pro Zelle. Nicht verwendete Smart-Marker werden entfernt.

Smart Marker kann auch Parameter enthalten. Mit Parametern können Sie die Anordnung der Informationen ändern. Sie werden als kommagetrennte Liste in Klammern an das Ende des Smart-Markers angehängt.

Smart-Marker-Optionen

&=Datenquelle.Feldname &=[Datenquelle].[Feldname]&=$VariablenName &=$VariableArray &==DynamischeFormel &=&=DynamischeFormel wiederholen

Parameter

Folgende Parameter sind erlaubt:

• noadd - Fügen Sie keine zusätzlichen Zeilen hinzu, um Daten anzupassen.
• überspringen: n - Überspringen Sie n Zeilen für jede Datenzeile.
• aufsteigend: n oderabsteigend: n - Daten in Smartmarkern sortieren. Wenn n 1 ist, dann ist die Spalte der erste Schlüssel des Sortierers. Die Daten werden nach Verarbeitung der Datenquelle sortiert. Beispiel: &=Tabelle1.Feld3(aufsteigend:1).
• horizontal - Schreiben Sie Daten von links nach rechts, anstatt von oben nach unten.
• numerisch - Text wenn möglich in Zahlen umwandeln.
• Schicht - Verschieben Sie nach unten oder rechts und erstellen Sie zusätzliche Zeilen oder Spalten, um die Daten anzupassen. Der Shift-Parameter funktioniert genauso wie in Microsoft Excel. Wenn Sie beispielsweise in Microsoft Excel einen Zellbereich auswählen, klicken Sie mit der rechten Maustaste und wählen Sie ausEinfügung und spezifizierenZellen nach unten verschieben, Zellen nach rechts verschieben und andere Optionen. Kurz gesagt, dieSchicht Der Parameter erfüllt die gleiche Funktion für vertikale/normale (von oben nach unten) oder horizontale (von links nach rechts) Smartmarker.
• Kopierstil - Kopieren Sie den Stil der Basiszelle in alle Zellen in dieser Spalte.

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

Wenn Sie mehrere Parameter haben, trennen Sie sie mit einem Komma, aber ohne Leerzeichen: ParameterA,ParameterB,ParameterC

Die folgenden Screenshots zeigen, wie Daten in jede zweite Zeile eingefügt werden.

Vorlagendatei	Ausgabedatei

Dynamische Formeln

Mit dynamischen Formeln können Sie Excel-Formeln in Zellen einfügen, selbst wenn die Formel auf Zeilen verweist, die während des Exportvorgangs eingefügt werden. Dynamische Formeln können sich für jede eingefügte Zeile wiederholen oder nur die Zelle verwenden, in der die Datenmarkierung 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)

In der dynamischen Formelmarkierung bezeichnet “-1” den Versatz zur aktuellen Zeile in den B- bzw. C-Spalten, der für die Divisionsoperation eingestellt wird, der Skip-Parameter ist eine Zeile. Außerdem sollten wir das folgende Zeichen angeben:

 "~"

als Trennzeichen, um weitere Parameter in dynamische Formeln zu übernehmen.

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

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

Die Verarbeitung der Smartmarker ist sehr einfach. Was folgt, sind zwei Codeausschnitte, einer in C# und einer in VB, die zeigen, wie es gemacht 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);

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

Verwenden von Variablen-Arrays

Der folgende Beispielcode zeigt, wie Variablen-Arrays in Smart Markern verwendet werden. Wir platzieren dynamisch eine variable Array-Markierung in der A1-Zelle des ersten Arbeitsblatts der Arbeitsmappe, die eine Zeichenfolge von Werten enthält, die wir für die Markierung festlegen, verarbeiten die Markierungen, um Daten in die Zellen gegen die Markierung zu füllen. Abschließend 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 müssen Sie die Daten möglicherweise in Gruppen aufteilen, um sie leichter lesen und analysieren zu können. Einer der Hauptzwecke für das Aufteilen von Daten in Gruppen ist das Ausführen von Berechnungen (Durchführen von Zusammenfassungsoperationen) für jede Gruppe von Datensätzen.

Aspose.Cells Mit intelligenten Markierungen können Sie Daten nach Feldern gruppieren und Zusammenfassungszeilen zwischen Datensätzen oder Datengruppen platzieren. Wenn Sie beispielsweise Daten nach Customers.CustomerID gruppieren, können Sie jedes Mal, wenn sich die Gruppe ändert, einen Zusammenfassungsdatensatz hinzufügen.

Parameter

Im Folgenden sind einige der Smart-Marker-Parameter aufgeführt, die zum Gruppieren von Daten verwendet werden.

Gruppe:normal/zusammenführen/wiederholen

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

• normal - Der Gruppieren-nach-Feld(er)-Wert wird für die entsprechenden Datensätze in der Spalte nicht wiederholt; stattdessen werden sie einmal pro Datengruppe gedruckt.
• verschmelzen - Dasselbe Verhalten wie beim normalen Parameter, außer dass die Zellen in den Gruppieren-nach-Feldern für jeden Gruppensatz zusammengeführt werden.
• wiederholen - Der Gruppieren-nach-Feld(er)-Wert wird für die entsprechenden Datensätze wiederholt.

Zum Beispiel: &=Kunden.KundenID(Gruppe:Merge)

überspringen

Überspringt eine angegebene Anzahl von Zeilen nach jeder Gruppe.

Beispiel: &=Employees.EmployeeID(group:normal,skip:1)

ZwischensummeN

Führt eine Zusammenfassungsoperation für bestimmte Felddaten aus, die sich auf ein Gruppieren-nach-Feld beziehen. Das N steht für Zahlen zwischen 1 und 11, die die Funktion angeben, die beim Berechnen von Zwischensummen innerhalb einer Datenliste verwendet wird. (1=MITTELWERT, 2=ZAHL, 3=ZAHLA, 4=MAX, 5=MIN,…9=SUMME usw.) Weitere Einzelheiten finden Sie in der Zwischensummen-Referenz in der Excel-Hilfe Microsoft.

Das Format lautet tatsächlich wie folgt: subtotalN:Ref wobei Ref sich auf die Gruppierung nach Spalte bezieht.

Zum Beispiel,

• &=Products.Units(subtotal9:Products.ProductID) gibt die Zusammenfassungsfunktion anEinheiten Feld in Bezug auf dieProdukt ID Feld imProdukte Tisch.
• &=Tabx.Col3(subtotal9:Tabx.Col1) gibt die Zusammenfassungsfunktion anSpalte3 Feldgruppe nachSpalte1 in der TabelleTabx.
• &=Table1.ColumnD(subtotal9:Table1.ColumnA&Table1.ColumnB) gibt die Zusammenfassungsfunktion anSpalteD Feldgruppe nachSpalteA undSpalteB in der TabelleTabelle 1.

Dieses Beispiel zeigt einige der Gruppierungsparameter in Aktion. Es verwendet die Access-Datenbank Northwind.mdb Microsoft und extrahiert Daten aus der Tabelle mit dem Namen “Bestelldetails”. Wir erstellen eine Designer-Datei mit dem Namen SmartMarker_Designer.xls in Microsoft Excel und platzieren intelligente Markierungen in verschiedenen Zellen in Arbeitsblättern. Die Markierungen werden verarbeitet, um die Arbeitsblätter zu füllen. Die Daten werden durch ein Gruppenfeld platziert und organisiert.

Die Designerdatei hat zwei Arbeitsblätter. In der ersten setzen wir intelligente Markierungen mit Gruppierungsparametern, wie im folgenden Screenshot gezeigt. Drei Smart-Marker (mit Gruppierungsparametern) werden platziert: &=[Bestelldetails].OrderID(group:merge,skip:1), &=[Bestelldetails].Menge(Zwischensumme9:Bestelldetails.Bestell-ID) und &=[Bestelldetails].UnitPrice(subtotal9:Order Details.OrderID) geht jeweils in A5, B5 und C5.

Das erste Arbeitsblatt in der Datei SmartMarker_Designer.xls, komplett mit intelligenten Markierungen
Im zweiten Arbeitsblatt der Designer-Datei setzen wir einige weitere intelligente Markierungen, wie in der Abbildung unten gezeigt. Wir setzen die folgenden Smartmarker:
&=[Bestelldetails].OrderID(group:normal),
&=[Bestelldetails].Menge,
&=[Bestelldetails].Einheitspreis,
&=&=B(r)*C(r) und
&=subtotal9:Order Details.OrderID jeweils in A5, B5, C5, D5 und C6.

Das zweite Arbeitsblatt der Datei SmartMarker_Designer.xls mit gemischten Smart-Markern.
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 Ihre eigenen benutzerdefinierten Beschriftungen zu den Zusammenfassungszeilen hinzufügen müssen oder den Feldnamen mit einer Beschriftung verketten möchten, z. B. „Zwischensumme der Bestellungen“, stellt Aspose.Cells Ihnen die Attribute „Label“ und „LabelPosition“ zur Verfügung, sodass Sie Ihre benutzerdefinierten Beschriftungen im Smart platzieren können Markierungen beim Verketten mit den Zwischensummenzeilen beim Gruppieren von Daten. Siehe das Dokument zum Hinzufügen von benutzerdefinierten Beschriftungen zum Verketten mit den Zwischensummenzeilen in intelligenten Markierungen als Referenz.

Verwenden von anonymen Typen oder benutzerdefinierten Objekten

Aspose.Cells unterstützt auch anonyme Typen oder benutzerdefinierte Objekte in Smartmarkern. Das folgende Beispiel zeigt, wie das funktioniert. Informationen zum Importieren von Daten aus dynamischen Objekten mithilfe von Smart Markers finden Sie im folgenden Artikel:

Import 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 Intelligente Markierungen unterstützen auch Bildmarkierungen. Dieser Abschnitt zeigt Ihnen, wie Sie Bilder mit intelligenten Markierungen einfügen.

Bildparameter

Smart-Marker-Parameter zum Verwalten von Bildern.

• Bild:FitToCell - Passen Sie das Bild automatisch an die Zeilenhöhe und Spaltenbreite der Zelle an.
• Bild:ScaleN - Skalieren Sie Höhe und Breite auf N Prozent.
• Bild:Breite:Nin&Höhe:Nin - Rendern Sie das Bild N Zoll hoch und N Zoll breit. Sie können auch die Positionen Links und Oben (in Punkten) angeben.

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

Verwenden von verschachtelten Objekten

Aspose.Cells unterstützt verschachtelte Objekte in Smartmarkern, die verschachtelten Objekte sollten einfach sein. Wir verwenden eine einfache Vorlagendatei. Sehen Sie sich das Designer-Arbeitsblatt an, das einige verschachtelte intelligente Markierungen enthält.

Das erste Arbeitsblatt der Datei SM_NestedObjects.xlsx mit verschachtelten Smart-Markern.
Wie das funktioniert, zeigt das folgende Beispiel.

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

Generische Liste als verschachteltes Objekt verwenden

Aspose.Cells unterstützt jetzt auch die Verwendung einer generischen Liste als verschachteltes Objekt. Bitte überprüfen Sie den Screenshot der Excel-Ausgabedatei, die mit dem folgenden Code generiert wurde. Wie Sie im Screenshot sehen können, enthält ein Teacher-Objekt mehrere verschachtelte Student-Objekte.

// 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 Eigenschaft HTML von Smart Markers

Der folgende Beispielcode erläutert die Verwendung der Eigenschaft HTML der Smart Marker. Wenn es verarbeitet wird, wird “World” in “Hello World” wegen HTML fett angezeigt Schild.

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

Die aktuelle Standardverarbeitungsmethode besteht darin, Smartmaker Zeile für Zeile zu verarbeiten. Aber manchmal müssen die intelligenten Markierungen derselben Datentabelle zusammen verarbeitet werden, egal Wenn sie sich in derselben Zeile befinden oder nicht, müssen Sie einen benannten Bereich „_CellsSmartMarkers“ angeben und WorkbookDesigner.LineByLine als „false“ angeben, 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 erhalten, während Daten mit Smart Markern zusammengeführt werden

Manchmal kann es erforderlich sein, die Benachrichtigungen über den Zellbezug oder den bestimmten Smart Marker, der verarbeitet wird, vor dem Abschluss zu erhalten. Dies kann mit der WorkbookDesigner.CallBack-Eigenschaft und ISmartMarkerCallBack erreicht werden

Themen vorantreiben

• Hinzufügen von anonymen oder benutzerdefinierten Objekten zu SmartMarkern
• Smart-Marker-Daten automatisch in andere Arbeitsblätter einfügen, wenn die Daten zu groß sind
• Formatieren von intelligenten Markierungen
• Benachrichtigungen erhalten, während Daten mit Smart Markern zusammengeführt werden
• Legen Sie eine benutzerdefinierte Datenquelle für WorkbookDesigner fest
• Führenden Apostroph in Zellen anzeigen
• Verwenden des Formelparameters im Smart Marker-Feld
• Verwenden von Bildmarkierungen beim Gruppieren von Daten in Smart-Markierungen