AGB  ·  Datenschutz  ·  Impressum  







Anmelden
Nützliche Links
Registrieren

Observer-Pattern

Ein Thema von Codewalker · begonnen am 15. Dez 2011 · letzter Beitrag vom 16. Nov 2012
Antwort Antwort
Seite 1 von 2  1 2   
Benutzerbild von Codewalker
Codewalker

Registriert seit: 18. Nov 2005
Ort: Ratingen
945 Beiträge
 
Delphi XE2 Professional
 
#1

Observer-Pattern

  Alt 15. Dez 2011, 18:09
Hallo zusammen.

Ich habe für ein kleines Projekt das Observer-Pattern versucht möglichst wiederverwendbar und einfach umzusetzen. Ich würde gerne Eure Meinung und Verbesserungsvorschläge hören und gleichzeitig das Ganze auch alles hier zur Verfügung stellen.

Der Code des Patterns ist wie folgt:
Delphi-Quellcode:
unit PatObserver;

interface

uses SysUtils, Classes;

type
  INotifyObserver = interface
    ['{F4A2A0D8-385E-4D38-ABF5-056ED79532BC}']
    procedure ObserverNotify(Sender: TObject);
  end;

  TObserverSubject = class
  protected
    ObserverCollection: TInterfaceList;
  public
    constructor Create;
    destructor Destroy; override;

    procedure RegisterObserver(Observer: INotifyObserver);
    procedure UnregisterObserver(Observer: INotifyObserver);
    procedure NotifyObservers();
  end;

implementation

{ TObserverSubject }

constructor TObserverSubject.Create;
begin
  ObserverCollection := TInterfaceList.Create();
end;

destructor TObserverSubject.Destroy;
begin
  FreeAndNil(ObserverCollection);
  inherited;
end;

procedure TObserverSubject.RegisterObserver(Observer: INotifyObserver);
begin
  ObserverCollection.Add(Observer);
end;

procedure TObserverSubject.UnregisterObserver(Observer: INotifyObserver);
begin
  ObserverCollection.Remove(Observer);
end;

procedure TObserverSubject.NotifyObservers;
var
  I: Integer;
  fIntf: INotifyObserver;
begin
  for I := 0 to ObserverCollection.Count - 1 do
  begin
    if Supports(ObserverCollection.Items[I], INotifyObserver, fIntf) then
    begin
      fIntf.ObserverNotify(Self);
    end;
  end;
end;

end.
Ich habe das ganze eingesetzt, um bei Änderungen an einem Logbuch automatisch in allen möglichen Formularen automatisch benachrichtigt zu werden. Dazu habe ich im Logbuch folgendes ergänzt:
Delphi-Quellcode:
  TLogFile = class(TInterfacedObject)
  (*SNIP*)
  public
    Notifier: TObserverSubject;
    constructor Create;
    destructor Destroy; override;
    (* SNIP *)

{...}

constructor TLogFile.Create;
begin
  {...}
  Notifier := TObserverSubject.Create;
end;

destructor TLogFile.Destroy;
begin
  {...}
  Notifier.Free;
  inherited;
end;
An den Methoden, an denen das Logbuch verändert wird, wird dann Notifier.NotifyObservers(); aufgerufen.

Um mich im LogViewer als Observer einzutragen habe ich folgendes gemacht:

Delphi-Quellcode:
{...}
type
  TLogViewer = class(TForm, INotifyObserver)
  {...}
  private
    procedure ObserverNotify(Sender: TObject);
  {...}

procedure TLogViewer.FormCreate(Sender: TObject);
begin
  inherited;
  Logfile.Notifier.RegisterObserver(Self);
end;

procedure TLogViewer.FormDestroy(Sender: TObject);
begin
  inherited;
  Logfile.Notifier.UnregisterObserver(Self);
end;

procedure TLogViewer.ObserverNotify(Sender: TObject);
begin
 // Hier auf die Benachrichtigung reagieren
end;
  Mit Zitat antworten Zitat
mjustin

Registriert seit: 14. Apr 2008
3.003 Beiträge
 
Delphi 2009 Professional
 
#2

AW: Observer-Pattern

  Alt 15. Dez 2011, 18:40
Delphi-Quellcode:
  TObserverSubject = class
  protected
    ObserverCollection: TInterfaceList;
  public
    constructor Create;
    destructor Destroy; override;

    procedure RegisterObserver(Observer: INotifyObserver);
    procedure UnregisterObserver(Observer: INotifyObserver);
    procedure NotifyObservers();
  end;
Vorschläge:

* statt TInterfaceList IInterfaceList verwenden (spart ein FreeAndNil im Destruktor)
* in den Parametern const verwenden: statt (Observer: INotifyObserver) (const Observer: INotifyObserver), so kann eine unnötige Referenzzählung verhindert werden
* Generics verwenden um die Observerliste typsicher zu machen (spart das Supports(...))
Michael Justin
habarisoft.com

