Observer-Pattern

[Codewalker]

*Thread ausgrab*

Ich bin mit dem Pattern immer noch nicht wirklich zufrieden. Im Prinzip hätte ich gerne einen Observer, der für alle Events herhalten kann. Ich habe jetzt dazu mit der RTTI ein wenig gebastelt.
Der Ansatz sieht so aus:

Delphi-Quellcode:

unit thObserver;

interface

uses System.Generics.Collections, Rtti;

type
  TObseverItem = class
  public
    Methods: TList<TRttiMethod>;
    constructor Create;
    destructor Destroy; override;
  end;

  TObserver = class(TDictionary<string, TObseverItem>)
  public
    procedure RegisterObserver(EventName: string; Method: TRttiMethod);
    procedure UnregisterObserver(EventName: string; Method: TRttiMethod);
    procedure Call(EventName: string; Args: array of TValue);
  end;

implementation

procedure TObserver.Call(EventName: string; Args: array of TValue);
var
  Item: TRttiMethod;
begin
  for Item in Items[EventName].Methods do
  begin
    Item.Invoke(Item, Args)
  end;
end;

procedure TObserver.RegisterObserver(EventName: string;
  Method: TRttiMethod);
begin
  if not ContainsKey(EventName) then
  begin
    Add(EventName, TObseverItem.Create);
  end;
  Items[EventName].Methods.Add(Method);
end;

procedure TObserver.UnregisterObserver(EventName: string;
  Method: TRttiMethod);
begin
  Items[EventName].Methods.Remove(Method);

  if Items[EventName].Methods.Count = 0 then
  begin
    Items[EventName].Free;
    Remove(EventName);
  end;
end;

{ TObseverItem }

constructor TObseverItem.Create;
begin
  Methods := TList<TRttiMethod>.Create;
end;

destructor TObseverItem.Destroy;
begin
  Methods.Free;
  inherited;
end;

end.

Es läuft aber noch nicht rund. Im Moment sieht das ganze im Aufruf so aus:

Delphi-Quellcode:

type
  TMyClass = class
  private
    FObserver: TObserver;
  public
    constructor Create;
    destructor Destroy; override;

    procedure RegisterOnChange(Method: TRttiMethod);
    procedure UnregisterOnChange(Method: TRttiMethod);
  end;

{...}

// zum auslösen, um z.B. Button1 als Parameter zu übergeben (wir gehen davon aus, dass die registrierte Funktion auch darauf passt
   FObserver.Call('OnChange', [TValue.From<TButton>(Button1)]);

Um jetzt von außerhalb mich an das Event anzuhängen, mache ich folgendes:

Delphi-Quellcode:

procedure TForm1.TestOnChange(Button: TButton);
begin
// ...
end;

{...}

var
  Method: TRttiMethod;
  context: TRttiContext;
begin
  Method := context.GetType(Self.ClassType).GetMethod('TestOnChange');

  Myclass.RegisterOnAquireAchievement(Method);

Das ganze geht so lange gut, bis der Aufruf über das Invoke erfolgt, dann hagelt es eine AccessViolation. Ist das so, wie ich das vorhabe überhaupt möglich? (Noch schöner wäre, wenn man sich mit Include und Exclude an das Event anhängen könnte, ähnlich wie in .NET. Also dann sowas wie
Myclass.OnChange.Include(MeinEventHandler) , aber da weiß ich auch nicht, ob und wie das geht).

[Sir Rufo]

Ja geht, das hat Stevie vor kurzem hier gezeigt auch zum Thema Observer

Da is http://www.delphipraxis.net/1190831-post5.html

[Codewalker]

OKay, das mit dem .Add etc. sieht da gut aus. Nur ist es in seinem Fall ein konkreter Observer. Ich möchte das als wiederverwendbare Klasse machen. Wenn ich es als generische Klasse mache TObserver<T> = class kann ich T ja nicht aufrufen, weil nicht klar ist, dass es eine Methode ist. Und ein Constraint, dass da nur Methodentypen reindürfen kenne ich leider nicht.
Ein Idee wie ich das umschiffe? Dann könnte ich das mit Stevies Lösung verbinden und wäre glücklich

[Stevie]

Zitat von Codewalker:

OKay, das mit dem .Add etc. sieht da gut aus. Nur ist es in seinem Fall ein konkreter Observer. Ich möchte das als wiederverwendbare Klasse machen. Wenn ich es als generische Klasse mache TObserver<T> = class kann ich T ja nicht aufrufen, weil nicht klar ist, dass es eine Methode ist. Und ein Constraint, dass da nur Methodentypen reindürfen kenne ich leider nicht.
Ein Idee wie ich das umschiffe? Dann könnte ich das mit Stevies Lösung verbinden und wäre glücklich

TEvent<T> wirft zur Laufzeit eine Exception, wenn T kein Event oder Delegate Typ mit Rtti ist.
Dadurch, dass die Eigenschaft Invoke von T ist, kann man die auch aufrufen (z.B. e.Invoke(Button1); ).

[Codewalker]

Aber ich scheitere doch schon zur DesignTime, weil ich die Notify-Methode nicht programmieren kann.

Delphi-Quellcode:

unit thObserver;

interface

uses 
   System.Generics.Collections, Rtti;

type
  TObserver<T> = class
  private
    FEvents: TList<T>;
  public
    constructor Create;
    destructor Destroy; override;

    procedure Notify(Args: array of TValue);
    property OnEvent: TList<T> read FEvents;
  end;

implementation


{ TObserver<T> }

constructor TObserver<T>.Create;
begin
  FEvents := TList<T>.Create;
end;

destructor TObserver<T>.Destroy;
begin
  FEvents.Free;
  inherited;
end;

procedure TObserver<T>.Notify(Args: array of TValue);
var
  Event: T;
begin
  for Event in FEvents do
  begin
    Event(Args);  /// Bis hierhin ist noch alles gut, aber das hier geht ja nicht
  end;
end;

end.

[Stevie]

Zitat von Codewalker:

Aber ich scheitere doch schon zur DesignTime, weil ich die Notify-Methode nicht programmieren kann.

Schau dir einfach DSharp.Core.Events.pas an.