Man kann doch Class/Record Helper nun an "alles" dran hängen?

Warum nicht auch an Interfaces?

Weil Embarcadero einfach zu be... ach, lassen wir das, sonst reg ich mich nur wieder auf...

Class Helper sind doch dazu gedacht, eine Klasse nachträglich etwas zu pimpen.
Interfaces sind Verträge.

Wieso sollte ich Verträge nachträglich noch aufbohren wollen. Dann passt das doch nicht mehr.

Wo ist mein Denkfehler?

Berühmtestes Beispiel: IEnumerable<T>

Eigentlich müsste dieses Interface nur so aussehen:

markieren

Delphi-Quellcode:

type
  IEnumerable<T> = interface
    function GetEnumerator: IEnumerator<T>
  end;

Und über Extension Methodseinen interface helper kann man nun alle möglichen Operationen, die auf GetEnumerator operieren, implementieren.
Das ermöglicht einem eine Verkettung dieser Operationen -> syntax Sugar.

Anderes Beispiel:

markieren

Delphi-Quellcode:

type
  ILogger = interface
    procedure WriteLogEntry(const entry: TLogEntry);
  end;

Simples Interface, wenn man neue Logger bauen will, muss man nur eine Methode implementieren -> gut!

Aber den Logger zu benutzen ist nun eher umständlich, denn es mag nun verschiedene Eigenschaften in TLogEntry geben, die ich immer befüllen muss.
Also würde sich so ein Interface helper anbieten:

markieren

Delphi-Quellcode:

type
  ILoggerHelper = interface helper for ILogger
    procedure LogValue<T>(const value: T)
    procedure EnterMethod(const methodName: string);
    procedure LeaveMethod(const methodName: string);
  end;

In diesen Methoden wird nun nix anderes gemacht als die Information in ein TLogEntry gepackt und dann an die WriteLogEntry Methode übergeben.
D.h. ich kann die Funktionalität des Interfaces erweitern, ohne den Vertrag zu verletzen und ohne weitere Kopplung für den Implementierenden zu erzeugen.

Im Grunde sind so helper Methoden nix anderes als das:

procedure Methode(Self: <gehelpter type>; args) Aber ein:

markieren

Delphi-Quellcode:

logger.EnterMethod('foo');

// liest sich einfach besser als:

EnterMethod(logger, 'foo');

Und umso mehr, wenn ich solche Methoden verketten kann (ja, das geht mit Spring4D aber auch nur, weil die ganzen Methoden auf IEnumerable<T> sitzen und somit dem Implementierer aufgezwungen werden, obwohl sie nur auf GetEnumerator aufsetzen -> fette Klassen):

markieren

Delphi-Quellcode:

for c in customers.Where(...).Ordered.Take(10) do
  // mach was

Aber warum nicht einfach ILoggerHelper = interface(ILogger) ?

Zitat von TiGü:

Aber warum nicht einfach ILoggerHelper = interface(ILogger) ?

Und, wie bekomm ich dann die Methoden von ILoggerHelper aufgerufen, wenn ich nur ILogger implementiere?
Ja, Dekorator bauen, etc... aber darum gehts nicht.

Außerdem könnte ich, wären die helper vernünftig implementiert auch mehrere gleichzeitig aktiv haben, mach das mal mit Vererbung

Eine mögliche Syntax die ich mir auch vorstellen könnte wäre sowas (woher ich das wohl habe...):

markieren

Code:

procedure EnterMethod(extends logger: ILogger; const methodName: string);

Und die kann man dann so aufrufen:

markieren

Code:

logger.EnterMethod('foo')

Simpler Syntaxzucker also. Und wenn ich das gerade richtig überblicke dürften dort auch alle Regeln von normalen Routinen (sprich, welche Methode ist im Scope, Overload resolution etc) greifen.

Bei der Gelegenheit könnte man gleich noch eine Diskussion über, seit Java 8 vorhandene, Standard-Implementierungen für Interfaces anstoßen: Ein Interface kann eine Standard-Implementierung einer Methode sowie statische Methoden vorgeben. Im Endeffekt geht das ja in eine stark ähnliche Richtung.

Würdet ihr, so etwas gerne in Delphi sehen wollen? Ich dachte erst "Was für ein Quatsch" aber in der Zwischenzeit bin ich auch über ein paar Fälle gestolpert wo man das hätte gebrauchen können...

Unter Delphi ist das mit den Interface Helpern doch uninteressant, denn die Interfaces unterstützen keine Generics

markieren

Delphi-Quellcode:

IFoo<T> = interface
  function AsType<TResult> : TResult; // <- Zonk
end;

Mit einem record drumherum ist das dann wieder kein Problem (ist ja in Spring4D auch so vorhanden )

markieren

Delphi-Quellcode:

Foo<T> = record
  class operator implicit ( a : IFoo<T> ) : Foo<T>;
  function AsType<TResult> : TResult;
end;

Wenn also diese Schranke fällt, dann ist auch der Interface Helper interessant. Bis dahin müsste man sich je nach Fall immer zwischen Interface Helper oder eben doch Record entscheiden. Dann doch lieber immer auf die gleiche Weise

Zitat von Der schöne Günther:

aber in der Zwischenzeit bin ich auch über ein paar Fälle gestolpert wo man das hätte gebrauchen können...

Wenn man es so nimmt, dann wollte ich diesesmal genau das.

Im Grunde geht es genau um das, wozu diese Helper erfunden wurden. Das "erweitern" der Funktionen, von irgedwas (Klasse/Record/Typ), ohne diesen Typen direkt zu verändern.


Bei Klassen kann man einfach vererben, aber bei Interfaces geht das nicht, denn dort muß man das "Objekt" hinter dem Interface verändern/kapseln und Funktionsaufrufe an das originale Interface weiterreichen.

Man kann ein eigenes Objekt schreiben, daß beim QueryInterface die Zugriff auf das/die originalen Interfaces weitergibt, aber rückwärts geht das nicht, daß das "fremde" Objekt mein Interface nicht kennt.
Dazumal sind das zwei getrennten Objekte und die Referenzzählung/Freigabe ist nicht lösbar, ohne das andere Interface komplett zu kapseln.

Zitat von Sir Rufo:

Unter Delphi ist das mit den Interface Helpern doch uninteressant, denn die Interfaces unterstützen keine Generics

Genau, weil b nicht geht, lassen wir a auch gleich lieber sein.
Dass es keine generischen Methoden auf Interface selber gibt, hat einen technischen Grund, nämlich den gleichen, warum es keine virtuellen Methoden mit generischen Parametern gibt: ich hab nur einen Slot in der VMT dafür, für welches T soll ich den nehmen?

Methoden in einem Interface Helper wären aber nicht virtuell.
Viel schlimmer: man kann aktuell keine helper für generische Typen bauen!

Zitat von Sir Rufo:

Mit einem record drumherum ist das dann wieder kein Problem (ist ja in Spring4D auch so vorhanden )

Wenn der Compiler da nicht bei so nem record mit ner Menge Methoden ohne das IDEFixPack, wo Andreas nen Fix für den Compiler eingebaut hat, total abröcheln würde, dann würd ich das mehr benutzen.