Observer-Pattern Implementation

[Der schöne Günther]

Als ich mit Delphi angefangen habe dachte ich auch erst das Observer-Pattern so umsetzen zu müssen, da ich es in Java (vor Java 8) so gelernt hatte.

Vielleicht habe ich es mir jetzt nicht genau angesehen, aber das Interface "Listener" ist doch eigentlich überflüssig, oder? Warum muss mein Objekt eine bestimmte Schnittstelle implementieren, nur um etwas mitzubekommen? Man könnte dem Subject stattdessen eine procedure register(onNotification: TProc) verpassen mit welcher jeder auf dem Observable einmal z.B. sagen kann

Delphi-Quellcode:

someObservable.register(
    procedure()
    begin
        ShowMessage(someObservable.someValue);
    end
);

Man könnte sich auch mehrmals registrieren. Sehe ich mit dieser Implementation nicht wie das ginge.

Das ist glücklicherweise wie man das in letzter Zeit auch häufig ab Java 8 und C++ 11 sieht. Ob das "Turbo Pascal" auch kann weiß ich nicht, ich weiß noch nichtmal was das ist.


Allen Bauer hier auch mal so etwas in die Richtung gebaut:
https://community.embarcadero.com/bl...generics-38865

[Uwe Raabe]

Zitat von Der schöne Günther:

ich weiß noch nichtmal was das ist.

Das nennt sich Anonyme Methode.

Es ist tatsächlich so, daß sich viele Design-Patterns mittels moderner Sprachkonstrukte in einem aktuellen Delphi wesentlich schlanker und eleganter umsetzen lassen, als es in den Lehrbüchern beschrieben ist.

[Der schöne Günther]

Zitat von Uwe Raabe:

Zitat von Der schöne Günther:

ich weiß noch nichtmal was das ist.

Das nennt sich Anonyme Methode.

Was "Turbo Pascal" ist, meinte ich


Java hat so etwas ja erst extrem spät bekommen, viele Observer-Pattern Implementationen in Delphi sehen so aus als hätte man sie aus Java 1:1 übernommen

Zitat von Ghostwalker:

Warum soll sich ein Objekt bei einem anderen mehrmals für die gleiche Notification registrieren ?????

Unverhofft kommt oft
Ich meinte aber eher: Wenn sich ein Objekt bei zwei Observables vom gleichen Typ registrieren will - Dann rufen beide zwangsläufig die gleiche Methode auf, obwohl man das sicher nicht will.

[Ghostwalker]

Zitat von Der schöne Günther:

Unverhofft kommt oft
Ich meinte aber eher: Wenn sich ein Objekt bei zwei Observables vom gleichen Typ registrieren will - Dann rufen beide zwangsläufig die gleiche Methode auf, obwohl man das sicher nicht will.

Doch, genau das will ich, zumindest in dem geplanten Anwendungsfall. Der Unterschied besteht hier lediglich in den übergebenen Daten bei der Notification (daher auch Pointer !)

[Ghostwalker]

So dale, noch mal ein Update.

Hab das ganze nochmal komplet umgebaut. Source im Anhang.

Achtung hab da FastMM4 eingebunden, um zu checken ob Memory-Leaks entstehen

Generics wären schön, insbesondere bei der Methodlist bzw. deren Nachfahren. Habsch aber net.

Jetzt ist wieder euer Meinung gefragt

[Devstructor]

Hi,

ich hatte mal für ein privates Projekt Observer-Komponenten geschrieben. Du kannst da mal rüber schauen
Mit einer List hatte ich nicht gearbeitet, sondern mit einer TInterfacedList, das wäre sicher eine Optimierung
Der TMBObserver ist eigentlich nur eine Basiskomponente, man könnte auch einfach das Interface IMBObserver zum Beispiel einem Form hinzufügen.

Delphi-Quellcode:

unit MBSubject;

{$mode objfpc}{$H+}

interface

uses
  Classes, SysUtils, LResources, MBObserver;

type
  IMBSubject = interface
    ['{A89B6DD9-711C-4444-BF29-1AB0335A489C}']
    procedure AddObserver(Observer: IMBObserver);
    procedure RemoveObserver(Observer: IMBObserver);
    procedure ClearObservers;
    procedure NotifiyObservers;
  end;

  { TMBSubject }

  TMBSubject = class(TComponent, IMBSubject)
  private
    FEnabled: Boolean;
    FObservers: TInterfaceList;
  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;

    procedure AddObserver(Observer: IMBObserver);
    procedure RemoveObserver(Observer: IMBObserver);
    procedure ClearObservers;

    procedure NotifiyObservers;
  published
    property Enabled: Boolean read FEnabled write FEnabled default True;
  end;

procedure Register;

implementation

procedure Register;
begin
  {$I mbsubject_icon.lrs}
  RegisterComponents('MBComponents',[TMBSubject]);
end;

{ TMBSubject }

constructor TMBSubject.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);

  FObservers:=TInterfaceList.Create;
  FEnabled:=True;
end;

destructor TMBSubject.Destroy;
begin
  if Assigned(FObservers) then FreeAndNil(FObservers);

  inherited Destroy;
