Importer et placer intelligemment des données avec des marqueurs intelligents

Introduction

Marqueurs intelligentssont utilisés pour indiquer au Aspose.Cells quelles informations placer dans une feuille de calcul de concepteur Excel Microsoft. Les marqueurs intelligents vous permettent de créer des modèles contenant uniquement des informations et une mise en forme spécifiques.

Tableur Designer et marqueurs intelligents

Les feuilles de calcul Designer sont des fichiers Excel standard qui contiennent une mise en forme visuelle, des formules et des marqueurs intelligents. Ils peuvent contenir des marqueurs intelligents qui font référence à une ou plusieurs sources de données, telles que des informations d’un projet et des informations sur des contacts associés. Des marqueurs intelligents sont écrits dans les cellules où vous voulez les informations.

Tous les marqueurs intelligents commencent par &=. Un exemple de marqueur de données est &=Party.FullName. Si le marqueur de données génère plusieurs éléments, par exemple une ligne complète, les lignes suivantes sont automatiquement déplacées vers le bas pour faire de la place aux nouvelles informations. Ainsi, les sous-totaux et les totaux peuvent être placés sur la ligne immédiatement après le marqueur de données pour effectuer des calculs basés sur les données insérées. Pour effectuer des calculs sur les lignes insérées, utilisezformules dynamiques.

Les marqueurs intelligents consistent enla source de données etnom de domainepièces pour la plupart des informations. Des informations spéciales peuvent également être transmises avec des variables et des tableaux de variables. Les variables remplissent toujours une seule cellule alors que les tableaux de variables peuvent en remplir plusieurs. N’utilisez qu’un marqueur de données par cellule. Les marqueurs intelligents inutilisés sont supprimés.

Le marqueur intelligent peut également contenir des paramètres. Les paramètres permettent de modifier la présentation des informations. Ils sont ajoutés à la fin du marqueur intelligent entre parenthèses sous forme de liste séparée par des virgules.

Options de marqueur intelligent

&=DataSource.FieldName &=[Source de données].[Nom du champ]&=$NomVariable &=$VariableArray &==Formule Dynamique &=&=RépéterDynamicFormula

Paramètres

Les paramètres suivants sont autorisés :

• pas d’ajout - N’ajoutez pas de lignes supplémentaires pour ajuster les données.
• sauter :n - Sauter n nombre de lignes pour chaque ligne de données.
• ascendant : n ou alorsdescendant:n - Trier les données dans des marqueurs intelligents. Si n vaut 1, alors la colonne est la première clé du trieur. Les données sont triées après le traitement de la source de données. Par exemple : &=Table1.Field3(croissant : 1).
• horizontal - Écrivez les données de gauche à droite, au lieu de haut en bas.
• numérique - Convertissez le texte en nombre si possible.
• changement - Maj vers le bas ou vers la droite, créant des lignes ou des colonnes supplémentaires pour s’adapter aux données. Le paramètre de décalage fonctionne de la même manière que dans Microsoft Excel. Par exemple, dans Microsoft Excel, lorsque vous sélectionnez une plage de cellules, cliquez avec le bouton droit et sélectionnezInsérer et précisezdécaler les cellules vers le bas, décaler les cellules vers la droite et d’autres options. Bref, lechangement remplit la même fonction pour les marqueurs intelligents verticaux/normaux (de haut en bas) ou horizontaux (de gauche à droite).
• style de copie - Copiez le style de la cellule de base dans toutes les cellules de cette colonne.

Les paramètres noadd et skip peuvent être combinés pour insérer des données sur des lignes alternées. Étant donné que le modèle est traité de bas en haut, vous devez ajouter noadd sur la première ligne pour éviter que des lignes supplémentaires ne soient insérées avant l’autre ligne.

Si vous avez plusieurs paramètres, séparez-les par des virgules, mais sans espace : paramètreA, paramètreB, paramètreC

Les captures d’écran suivantes montrent comment insérer des données sur une ligne sur deux.

Fichier de modèle	Fichier de sortie

Formules dynamiques

Les formules dynamiques vous permettent d’insérer des formules Excel dans des cellules même lorsque la formule fait référence à des lignes qui seront insérées lors du processus d’exportation. Les formules dynamiques peuvent se répéter pour chaque ligne insérée ou utiliser uniquement la cellule dans laquelle le marqueur de données est placé.

Les formules dynamiques permettent les options supplémentaires suivantes :

• r - Numéro de ligne actuel.
• 2, -1 - Décalage par rapport au numéro de ligne actuel.

Par exemple:

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

Dans le marqueur de formule dynamique, “-1” indique le décalage par rapport à la ligne actuelle dans les colonnes B et C respectivement qui sera défini pour l’opération de division, le paramètre de saut est d’une ligne. De plus, nous devons spécifier le caractère suivant :

 "~"

