Observer-Pattern Implementation

[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

[Phoenix]

Als kleiner Tipp: Es gibt sehr gute Implementierungen der ganzen Sache (also Obersever Pattern und Iterator Pattern) mit einem größtenteils sehr einheitlichen Interface: http://reactivex.io/

Leider ist hier (noch? ) keine Bibliothek für Delphi dabei.

Aber auch wenn ich es jetzt gerade nicht geschafft habe Dich zu überreden diese zu erstellen *g*, so empfehle ich auf jeden Fall, dass Du Dir dort mal anguckst, wie das in anderen Sprachen realisiert wurde. Rx hat sehr viele Anhänger, und aus meiner Sicht nicht umsonst. Damit zu arbeiten empfinde ich (zumindest in C# und JavaScript) als sehr angenehm.

Von daher lohnt es sich auf jeden Fall mal, sich das mal intensiver anzuschauen und sich ggf. von dort inspirieren zu lassen, bevor man sonst eine eigene Lösung ohne diesen Input baut, die dann sonst möglicherweise Schwächen hat die Rx schon an anderen Stellen ausgemerzt hat.

[Stevie]

Zitat von Phoenix:

Als kleiner Tipp: Es gibt sehr gute Implementierungen der ganzen Sache (also Obersever Pattern und Iterator Pattern) mit einem größtenteils sehr einheitlichen Interface: http://reactivex.io/

Leider ist hier (noch? ) keine Bibliothek für Delphi dabei.

Ich hab kürzlich angefangen, das in Spring4D zu implementieren, allerdings hat das noch internen Prototyp Status