Pattern: Visitor

[implementation]

Hallo liebe Forumsgenossen,

so manch einer von euch ist sicherlich schonmal in folgende Situation geraten:

Ihr habt sehr viele Klassen, die alle eine neue gemeinsame Methode bekommen sollen, die sich aber nicht zentral im Vorfahren einfügen lässt (bspw. weil sich jede Unterklasse anders verhalten soll).
Nun könntet ihr die Methode in jeder dieser Klasse einzeln einführen. Dann hättet ihr die Methoden der jeweiligen Klasse immer schön beieinander.

Delphi-Quellcode:

type
  TClass1 = class
    procedure AndereMethode;
    procedure BlubbNochMehr;
    // ...
    procedure TuWasBesonderes;
  end;
  TClass2 = class
    procedure IchKannWas;
    procedure GanzAnderes;
    // ...
    procedure TuWasBesonderes;
  end;

// TClass1
procedure TClass1.AndereMethode;
begin
  MachWas;
  MachNochMehr;
end;
...
procedure TClass1.TuWasBesonderes;
begin
  Writeln('Ich bin Klasse 1');
end;

// TClass2
procedure TClass2.IchKannWas;
begin
  MachIrgendwas;
  GuckBloed;
end;
...
procedure TClass2.TuWasBesonderes;
begin
  Writeln('Ich bin Klasse 2');
end;

Nun könnt ihr im Nachhinein schön jede Klasse an sich überblicken.

Nun mag manchmal aber etwas anderes viel sinnvoller sein:
Wäre es nicht viel schöner, alle TuWasBesonderes() auf einmal an einer zentralen Stelle im Blick zu haben?

Die Viererbande hat sich dazu ein schönes Pattern ausgedacht: Den Visitor.

Delphi-Quellcode:

// Unit A
type
  IVisitor = interface
    procedure Visit(const x: TClass1); overload;
    procedure Visit(const x: TClass2); overload;
  end;
  TClass1 = class
    // viele Methoden...
    procedure TuWasBesonderes(const v: IVisitor);
  end;
  TClass2 = class
    // viele Methoden...
    procedure TuWasBesonderes(const v: IVisitor);
  end;

procedure TClass1.TuWasBesonderes(const v: IVisitor);
begin
  v.Visit(self);
end;

procedure TClass2.TuWasBesonderes(const v: IVisitor);
begin
  v.Visit(self);
end;

Delphi-Quellcode:

// Unit B
uses UnitA;

type
  TVisitorA = class (TInterfacedObject, IVisitor)
    procedure Visit(const x: TClass1); overload;
    procedure Visit(const x: TClass2); overload;
  end;
  TVisitorB = class (TInterfacedObject, IVisitor)
    procedure Visit(const x: TClass1); overload;
    procedure Visit(const x: TClass2); overload;
  end;

procedure TVisitorA.Visit(const x: TClass1);
begin
  Writeln('Visitor A mit Klasse 1');
end;

procedure TVisitorA.Visit(const x: TClass2);
begin
  Writeln('Visitor A mit Klasse 2');
end;

procedure TVisitorB.Visit(const x: TClass1);
begin
  Writeln('Visitor B mit Klasse 1');
end;

procedure TVisitorB.Visit(const x: TClass2);
begin
  Writeln('Visitor B mit Klasse 2');
end;

Und da können wir auch noch mehr Vorteile sehen:

• Wir können nicht nur einen Visitor schreiben, sondern gleich mehrere! Dadurch hat der Aufrufer von TuWasBesonderes() auch eine bessere Möglichkeit, den Ablauf zu beeinflussen. Neue Visitoren lassen sich schnell dazuergänzen, überlegen Sie mal, wie schnell es nun ginge, noch einen Visitor C hinzuzufügen.
• Es lassen sich auch schnell neue Klassen ergänzen. Angenommen wir führen nun eine neue Klasse 3 ein, müssen wir sie nur IVisitor.Visit() aufrufen lassen, und sie in den Visitoren ergänzen.
• Wir können damit die gesamte TuWasBesonderes()-Funktionalität in eine eigene Unit auslagern.

Mfg und in der Hoffnung, geholfen zu haben,
implementation

Kritik ist erwünscht, also scheut euch nicht