Geändert von mjustin (15. Dez 2011 um 18:43 Uhr)
  Mit Zitat antworten Zitat
Benutzerbild von Uwe Raabe
Uwe Raabe

Registriert seit: 20. Jan 2006
Ort: Lübbecke
10.934 Beiträge
 
Delphi 12 Athens
 
#3

AW: Observer-Pattern

  Alt 15. Dez 2011, 20:44
statt TInterfaceList IInterfaceList verwenden (spart ein FreeAndNil im Destruktor)
Schlimmer noch: da TInterfaceList von TInterfacedObject abgeleitet ist, steht nach dem Create der Referenzzähler auf 0, wenn man die erzeugte Instanz keiner Interface-Variablen zuweist. Erfolgt nun irgendwie ein AddRef, führt das ausgleichende Release zur sofortigen Freigabe der Instanz. Das Ganze ist somit eine Art Zeitbombe, deren Ursache später nur schwer zu finden ist.
Uwe Raabe
Certified Delphi Master Developer
Embarcadero MVP
Blog: The Art of Delphi Programming
  Mit Zitat antworten Zitat
Benutzerbild von Codewalker
Codewalker

Registriert seit: 18. Nov 2005
Ort: Ratingen
945 Beiträge
 
Delphi XE2 Professional
 
#4

AW: Observer-Pattern

  Alt 16. Dez 2011, 07:34
Danke schonmal für das Feedback. Ich werde also entsprechend const-Parameter nutzen und IInterfaceList verwenden.
Was die Generics angeht: Warum genau sollte ich die hier nutzen? Ich hatte auch mit sowas angefangen, aber der Datentyp von dem, was da als Observer registriert interessiert mich ja nicht. Im Gegenteil, ich will ihn ja gar nicht einschränken. Deshalb bin ich auf Interfaces gegangen. Wo wäre der denn Vorteil der Generics hier?
  Mit Zitat antworten Zitat
mjustin

Registriert seit: 14. Apr 2008
3.003 Beiträge
 
Delphi 2009 Professional
 
#5

AW: Observer-Pattern

  Alt 16. Dez 2011, 11:32
Wo wäre der denn Vorteil der Generics hier?
Es ist nur eine interne Verbesserung (unabhängig vom Typ der "Observables"):

if Supports(ObserverCollection.Items[I], INotifyObserver, fIntf) then entfällt, wenn die ObserverCollection mit INotifyObserver statt IInterface arbeitet.
Michael Justin
habarisoft.com
  Mit Zitat antworten Zitat
Benutzerbild von Uwe Raabe
Uwe Raabe

Registriert seit: 20. Jan 2006
Ort: Lübbecke
10.934 Beiträge
 
Delphi 12 Athens
 
#6

AW: Observer-Pattern

  Alt 16. Dez 2011, 12:12
Wo wäre der denn Vorteil der Generics hier?
Es ist nur eine interne Verbesserung (unabhängig vom Typ der "Observables"):

if Supports(ObserverCollection.Items[I], INotifyObserver, fIntf) then entfällt, wenn die ObserverCollection mit INotifyObserver statt IInterface arbeitet.
Wenn man (wie der Code vermuten lässt) sicher stellen kann, daß sich nur INotifyObserver in die InterfaceList eintragen können, dann kann man das Supports auch durch ein einfaches as ersetzen. Somit reduziert sich die Methode auf:

Delphi-Quellcode:
procedure TObserverSubject.NotifyObservers;
var
  I: Integer;
begin
  for I := 0 to ObserverCollection.Count - 1 do
  begin
    (ObserverCollection.Items[I] as INotifyObserver).ObserverNotify(Self);
  end;
end;
Richtig interessant für Generics wäre aber schon ein generisches Interface á la:

Delphi-Quellcode:
  
  INotifyObserver<T> = interface
    procedure ObserverNotify(Sender: T);
  end;
Damit könnte dann eine einzige Klasse für unterschiedliche Subject-Typen mehrere ObserverNotify-Methoden in einer Klasse implementieren.

Leider scheitert dies aber erstmal daran, daß man einem generischen Interface bei der "Spezialisierung" (wenn man den generischen Typ auflöst) keine eigene GUID mitgeben kann. Somit hat das Interface dann entweder keine GUID oder immer die gleiche. Damit lassen sich dann aber auch keine (sinnvollen) Supports und as Aufrufe mehr damit machen.

Arbeitet man dann aber mit generischen Interfaces ohne GUID muss zwangsläufig die ObserverCollection vom Typ TList<INotifyObserver<T>> sein.

Ergänzend dazu habe ich das Subject noch ausgelagert. Damit vermeidet man zum Einen, daß die Subject-Klasse von dem ObserverSubject abgeleitet werden muss, und zum Anderen könnte man die Subject-Instanz noch austauschbar machen, ohne die Observer zu deregistrieren und wieder zu registrieren.

Der ganze Code sähe dann so aus:

Delphi-Quellcode:
type
  INotifyObserver<T> = interface
    procedure ObserverNotify(Sender: T);
  end;

  TObserverSubject<T> = class
  private
    FSubject: T;
  protected
    ObserverCollection: TList<INotifyObserver<T>>;
  public
    constructor Create(ASubject: T);
    destructor Destroy; override;

    procedure RegisterObserver(Observer: INotifyObserver<T>);
    procedure UnregisterObserver(Observer: INotifyObserver<T>);
    procedure NotifyObservers();
    property Subject: T read FSubject;
  end;

constructor TObserverSubject<T>.Create(ASubject: T);
begin
  ObserverCollection := TList<INotifyObserver<T>>.Create();
  FSubject := ASubject;
end;

destructor TObserverSubject<T>.Destroy;
begin
  ObserverCollection.Free;
  inherited;
end;

procedure TObserverSubject<T>.NotifyObservers;
var
  intf: INotifyObserver<T>;
begin
  for intf in ObserverCollection do
  begin
    intf.ObserverNotify(Subject);
  end;
end;

procedure TObserverSubject<T>.RegisterObserver(Observer: INotifyObserver<T>);
begin
  ObserverCollection.Add(Observer);
end;

procedure TObserverSubject<T>.UnregisterObserver(Observer: INotifyObserver<T>);
begin
  ObserverCollection.Remove(Observer);
end;
Ein Beispiel für eine mehrere Observer implementierende Instanz wäre z.B.:

Delphi-Quellcode:
type
  TMyClient = class(TInterfacedObject, INotifyObserver<TComboBox>, INotifyObserver<TStrings>)
  protected
    procedure ObserverNotify(Sender: TComboBox); overload;
    procedure ObserverNotify(Sender: TStrings); overload;
  end;
Uwe Raabe
Certified Delphi Master Developer
Embarcadero MVP
Blog: The Art of Delphi Programming
  Mit Zitat antworten Zitat
Benutzerbild von Codewalker
Codewalker

Registriert seit: 18. Nov 2005
Ort: Ratingen
945 Beiträge
 
Delphi XE2 Professional
 
#7

AW: Observer-Pattern

  Alt 16. Nov 2012, 14:40
*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).
  Mit Zitat antworten Zitat
Benutzerbild von Sir Rufo
Sir Rufo

Registriert seit: 5. Jan 2005
Ort: Stadthagen
9.454 Beiträge
 
Delphi 10 Seattle Enterprise
 
#8

AW: Observer-Pattern

  Alt 16. Nov 2012, 14:46
Ja geht, das hat Stevie vor kurzem hier gezeigt auch zum Thema Observer

Da is http://www.delphipraxis.net/1190831-post5.html
Kaum macht man's richtig - schon funktioniert's
Zertifikat: Sir Rufo (Fingerprint: ‎ea 0a 4c 14 0d b6 3a a4 c1 c5 b9 dc 90 9d f0 e9 de 13 da 60)
  Mit Zitat antworten Zitat
Benutzerbild von Codewalker
Codewalker

Registriert seit: 18. Nov 2005
Ort: Ratingen
945 Beiträge
 
Delphi XE2 Professional
 
#9

AW: Observer-Pattern

  Alt 16. Nov 2012, 14:56
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
  Mit Zitat antworten Zitat
Benutzerbild von Stevie
Stevie

Registriert seit: 12. Aug 2003
Ort: Soest
4.007 Beiträge
 
Delphi 10.1 Berlin Enterprise
 
#10

AW: Observer-Pattern

  Alt 16. Nov 2012, 14:59
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); ).
Stefan
“Simplicity, carried to the extreme, becomes elegance.” Jon Franklin

Delphi Sorcery - DSharp - Spring4D - TestInsight

Geändert von Stevie (16. Nov 2012 um 15:02 Uhr)
  Mit Zitat antworten Zitat
Antwort Antwort
Seite 1 von 2  1 2   

Themen-Optionen Thema durchsuchen
Thema durchsuchen:

Erweiterte Suche
Ansicht

Forumregeln

Es ist dir nicht erlaubt, neue Themen zu verfassen.
Es ist dir nicht erlaubt, auf Beiträge zu antworten.
Es ist dir nicht erlaubt, Anhänge hochzuladen.
Es ist dir nicht erlaubt, deine Beiträge zu bearbeiten.

BB-Code ist an.
Smileys sind an.
[IMG] Code ist an.
HTML-Code ist aus.
Trackbacks are an
Pingbacks are an
Refbacks are aus

Gehe zu:

Impressum · AGB · Datenschutz · Nach oben
Alle Zeitangaben in WEZ +1. Es ist jetzt 19:00 Uhr.
Powered by vBulletin® Copyright ©2000 - 2024, Jelsoft Enterprises Ltd.
LinkBacks Enabled by vBSEO © 2011, Crawlability, Inc.
Delphi-PRAXiS (c) 2002 - 2023 by Daniel R. Wolf, 2024 by Thomas Breitkreuz