Liebe Delphi-Gemeinde,

ich mag im Design meiner Objekte das Pattern des Fluent Design sehr gerne und gestalte meine Methoden deshalb gerne damit. Ich meine damit also etwa ein solches Gebilde:

Result := CreateSomeInterface.DoSomething('withParameter').DoSomethingOther.ConvertEverythingToString;

Das ist an manchen Stellen sehr praktisch und macht den Code in meinen Augen etwas schöner, vor allem, wenn man mit Interfaces statt mit Objekten arbeitet.

Nun frage ich mich, ob man das auch mit Records machen kann, bzw. ob das sinnvoll ist.

Angenommen ich habe folgendes:

zusammenfalten · markieren

Delphi-Quellcode:

type
  Tfluent = record
    variable: string;
    function DoSomething(const mParameter: string): Tfluent;
  end;

function Tfluent.DoSomething(const mParameter: string): Tfluent;
begin
  variable := variable + mParameter;
  Result := Self;
end;

Soweit ich das verstehe, würde das Result := Self; bei Records immer dazu führen, dass der komplette Record kopiert wird, da eine Übergabe bei Records ja "als Wert" und nicht "als Zeiger" funktioniert.

Damit wäre das Fluent Design bei Records nicht sinnvoll und würde ständig eine Kopiererei der Daten verursachen. Ist das so, oder gibt es einen Trick? Wie macht ihr das?

Ich fände die Records deshalb sehr schön, weil man z.B. mit Operator Overloading sich dann eine Methode "ConvertEverthingToString" sparen könnte, was meines Wissens mit Objekten/Interfaces bislang noch nicht geht.

Viele Grüße
Harald

Man kann einen Record erstellen, der als einzige Methoden Konstruktoren hat. Das ist natürlich Quatsch, würde aber vielleicht funktionieren. Ich setze schon mal einen Helm auf, weil ich gleich gesteinigt werde.

Du könntest jeweils einen Zeiger auf Self zurückgeben. Also Result := @Self (mit Klammeraffe).
Da Delphi erlaubt, beim Dereferenzieren den ^ wegzulassen, könnten die Aufrufe sogar identisch ausschauen.
(Wobei ich dieses Feature persönlich verabscheue. Aber die Geschmäcker sind verschieden.)

Eigentlich hat uligerhardt schon alles gesagt...

Ich würde jedoch das ^ nie weglassen... Einfach um den Ursprung besser zu verstehen.

Zitat von Mavarik:

Ich würde jedoch das ^ nie weglassen... Einfach um den Ursprung besser zu verstehen.

Ihr meint sicher Fluent Interface und nicht Fluent Design.

Zitat von hschmid67:

Liebe Delphi-Gemeinde,

ich mag im Design meiner Objekte das Pattern des Fluent Design sehr gerne und gestalte meine Methoden deshalb gerne damit. Ich meine damit also etwa ein solches Gebilde:

Result := CreateSomeInterface.DoSomething('withParameter').DoSomethingOther.ConvertEverythingToString;

Das ist an manchen Stellen sehr praktisch und macht den Code in meinen Augen etwas schöner, vor allem, wenn man mit Interfaces statt mit Objekten arbeitet.

Naja, Schönheit liegt im Auge des Betrachters.

Stell Dir mal vor, Du mußt sowas debuggen, dann ist es nicht mehr so schön...

Zitat von peterbelow:

Zitat von hschmid67:

Result := CreateSomeInterface.DoSomething('withParameter').DoSomethingOther.ConvertEverythingToString; Das ist an manchen Stellen sehr praktisch und macht den Code in meinen Augen etwas schöner, vor allem, wenn man mit Interfaces statt mit Objekten arbeitet.

Naja, Schönheit liegt im Auge des Betrachters.

Stell Dir mal vor, Du mußt sowas debuggen, dann ist es nicht mehr so schön...

Einfach vernuenftig formatieren ...

markieren

Delphi-Quellcode:

Result := CreateSomeInterface
  .DoSomething('withParameter')
  .DoSomethingOther
  .ConvertEverythingTo

... und schon ist das kein Problem mehr. Und lesbarer ist es (IMHO) auch.
(Ob der OP das dann allerdings immernoch "schön" findet?).

Hmm..

Zitat von dummzeuch:

Zitat von peterbelow:

Zitat von hschmid67:

Result := CreateSomeInterface.DoSomething('withParameter').DoSomethingOther.ConvertEverythingToString; Das ist an manchen Stellen sehr praktisch und macht den Code in meinen Augen etwas schöner, vor allem, wenn man mit Interfaces statt mit Objekten arbeitet.