end;

procedure TMBSubject.AddObserver(Observer: IMBObserver);
begin
  if FObservers.IndexOf(Observer) = -1 then FObservers.Add(Observer);
end;

procedure TMBSubject.RemoveObserver(Observer: IMBObserver);
begin
  FObservers.Remove(Observer);
end;

procedure TMBSubject.ClearObservers;
begin
  FObservers.Clear;
end;

procedure TMBSubject.NotifiyObservers;
var
  i: Integer;
  Observer: IMBObserver;
begin
  if not FEnabled then Exit;

  for i := 0 to Pred(FObservers.Count) do
    if Supports(FObservers.Items[i], IMBObserver, Observer) then Observer.SubjectChanged(Self);
end;

end.

Delphi-Quellcode:

unit MBObserver;

{$mode objfpc}{$H+}

interface

uses
  Classes, SysUtils, LResources;

type
  IMBObserver = interface
    ['{512FD47A-6122-4EFF-9ED4-09AC795EF794}']
    procedure SubjectChanged(Sender: TObject);
  end;

  { TMBObserver }

  TMBObserver = class(TComponent, IMBObserver)
  private
    FOnSubjectChanged: TNotifyEvent;
  protected
    procedure SubjectChanged(Sender: TObject);
  published
    property OnSubjectChanged: TNotifyEvent read FOnSubjectChanged write FOnSubjectChanged;
  end;

procedure Register;

implementation

procedure Register;
begin
  {$I mbobserver_icon.lrs}
  RegisterComponents('MBComponents',[TMBObserver]);
end;

{ TMBObserver }

procedure TMBObserver.SubjectChanged(Sender: TObject);
begin
  if Assigned(FOnSubjectChanged) then FOnSubjectChanged(Sender);
end;

end.

[Ghostwalker]

Erstmal Danke für deine Anmerkungen

Da ich keine Interfaces speichere und auch ganz gern auf das automatische Instanzhandling verzichten möchte, hab ich mich ganz bewußt gegen TInterfaceList entschieden.

Stattdessen speichere ich nur noch Methodenzeiger in folgender Liste bzw einer davon abgeleiteten Klasse:

Delphi-Quellcode:

TYPE
  PMethod = ^TMethod;
  TMethodList = Class(TObject)
    PRIVATE
       flist : TList;
       function getMethod(Index: integer): TMethod;
       procedure setMethod(Index: integer; const Value: TMethod);
    PROTECTED
       function getCount:integer;
       function indexOf(proc:TMethod):integer;
    PUBLIC
       Constructor Create;
       Destructor Destroy;override;

       Procedure Clear;
       procedure Add(const proc:TMethod);
       procedure Remove(const proc:TMethod);
       property Items[Index:integer]:TMethod read getMethod write setMethod;
    PUBLISHED
       Property Count:integer read getCount;
  End;

Damit laufe ich nicht Gefahr, das mir die Liste plötzlich mein Objekt unterm Allerwertesten wegzieht

[Ghostwalker]

Zitat von Der schöne Günther:

Als ich mit Delphi angefangen habe dachte ich auch erst das Observer-Pattern so umsetzen zu müssen, da ich es in Java (vor Java 8) so gelernt hatte.

Vielleicht habe ich es mir jetzt nicht genau angesehen, aber das Interface "Listener" ist doch eigentlich überflüssig, oder?

Wie oben erwähnt, hab ich die Interfaces deshalb gemacht, damit auch später von Externer seite (z.B. Plugin) das ganze genutzt werden kann. Damit stell ich letztlich sicher, das die App und das Plugin vom gleichen sprechen

Zitat von Der schöne Günther:

Warum muss mein Objekt eine bestimmte Schnittstelle implementieren, nur um etwas mitzubekommen? Man könnte dem Subject stattdessen eine procedure register(onNotification: TProc) verpassen mit welcher jeder auf dem Observable einmal z.B. sagen kann

hmm....was die bisherige Funktionalität betrifft, hast du Recht, da würde auch eine Prozedur/Methode
reichen.

Zitat von Der schöne Günther:

Man könnte sich auch mehrmals registrieren. Sehe ich mit dieser Implementation nicht wie das ginge.

Warum soll sich ein Objekt bei einem anderen mehrmals für die gleiche Notification registrieren ?????

Zitat von Der schöne Günther:

Das ist glücklicherweise wie man das in letzter Zeit auch häufig ab Java 8 und C++ 11 sieht. Ob das "Turbo Pascal" auch kann weiß ich nicht, ich weiß noch nichtmal was das ist.

Allen Bauer hier auch mal so etwas in die Richtung gebaut:
https://community.embarcadero.com/bl...generics-38865

Ähm....TD ist nicht Turbo Pascal sonder Turbo Delphi (letztlich BDS2006). Und ja, Prozedure/Function's als Parameter übergeben funktioniert schon seit Turbo Pascal 5 (gute alte DOS-Zeit), wenn auch nicht in der Variante.

Das Konzept anonymer Funktionen kenn ich von js und anderen Sprachen. Und auch wie "verpönt" sie sind