Afficher : Delphi C++
Préférences d'affichage

Liaison par programmation des objets créés

De RAD Studio

Remonter à Tutoriel : Utilisation de LiveBindings par programmation


Attention : La méthode par programmation décrite ici n'est PAS le moyen standard d'implémenter les expressions de liaison. Typiquement, vous devriez utiliser l'inspecteur d'objets (la méthode standard) à la conception. Vous ne devriez jamais avoir besoin d'utiliser la méthode de création d'expressions de liaison par programmation. Toutefois, ce tutoriel montre qu'il est possible de créer manuellement de telles expressions.


Pour obtenir des exemples d'utilisation de LiveBindings selon la méthode standard, voir :

Désormais, pour la partie liaison, vous devez créer une expression de liaison qui indique au moteur LiveBindings comment lier des objets entre eux, ainsi que les opérations à effectuer avec les propriétés liées.

L'extrait de code suivant montre comment lier les deux propriétés des objets d'entrée (MyObject1 et MyObject2) à l'objet de sortie (MyResultObject). La syntaxe est un peu volumineuse et elle sera expliquée ci-dessous, après l'extrait de code.

Delphi :

var
  BindingExpression1: TBindingExpression;
  BindingExpression2: TBindingExpression;
 
begin
  { a binding expression that binds the two Integer properties of the given objects }
  BindingExpression1 := TBindings.CreateManagedBinding(
    { inputs }
    [TBindings.CreateAssociationScope([
      Associate(MyObject1, 'o1'),
      Associate(MyObject2, 'o2')
      ])],
    'o1.IntegerValue + o2.IntegerValue',
    { outputs }
    [TBindings.CreateAssociationScope([
      Associate(MyResultObject, 'res')
      ])],
    'res.IntegerValue',
    nil);
 
  { a binding expression that binds the two String properties of the given objects }
  BindingExpression2 := TBindings.CreateManagedBinding(
    { inputs }
    [TBindings.CreateAssociationScope([
      Associate(MyObject1, 'o1'),
      Associate(MyObject2, 'o2')
      ])],
    'o1.StringValue + o2.StringValue',
    { outputs }
    [TBindings.CreateAssociationScope([
      Associate(MyResultObject, 'res')
      ])],
    'res.StringValue',
    nil);
end;

C++ :

TBindingExpression *BindingExpression1, *BindingExpression2;
 
OpenArray<_di_IScope>InputScopes
        (TBindings::CreateAssociationScope
        (OPENARRAY(TBindingAssociation, (Associate(MyObject1, "o1"),
        Associate(MyObject2, "o2")))));
OpenArray<_di_IScope>OutputScopes
        (TBindings::CreateAssociationScope
        (OPENARRAY(TBindingAssociation, (Associate(MyResultObject,
        "res")))));
 
BindingExpression1 = TBindings::CreateManagedBinding(InputScopes,
        InputScopes.GetHigh(), "o1.IntegerValue + o2.IntegerValue",
        OutputScopes, OutputScopes.GetHigh(), "res.IntegerValue", NULL);
 
BindingExpression2 = TBindings::CreateManagedBinding(InputScopes,
        InputScopes.GetHigh(), "o1.StringValue + o2.StringValue",
        OutputScopes, OutputScopes.GetHigh(), "res.StringValue", NULL);

La syntaxe ci-dessus est utilisée pour créer une expression de liaison managée. Pour de plus amples informations concernant les expressions de liaison managées, reportez-vous à la rubrique de référence API appropriée, System.Bindings.Helper.TBindings.CreateManagedBinding. Dans l'extrait de code ci-dessus, nous avons utilisé la deuxième méthode surchargée CreateManagedBinding pour créer une expression de liaison managée.

La syntaxe est similaire pour les deux expressions de liaison (qui affectent IntegerValue ou StringValue). Ainsi, seule la syntaxe de la première expression de liaison sera expliquée ci-dessous.

Le tableau des portées d'entrée (RealObject, ScriptObject) est donné comme suit :

Delphi :

[TBindings.CreateAssociationScope([
      Associate(MyObject1, 'o1'),
      Associate(MyObject2, 'o2')
      ])]

C++ :

OpenArray<_di_IScope>InputScopes
        (TBindings::CreateAssociationScope
        (OPENARRAY(TBindingAssociation, (Associate(MyObject1, "o1"),
        Associate(MyObject2, "o2")))));

L'expression de liaison pour la portée d'entrée est une simple addition des deux propriétés Integer des deux objets.

Delphi :

'o1.IntegerValue + o2.IntegerValue'

C++ :

"o1.IntegerValue + o2.IntegerValue"

L'examen de la syntaxe BindingExpression1 révèle que le tableau des portées de sortie et l'expression de liaison pour la portée de sortie sont similaires à la syntaxe décrite ci-dessus, mais ils affectent l'objet résultat (MyResultObject).

Pour une expression de liaison à évaluer et à compiler, donc utilisée, vous devez émettre une commande de notification. Quand la valeur spécifiée par une propriété d'un objet change, vous devez notifier le moteur de liaison à ce sujet. Ceci est effectué comme décrit dans l'extrait de code suivant.

Delphi :

{ if the IntegerValue or StringValue for MyObject1 changes, use the following lines of code }
TBindings.Notify(MyObject1, 'IntegerValue');
TBindings.Notify(MyObject1, 'StringValue');
 
{ if the IntegerValue or StringValue for MyObject2 changes, use the following lines of code }
TBindings.Notify(MyObject2, 'IntegerValue');
TBindings.Notify(MyObject2, 'StringValue');
 
{ or any other combination of the two above, depending on which value changes }

C++ :

// if the IntegerValue or StringValue for MyObject1 changes, use the following lines of code
TBindings::Notify(MyObject1, "IntegerValue");
TBindings::Notify(MyObject1, "StringValue");
 
// if the IntegerValue or StringValue for MyObject2 changes, use the following lines of code
TBindings::Notify(MyObject2, "IntegerValue");
TBindings::Notify(MyObject2, "StringValue");
 
// or any other combination of the two above, depending on which value changes

Suivant

Précédent

Outils personnels
Autres langues
Versions précédentes