Structures internes

Les scripts contiennent des références aux classes .Net System, aux classes .Net EDV, aux fonctions et objets disponibles dans l'évaluateur de script et aux variables EDV.
Les objets peuvent être du type JSObject (edv, session, arguments).
Des objets sont issus de classes statiques (edvTools, edvVisual, ...).
Des mots-clés et éléments de syntaxe sont pré-interprétés (me, ., .., :).

Côté Serveur

Il est important de comprendre la structure des objets et du processus d'interprétation des scripts. Cela implique de savoir ce que va devenir le script que nous saisissons et comment il va être interprété.

Une variable EDV est au moins deux objets : EDVServer.Variable et un objet contenu dans la propriété Value de la variable.

Une confusion vient de la syntaxe JScript pour EDV qui pré-interprète les chemins EDV et utilise la propriété Value par défaut.
Ce "par défaut" signifie "en l'absence de :Nom_de_propriété en fin de nom de variable".

Pour obtenir la référence de l'objet Variable, la syntaxe JScript pour EDV est :Object.

Les trois expressions me:Object, :Object et edvSender renvoient l'objet de type EDV.EDVServer.Variable servant de référence au script en cours d'évaluation. Seul edvSender est un objet réel, les deux premières expressions sont pré-interprétées.

Une ambiguïté supplémentaire vient de l'utilisation de : en début d'expression pour dire "une propriété de me" mais aussi "une sous-variable de me" (me === edvSender).
Ainsi :Name peut vouloir dire edvSender.Name ou edvar(".MyDom.MyVar.Name").Value si une sous-variable Name existe.

Lors de la pré-interprétation, les chemins EDV sont inclus dans un appel de fonction edvar (et edvarvalue pour obtenir directement la valeur (de la propriété Value) en un seul appel).

Autre source de confusion, les propriétés des variables et les sous-variables.
Ces propriétés et/ou sous-variables peuvent être des accesseurs simples à une propriété de l'objet-valeur de la variable.
Par exemple, toutes les variables ont une propriété Description (héritée de IVariable) et elle peuvent créer une sous-variable _Description. Un mécanisme interne synchronise la valeur de la propriété Description de la variable parente avec la valeur de la variable enfant _Description
Voir ci-dessous les Propriétés d'une variable.


Exemple d'une variable .MyDom.MyDataTable de type EDVType.DataTable.

Type
.Net
  JScript pour EDV
EDVJScript dans EDVServer.exe
  JScript pré-interprété
Microsoft.JScript.Eval() dans EDVJScript.dll
  C#
Variable dans EDVServer.exe
 
EDV.EDVServer.VarDataTable  

.MyDom["MyDataTable"]
   = edvnew(EDVType.DataTable)

 

edvar(".MyDom")["MyDataTable"]
   = edvnew(EDVType.DataTable)

  //this===.MyDom
Variable.FromClassName(".MyDom.MyDataTable", "VarDataTable", EDVType.DataTable, new DataTable());
 
EDV.EDVServer.VarDataTable  

.MyDom.MyDataTable:Object
edvar(".MyDom.MyDataTable")

 