Naja, Schönheit liegt im Auge des Betrachters.

Stell Dir mal vor, Du mußt sowas debuggen, dann ist es nicht mehr so schön...

Einfach vernuenftig formatieren ...

markieren

Delphi-Quellcode:

Result := CreateSomeInterface
  .DoSomething('withParameter')
  .DoSomethingOther
  .ConvertEverythingTo

... und schon ist das kein Problem mehr. Und lesbarer ist es (IMHO) auch.
(Ob der OP das dann allerdings immernoch "schön" findet?).

So etwas ist immer gefährlich....

Was ist, wenn es beim '.DoSomething('withParameter')' kracht oder etwas geliefert wird, was in '.DoSomethingOther' zur Exception führt?

Wenn ich das in einer Zeile schreibe, wie kann ich dann im Debugger erkennen, wo es geknallt hat?

(Nur so meine Meinung )

Mal eine Frage, was Ihr grundsätzlich von einer solchen Darstellung haltet (mal völlig unabhängig von Delphi und anderen realen Sprachen).
Es geht mir nur um die reine Lesbarkeit und Wünsche diesbezüglich.

Das wäre ja Delphi ohne irgendwelche Klimmzüge:

markieren

Code:

  Result := CreateSomeInterface;
  Result.DoSomething('withParameter');
  Result.DoSomethingOther;
  Result.ConvertEverythingTo;

Warum will man das anders darstellen?
Um nicht mehrfach "Result" zu schreiben?

---

Ok, wenn man jetzt (rein hypothetisch!) dem IDE-Editor folgendes beibringen könnte:
"Wenn in den folgenden Zeilen das gleiche erste Wort steht und dann ein Punkt folgt, dann lasse das erste Wort in der Darstellung weg und rücke alles ab dem Punkt ein!"
dann würde das so aussehen:

markieren

Code:

  Result := CreateSomeInterface;
         .DoSomething('withParameter');
         .DoSomethingOther;
         .ConvertEverythingTo;

---

Da aber dann der Editor abweichenden Code darstellen müsste als der, den der Compiler erhält, müsste man das etwas anders aufziehen:
Man müsste dem Compiler sagen: "Wenn eine Anweisung mit einem Punkt beginnt, dann denke Dir mal, dass davor die Variable steht, der in der vorherigen Anweisung etwas zugewiesen wurde."
Die IDE könnte einfach die Anweisung ab dem Punkt einrücken.

markieren

Code:

  Result := CreateSomeInterface;
         .DoSomething('withParameter');
         .DoSomethingOther;
         .ConvertEverythingTo;

Das sähe also aus wie bei der vorherigen Überlegung, aber der Code wäre identisch zur Darstellung.
Das hätte den Haken, dass man letztlich nur in Verbindung mit der Einrückung klar erkennt, was dort gemeint ist.

---

Gut, schauen wir uns mal with an:

markieren

Code:

  Result := CreateSomeInterface;
  with Result do
  begin
    DoSomething('withParameter');
    DoSomethingOther;
    ConvertEverythingTo;
  end;

Eigentlich ja gar nicht sooo schlecht, allerdings bekannter Maßen mit einem recht hohen Verwechslungsrisiko und die Umschließung mit begin..end ist auch etwas nervig.

---

Mich würde das zu folgenden gewünschten Sprachfeature führen: "use"

markieren

Code:

  use Result := CreateSomeInterface;
             .DoSomething('withParameter');
             .DoSomethingOther;
             .ConvertEverythingTo;
             Report(.Text);
  Report('use gilt nicht mehr');

"use" würde with entsprechen und so lange gelten, wie folgende Anweisungen Bezeichner benutzen, die mit einem Punkt anfangen.
Dann wäre auch noch die Report-Anweisung möglich.
Sobald eine Anweisung nicht nicht mehr auf Result bezieht (also kein Bezeichner mit einem . anfängt) ist der use-Bezug hinfällig und ungültig.

---

Wenn, dann würde ich mir so etwas wünschen.
Das wäre nachvollziehbar und einfach ein besseres "with".

Alle Klassen umzubauen um Anweisungen mit einem Punkt starten zu können wäre mir zu aufwendig und bezüglich der Debugbarkeit halte ich das auch nicht für hilfreich.
Außerdem sollten Funktionen für die Logik da sein und nicht für das Code-Styling.

Wenn ich eine Methode TPerson.SetIsNice(True) habe, dann sollte die möglicherweise für die Validierung ein Accept zurück geben und nicht die Klasse.

Also ich brauche ein fluent interface eher nicht und würde eher ein anderes Sprachfeature wünschen, um Codekürzungen zu erreichen. Da wäre ich dann dabei.