comme caractère de séparation pour appliquer d’autres paramètres dans les formules dynamiques.

Les captures d’écran suivantes illustrent une formule dynamique répétitive et la feuille de calcul Excel qui en résulte.

Fichier de modèle	Fichier de sortie
Cell “C1” contient la formule**= A1*B1** , la cellule “C2” contient**= A2*B2** et la cellule “C3” contient**= A3*B3**.

Il est très facile de traiter les marqueurs intelligents. Ce qui suit sont deux extraits de code, un en C# et un en VB, qui montrent comment cela se fait.

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

Utilisation de tableaux variables

L’exemple de code suivant montre comment utiliser les tableaux de variables dans les marqueurs intelligents. Nous plaçons dynamiquement un marqueur de tableau variable dans la cellule A1 de la première feuille de calcul du classeur qui contient une chaîne de valeurs que nous avons définie pour le marqueur, traitons les marqueurs pour remplir les données dans les cellules contre le marqueur. Enfin, nous enregistrons le fichier Excel.

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

Regroupement de données

Dans certains rapports Excel, vous devrez peut-être diviser les données en groupes pour en faciliter la lecture et l’analyse. L’un des principaux objectifs de la répartition des données en groupes est d’exécuter des calculs (effectuer des opérations récapitulatives) sur chaque groupe d’enregistrements.

Les marqueurs intelligents Aspose.Cells vous permettent de regrouper les données par champs et de placer des lignes récapitulatives entre les ensembles de données ou les groupes de données. Par exemple, si vous regroupez des données par Customers.CustomerID, vous pouvez ajouter un enregistrement récapitulatif chaque fois que le groupe change.

Paramètres

Voici quelques-uns des paramètres de marqueur intelligent utilisés pour regrouper les données.

groupe : normal/fusionner/répéter

Nous prenons en charge trois types de groupes parmi lesquels vous pouvez choisir.

• Ordinaire - La valeur de regroupement par champ(s) n’est pas répétée pour les enregistrements correspondants dans la colonne ; au lieu de cela, ils sont imprimés une fois par groupe de données.
• fusionner - Le même comportement que pour le paramètre normal, sauf qu’il fusionne les cellules dans le(s) champ(s) grouper par pour chaque ensemble de groupe.
• répéter - La valeur de regroupement par champ(s) est répétée pour les enregistrements correspondants.

Par exemple : &=Customers.CustomerID(group:merge)

sauter

Ignore un nombre spécifié de lignes après chaque groupe.

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

sous-totalN

Effectue une opération récapitulative pour les données d’un champ spécifié liées à un groupe par champ. Le N représente des nombres entre 1 et 11 qui spécifient la fonction utilisée lors du calcul des sous-totaux dans une liste de données. (1=AVERAGE, 2=COUNT, 3=COUNTA, 4=MAX, 5=MIN,…9=SUM etc.) Reportez-vous à la référence de sous-total dans l’aide d’Excel Microsoft pour plus de détails.

Le format indique en fait que : subtotalN:Ref où Ref fait référence à la colonne group by.

Par exemple,

• &=Products.Units(subtotal9:Products.ProductID) spécifie la fonction récapitulative lorsUnités domaine par rapport à laID produit champ dans leDes produits table.
• &=Tabx.Col3(subtotal9:Tabx.Col1) spécifie la fonction récapitulative sur leCol3 groupe de champs parCol1 dans la tableTabx.
• &=Table1.ColumnD(subtotal9:Table1.ColumnA&Table1.ColumnB) spécifie la fonction récapitulative surColonneD groupe de champs parColonneA etColonneB dans la tableTableau 1.

Cet exemple montre certains des paramètres de regroupement en action. Il utilise la base de données Access Northwind.mdb Microsoft et extrait les données de la table nommée “Détails de la commande”. Nous créons un fichier de concepteur appelé SmartMarker_Designer.xls dans Microsoft Excel et plaçons des marqueurs intelligents dans diverses cellules des feuilles de calcul. Les marqueurs sont traités pour remplir les feuilles de travail. Les données sont placées et organisées par un champ de groupe.

Le fichier de concepteur comporte deux feuilles de calcul. Dans le premier, nous mettons des marqueurs intelligents avec des paramètres de regroupement, comme indiqué dans la capture d’écran ci-dessous. Trois marqueurs intelligents (avec des paramètres de regroupement) sont placés : &=[Détails de la commande].ID de commande(groupe : fusionner, ignorer : 1), &=[Order Details].Quantity(subtotal9:Order Details.OrderID), et &=[Order Details].UnitPrice(subtotal9:Order Details.OrderID) va respectivement dans A5, B5 et C5.

