Das gesamte Projekt und Interpretation der Ergebnisse

Aus Appmethod Topics
Wechseln zu: Navigation, Suche

Nach oben zu Tutorial: Programmgesteuerte Verwendung von LiveBinding


Achtung: Die hier beschriebene programmseitige Methode zum Implementieren von Bindungsausdrücken stellt NICHT das Standardverfahren dar. Normalerweise würden Sie den Objektinspektor (die Standardmethode) in einer grafischen Anwendung verwenden. Wahrscheinlich werden Sie die programmseitige Methode zum Erstellen von Bindungsausdrücken nie benötigen. In diesem Tutorial wird jedoch gezeigt, dass es möglich ist, solche Ausdrücke manuell zu erstellen.


Dieses Thema enthält das gesamte Listing des Projekts sowie die Interpretation der Ausgabeergebnisse der Konsole.

Das Projektlisting

Object Pascal:

program LiveBindingProgr;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.SysUtils,
  System.Bindings.Expression,
  System.Bindings.ObjEval,
  System.Bindings.Helper;

type
  TMyObject1 = class(TObject)
  private
    FIntegerValue: Integer;
    FStringValue: String;
  public
    property IntegerValue: Integer read FIntegerValue write FIntegerValue;
    property StringValue: String read FStringValue write FStringValue;
  end;

  TMyObject2 = class(TObject)
  private
    FIntegerValue: Integer;
    FStringValue: String;
  public
    property IntegerValue: Integer read FIntegerValue write FIntegerValue;
    property StringValue: String read FStringValue write FStringValue;
  end;

  TMyResultObject = class(TObject)
  private
    FIntegerValue: Integer;
    FStringValue: String;
  public
    property IntegerValue: Integer read FIntegerValue write FIntegerValue;
    property StringValue: String read FStringValue write FStringValue;
  end;

var
  MyObject1: TMyObject1;
  MyObject2: TMyObject2;
  MyResultObject: TMyResultObject;

  BindingExpression1: TBindingExpression;
  BindingExpression2: TBindingExpression;

begin
  MyObject1 := TMyObject1.Create;
  MyObject2 := TMyObject2.Create;
  MyResultObject := TMyResultObject.Create;
  try
    MyObject1.IntegerValue := 1;
    MyObject1.StringValue := 'LiveBinding ';

    MyObject2.IntegerValue := 2;
    MyObject2.StringValue := 'power.';

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

    TBindings.Notify(MyObject1, 'IntegerValue');
    TBindings.Notify(MyObject1, 'StringValue');

    Writeln('Result of add operation: ', MyResultObject.IntegerValue);
    Writeln(MyResultObject.StringValue);
    Readln;
  finally
    MyObject1.Free;
    MyObject2.Free;
    MyResultObject.Free;
  end;
end.
Tipp: Wenn Sie die Appmethod C++-Konsolenanwendung erstellen, müssen Sie als Ziel-Framework die VCL (Visual Component Library) wählen, damit das Projekt ordnungsgemäß compiliert und gelinkt werden kann.

C++:

#pragma hdrstop
#pragma argsused
#pragma explicit_rtti methods()

#include <tchar.h>
#include <stdio.h>

#include <System.Bindings.Expression.hpp>
#include <System.Bindings.Helper.hpp>

class TMyObject1 : public TObject {
private:
        Integer FIntegerValue;
        String FStringValue;

public:
        __property Integer IntegerValue = {
                read = FIntegerValue, write = FIntegerValue};
        __property String StringValue = {read = FStringValue, write = FStringValue};
};

class TMyObject2 : public TObject {
private:
        Integer FIntegerValue;
        String FStringValue;

public:
        __property Integer IntegerValue = {
                read = FIntegerValue, write = FIntegerValue};
        __property String StringValue = {read = FStringValue, write = FStringValue};
};

class TMyResultObject : public TObject {
private:
        Integer FIntegerValue;
        String FStringValue;

public:
        __property Integer IntegerValue = {
                read = FIntegerValue, write = FIntegerValue};
        __property String StringValue = {read = FStringValue, write = FStringValue};
};

int _tmain(int argc, _TCHAR* argv[]) {
        TMyObject1 *MyObject1;
        TMyObject2 *MyObject2;
        TMyResultObject *MyResultObject;

        TBindingExpression *BindingExpression1, *BindingExpression2;

        MyObject1 = new TMyObject1();
        MyObject2 = new TMyObject2();
        MyResultObject = new TMyResultObject();

        MyObject1->IntegerValue = 1;
        MyObject1->StringValue = "LiveBinding ";
        MyObject2->IntegerValue = 2;
        MyObject2->StringValue = "power.";

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

                        TBindings::Notify(MyObject1, "IntegerValue");
                        TBindings::Notify(MyObject1, "StringValue");

                        printf("Result of add operation: %d\n", MyResultObject->IntegerValue);
                        printf("%ls\n", MyResultObject->StringValue.c_str());
                }
                catch (Exception& e) {
                        printf("%ls\n", e.ToString().c_str());
                }
        }
        __finally {
                delete MyObject1;
                delete MyObject2;
                delete MyResultObject;
        }

        return 0;
}

Interpretation der Ergebnisse

Mit dem in diesem Tutorial beschriebenen Programm werden vier Eigenschaften von zwei verschiedenen Objekten über Bindungsausdrücke aneinander gebunden. Zwei dieser Eigenschaften haben den Typ Integer; mit diesen Eigenschaften wurde eine Addition durchgeführt. Die beiden anderen Eigenschaften haben den Typ string; mit diesen Eigenschaften wurde eine Verkettung durchgeführt.

Bei Ausführung dieses Programms gibt die Konsole Folgendes aus.


Result of add operation: 3
LiveBinding power.

Zurück