Observer-Pattern

[Codewalker]

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;

[mjustin]

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(...))

[Uwe Raabe]

Zitat von mjustin:

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.

[Codewalker]

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?

[mjustin]

Zitat von Codewalker:

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.

[Uwe Raabe]

Zitat von mjustin:

Zitat von Codewalker:

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;