La première feuille de calcul du fichier SmartMarker_Designer.xls, complète avec des marqueurs intelligents
Dans la deuxième feuille de calcul du fichier de concepteur, nous mettons quelques marqueurs intelligents supplémentaires, comme indiqué dans la figure ci-dessous. Nous plaçons les marqueurs intelligents suivants :
&=[Détails de la commande].ID de commande(groupe :normal),
&=[Détails de la commande].Quantité,
&=[Détails de la commande].Prix unitaire,
&=&=B(r)*C(r), et
&=sous-total9 :Détails de la commande.ID de commande dans A5, B5, C5, D5 et C6 respectivement.

La deuxième feuille de calcul du fichier SmartMarker_Designer.xls, montrant des marqueurs intelligents mixtes.
Voici le code source utilisé dans l’exemple.

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)
    {

    }
}

Si vous devez ajouter vos propres étiquettes personnalisées aux lignes récapitulatives ou si vous souhaitez concaténer le nom du champ avec une étiquette, par exemple “Sous-total des commandes”, Aspose.Cells vous fournit les attributs Label et LabelPosition, vous pouvez donc placer vos étiquettes personnalisées dans le Smart Marqueurs lors de la concaténation avec les lignes de sous-total dans le regroupement des données. Consultez le document sur la façon d’ajouter des étiquettes personnalisées à concaténer avec les lignes de sous-total dans les marqueurs intelligents pour votre référence.

Utilisation de types anonymes ou d’objets personnalisés

Aspose.Cells prend également en charge les types anonymes ou les objets personnalisés dans les marqueurs intelligents. L’exemple qui suit montre comment cela fonctionne. Pour importer des données à partir d’objets dynamiques à l’aide de marqueurs intelligents, consultez l’article suivant :

Importation à partir d’un objet dynamique en tant que source de données

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

Marqueurs d’images

Les marqueurs intelligents Aspose.Cells prennent également en charge les marqueurs d’image. Cette section vous montre comment insérer des images à l’aide de marqueurs intelligents.

Paramètres d’images

Paramètres de marqueurs intelligents pour la gestion des images.

• Image : Ajuster à la cellule - Ajustez automatiquement l’image à la hauteur de ligne et à la largeur de colonne de la cellule.
• Image : ÉchelleN - Mettre à l’échelle la hauteur et la largeur à N pour cent.
• Image : largeur : Nin et hauteur : Nin - Rendez l’image N pouces de haut et N pouces de large. Vous pouvez également spécifier les positions Gauche et Haut (en points).

Voici le code source utilisé dans l’exemple.

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

Utilisation d’objets imbriqués

Aspose.Cells prend en charge les objets imbriqués dans les marqueurs intelligents, les objets imbriqués doivent être simples. Nous utilisons un simple fichier modèle. Consultez la feuille de calcul du concepteur qui contient des marqueurs intelligents imbriqués.

La première feuille de calcul du fichier SM_NestedObjects.xlsx montrant les marqueurs intelligents imbriqués.
L’exemple qui suit montre comment cela fonctionne.

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

Utilisation de la liste générique comme objet imbriqué

Aspose.Cells prend désormais également en charge l’utilisation de la liste générique en tant qu’objet imbriqué. Veuillez vérifier la capture d’écran du fichier Excel de sortie généré avec le code suivant. Comme vous pouvez le voir sur la capture d’écran, un objet Enseignant contient plusieurs objets Étudiant imbriqués.

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

Utilisation de la propriété HTML des marqueurs intelligents

L’exemple de code suivant explique l’utilisation de la propriété HTML des marqueurs intelligents. Lorsqu’il sera traité, il affichera “Monde” dans “Hello World” en gras à cause de HTML étiquette.

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

Pas ligne par ligne

La méthode de traitement par défaut actuelle consiste à traiter smartmaker ligne par ligne. Mais parfois, les marqueurs intelligents d’une même table de données doivent être traités ensemble, peu importe s’ils sont dans la même ligne ou non, vous devez spécifier une plage nommée “_CellsSmartMarkers” et spécifier WorkbookDesigner.LineByLine comme false avant d’appeler le traitement.

||

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

Obtenir des notifications lors de la fusion de données avec des marqueurs intelligents

Parfois, il peut être nécessaire d’obtenir les notifications concernant la référence de cellule ou le marqueur intelligent particulier en cours de traitement avant l’achèvement. Ceci peut être réalisé en utilisant la propriété WorkbookDesigner.CallBack et ISmartMarkerCallBack

Sujets avancés

• Ajout d’un objet anonyme ou personnalisé dans les SmartMarkers
• Remplir automatiquement les données du marqueur intelligent dans d’autres feuilles de calcul si les données sont trop volumineuses
• Formatage des marqueurs intelligents
• Obtenir des notifications lors de la fusion de données avec des marqueurs intelligents
• Définir une source de données personnalisée pour WorkbookDesigner
• Afficher l’apostrophe de tête dans les cellules
• Utilisation du paramètre Formule dans le champ Smart Marker
• Utilisation de marqueurs d’image lors du regroupement de données dans des marqueurs intelligents