edvar(".MyDom.MyDataTable)
edvar(".MyDom.MyDataTable")

  //this===EDVServer.Variables
this[".MyDom.MyDataTable"]
 
EDV.EDVServer.VarDataTable  

..MyDom["MyDataTable"]

 

edvar(".MyDom")["MyDataTable"]

  //this===.MyDom
edvServer.Vars[this.Name + "MyDataTable"]
 
System.Data.DataTable   .MyDom.MyDataTable:Value   edvar(".MyDom.MyDataTable").Value   //this===.MyDom.MyDataTable
this.Value
 
System.Data.DataTable   .MyDom.MyDataTable   edvarvalue(".MyDom.MyDataTable")   //this===.MyDom.MyDataTable
this.Value
 
System.Data.DataTable   (.MyDom.MyDataTable)   (edvarvalue(".MyDom.MyDataTable"))   //this===.MyDom.MyDataTable
this.Value
 
System.Data.DataRowCollection   .MyDom.MyDataTable:Rows   edvar(".MyDom.MyDataTable").Rows   //this===.MyDom.MyDataTable
(this.Value as DataTable).Rows
 
IEnumerator<System.Data.DataRow>   .MyDom.DataTable:Select   edvar(".MyDom.MyDataTable").Select   //this===.MyDom.MyDataTable
(this.Value as DataTable).Select().GetEnumerator()
 
System.Data.DataRow[]   (.MyDom.DataTable).Select()   (edvarvalue(".MyDom.MyDataTable")).Select()   //this===.MyDom.MyDataTable
this.Value //.Select() managé par JScript
 
System.Integer   .MyDom.DataTable:RowsCount   edvar(".MyDom.MyDataTable").RowsCount  

//this===.MyDom.MyDataTable
(this.Value as DataTable).RowsCount
(this.Value as DataTable).VarRowsCount.Value

 
System.Integer   .MyDom.DataTable.RowsCount   edvarvalue(".MyDom.MyDataTable.RowsCount")  

//this===.MyDom.MyDataTable.RowsCount
this.Value

 
System.String   (.MyDom.DataTable).TableName   edvarvalue(".MyDom.MyDataTable").TableName   //this===.MyDom.MyDataTable
this.Value //.TableName managé par JScript
 
System.String   .MyDom.DataTable:Script   edvarv(".MyDom.MyDataTable").Script  

//this===.MyDom.MyDataTable
this.Script

 
System.String   .MyDom.DataTable._Script   edvarvalue(".MyDom.MyDataTable._Script")   //this===.MyDom.MyDataTable._Script
this.Value
 

RowsCount est une propriété de la classe VarDataTable.
C'est aussi une sous-variable potentielle de la variable de type EDVType.DataTable.

TableName n'est accessible que par l'objet System.Data.DataTable.

Script est une propriété de la classe Variable.
_Script est une sous-variable potentielle de n'importe quelle variable. Elle a pour valeur le script (propriété Script) de sa variable parente.
Vous pouvez créer une sous-variable Script qui n'a aucun lien avec le script de sa variable parente.
Il faut alors distinguer me:Script et :Script, équivalents à edvSender.Script et edvar(edvSender.Name + ".Script").Value
me:_Script est une erreur de syntaxe car la classe Variable n'expose pas de propriété publique _Script.
C'est edvSender.VarScript qui contient la variable _Script si elle existe. Alors, edvSender.VarScript === edvSender["VarScript"] et edvSender.Script == edvSender["VarScript"].Value
Il n'est pas très fréquent qu'une variable expose à la fois une propriété sous la forme de sa valeur et sous la forme d'une variable. Si elle le fait, c'est pour un besoin interne et pour héritage.

Propriétés d'une variable

La notion de Propriété d'une variable est extensible aux propriétés des classes .Net et aux sous-variables.
Toute classe (.Net, en l'occurence) a ses propriétés comme ses méthodes et événements.
En créant des sous-variables à une variable EDV, vous les concevez comme des propriétés, selon la conception fonctionnelle de votre projet.
Ces sous-variables sont plus ou moins rattachées à leurs parents, selon la classe et le type des variables.
Dans le serveur, la classe Variable et celles qui en héritent peuvent appliquer à leurs propriétés un attribut du type EDVariableAttribute. Ceci provoque le référencement de la propriété de la classe comme sous-variable EDV potentielle.
Le paramètre AutoCreate = true provoque la création systématique de la sous-variable lors de la création de l'instance de la variable. Si la sous-variable existe déjà, celle-ci est rattachée à son parent.
Le paramètre Name = "PropSubVar" définit le nom de la sous-variable.
Le paramètre Name = "PropSubVar.Enabled" définit une sous-sous-variable rattachée à son grand-parent. La gestion des ancètres/descendants ne va pas plus en profondeur.
On parle donc des propriétés d'une variable à la fois par les propriétés de sa classe et des sous-variables en lien avec celle-ci.
La classe a besoin d'une propriété pour son fonctionnement interne mais c'est vous qui décidez de disposer ou pas d'une sous-variable représentant la valeur de la propriété de la classe (sauf si AutoCreate = true auquel cas elle est toujours générée).

Code C# dans la classe EDV.EDVServer.Variable

internal String _Script = "";

[EDVariableAttribute("_Script", "", null, EDVType.Code, AutoCreate = false)]
public String Script {
   get { return _Script; }
   set { ValueFromScript(PrepareScript(_Script = value)); }
}


[EDVariableAttribute("_Script", "", null, EDVType.Code, AutoCreate = false)]
public Variable VarScript { get; set; }

La double définition de l'attribut permet de disposer d'une référence directe à la sous-variable _Script quand elle est créée.
Vous noterez que le nom de la variable créée est différent du nom de la propriété de la classe.
Le développeur C# a le choix d'utiliser une des deux méthodes ou les deux à la fois.



Côté Client WinForm

Rappelons que le pré-interpréteur et l'interpréteur JScript côté Client n'est pas le même que côté Serveur.

Les scripts Client analysent les noms de variables comme des contrôles et commencent toujours par .. ou : .

Dans les scripts côté client, donc dans les “WinForm”, les contrôles EDV implémentent l’interface IEDVControl qui propose Variable et Client comme propriétés.
edvctrl(“:ctrlButton”).Variable vient de la variable WIN.ctrlButton.@
Dans les scripts côté-client, le mot-clé eventSender est le contrôle qui a déclenché l'événement auquel est rattaché le script. Pour savoir si un contrôle est lié à une variable, le test est
if(eventSender instanceof IEDVControl && eventSender.Variable != null)
   edvInfo = eventSender.Variable.Value + “ / “ + eventSender.Text;

(tous les contrôles ont une propriété Text, à priori)
(dans les scripts serveur, le mot-clé équivalent est edvSender, c’est un objet du type Variable).
 
Une autre subtilité est que les éléments contenus dans un Visual ne sont pas forcément de type Control, mais tous sont de type Component. Un abus de langage courant est de parler de Control à la place de Component, mais c’est vrai à 99%.
Un Component qui n’est pas un Control n’a pas de représentation visuelle, sauf en Design. Par exemple, un Timer, un ToolTip (info-bulle), un OpenFileDialog (fenêtre de sélection de fichier), ...

 


A voir :

Les scripts JScript
Les variables EDV dans les scripts
Les noms de variables