Pattern: Visitor

[stahli]

Zitat von implementation:

Soweit es so gewünscht ist, kann man den Wert ja auch der Methode einfach übergeben:

Wenn man Visit den Parameter V zusätzlich mitgibt, kann man Visit natürlich nicht mehr zentral für alle Visitor-Klassen verwenden. Daher würde ich es grundsätzlich wohl bevorzugen den Wert als Eigenschaft VisitorClass.V zu übergeben.

Zitat von implementation:

Zitat von stahli:

Ein sinnvollerer Procedurname als "TuWasBesonderes" könnte dann wohl "Do", "DoVisit" oder "Visit" sein. Oder wie macht Ihr das üblicherweise?

Am sinnvollsten ist es natürlich, sie nach dem zu benennen, was sie machen soll
"Visit" nennt man üblicherweise die Methoden des Visitors. Die Methode in der Klasse, die ich hier "TuWasBesonderes" genannt habe, heißt in der Literatur zumeist "Accept".
In der Praxis gibt man ihr aber lieber einen aussagekräftigeren Namen.

Jetzt komme ich wieder durcheinander. Wenn Du z.B. TVisitorAdd, TVisitorDel, TVisitorIrgendwas nutzt, dann würdest Du für jede "Nutzung" eine passende Methode in dem Objekt definieren? Den Vorteil (wenn überhaupt) hätte ich eher darin gesehen, dass man den Objekten nicht dutzende Methoden verpassen muss.

Ich will Dir an der Stelle nochmal für den Beitrag danken!
Auch wenn ich einige Bedenken bezüglich Aufwand+Nutzen habe bin ich doch froh, das Prinzip nun endlich verstanden zu haben.

[implementation]

Zitat von stahli:

Jetzt komme ich wieder durcheinander. Wenn Du z.B. TVisitorAdd, TVisitorDel, TVisitorIrgendwas nutzt, dann würdest Du für jede "Nutzung" eine passende Methode in dem Objekt definieren?

Natürlich reicht auch eine

Zitat von stahli:

Ich will Dir an der Stelle nochmal für den Beitrag danken!
Auch wenn ich einige Bedenken bezüglich Aufwand+Nutzen habe bin ich doch froh, das Prinzip nun endlich verstanden zu haben.

Kein Ding

[Uwe Raabe]

Wer des Englischen mächtig ist, kann sich ja weitere Informationen in meiner 4-teiligen Artikelserie zu diesem Thema anlesen.

[implementation]

Zitat von Uwe Raabe:

Wer des Englischen mächtig ist, kann sich ja weitere Informationen in meiner 4-teiligen Artikelserie zu diesem Thema anlesen.

Grad mal überflogen, sehr ausführlich
Und viel ansehnlichere Beispiele als ich.

[mquadrat]

Der Vorteil ist natürlich, dass ich beim Visitor Polymorphie nutzen kann, aber so wirklich gefällt mir das Pattern nicht.

[madas]

Zitat von mquadrat:

Der Vorteil ist natürlich, dass ich beim Visitor Polymorphie nutzen kann, aber so wirklich gefällt mir das Pattern nicht.

Ich finde es ganz praktisch. Vor Allem, wenn es um das Speichern bzw. Laden von Datenstrukturen in bzw. aus bestimmte(n) Dateiformate(n) geht. Dafür schreibt man einfach einen Load- bzw. Save-Visitor und gut ist. Sollte sich das Dateiformat od. der Dateiaufbau ändern wird einfach ein neuer Visitor geschrieben. So kann man auch eine gewisse Versionierung des Dateiformates/aufbaus beibehalten.

[madas]

Zitat von 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

Das Ganze kannste auch noch ein wenig eleganter lösen, da in TuWasBesonderes immer
das Gleiche gemacht wird:

Delphi-Quellcode:

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

procedure TVisitableBase.AcceptVisitor(const v: IVisitor);
begin
   v.Visit(self);
end;

[TiGü]

Wirklich? Ein volles Zitat?

[stahli]

Zitat von madas:

Das Ganze kannste auch noch ein wenig eleganter lösen, da in TuWasBesonderes immer
das Gleiche gemacht wird:

Delphi-Quellcode:

...
   TVisitableBase = class
     procedure AcceptVisitor(const v: IVisitor);
   end;
   TClass1 = class(TVisitableBase)
     // viele Methoden...
   end;
   TClass2 = class(TVisitableBase)
     // viele Methoden...
   end;

Es ging ja auch darum, dass die Klassen keine gemeinsame Basis haben müssen.

[madas]

Zitat von stahli:

Es ging ja auch darum, dass die Klassen keine gemeinsame Basis haben müssen.

Muss ich wohl überlesen haben. Sorry.
Aber dann macht es für mich keinen Sinn, Klassen ohne gemeinsame Basis mit diesem
Pattern zu versehen.
So bald in mehr als einer Klasse zwei Properties od. Methoden od. od. gleich heißen, sollte man meiner Meinung nach darüber nachdenken, ob sie nicht einen gemeinsamen Vorfahren bekommen sollten.