Zur Laufzeit entscheiden ob ein Interface implementiert wird oder nicht

[Der schöne Günther]

Gerne:

Es gab bislang immer ein Interface ISomething . Diese Instanzen wurden mittels Decorator-Pattern teilweise ein, oder zwei mal eingepackt.

Jetzt kam leider ein Interface ISomething2 hinzu dass unheimlich toll und wichtig ist. Und die Decorator können ja nicht per se ISomething2 unterstützten und wenn das dekorierte Objekt es eben nicht tut dann einfach ein ENotSupported werfen oder so.

Der Arbeitsablauf "Wenn das Ding nun ISomething2 unterstützt machen wir grad noch das und das" sollte nicht geändert werden.


Edit: Hier scheint jemand im Endeffekt die gleiche Frage zu haben und erhält darauf keine Antworten.

[Stevie]

Ein sehr schönes Beispiel, das bestätigt, was ich oft sage: Interface Casts sind in gewisser Weise ein Code Smell.

Gegeben, dass TFoo, IThis und IThat implementiert und per Decorator für IThis irgendwo reingegeben wird. Wenn ich nun dieses IThis (was den Decorator repräsentiert) anfrage, dann wird das selbst nicht IThat implementieren. Aber ich könnte den Cast (QueryInterface) an die dekorierte Komponente weitergeben und diese (also die TFoo Instanz) anfragen, ob sie IThat unterstützt.

Soweit so gut - wenn ich nun aber dieses IThat fragen würde, ob es IThis kann, dann werde ich nur das TFoo als IThis bekommen, also undekoriert, was nicht mehr mein ursprüngliches IThis (der Dekorator) ist.

Ebenso könnte es sein, dass ich auch für IThat einen Decorator habe, und diesen über meine TFoo Instanz stülpe, wenn ich diese irgendwo als IThat hereingebe. Somit wissen die beiden Decorator nichts von einander und man landet per Interface Cast immer auf der ursprünglichen undekorierten Instanz.

[Der schöne Günther]

Zitat von Stevie:

Ein sehr schönes Beispiel, das bestätigt, was ich oft sage: Interface Casts sind in gewisser Weise ein Code Smell.

Ich habe jetzt in den sauren Apfel gebissen und umgebaut.

Vorher:

Delphi-Quellcode:

type
   IThis = interface;
   IThat = interface(IThis);
   
   TImplementation = class(TInterfacedObject, IThis, IThat);
   
   TThisDecorator = class(TInterfacedObject, IThis)
      protected var
         delegate: IThis;
      public
         constructor Create(delegate: IThis);
   end;

Nachher:

Delphi-Quellcode:

type
   IThis = interface
      // Kann nil sein
      function getThat(): IThat;
   end;
   
   IThat = interface;
   
   TThisDecorator = class(TInterfacedObject, IThis)
      protected var
         delegate: IThis;
         thatDelegate: IThat; // Ist dann ein TThatDecorator
      public
         constructor Create(delegate: IThis);
         function getThat(): IThat; // liefert dann einen TThatDecorator
   end;

Ich glaube damit werde ich jetzt glücklich.

[stahli]

So ganz verstehe ich das obige Problem nicht...


Für eigene Zwecke habe ich mir etwas Artverwandtes(?) gebaut, das vielleicht als Anregung für ähnliche Anwendungen dienen kann.

Ich nutze viel "Supports()" um zu erkennen, was ich für Objekte vor mir habe.
Nun habe ich mir eine Funktion SupportsIn() gebaut, der ich einfach eine Menge von zu akzeptierenden Interfaces übergeben kann.

Als Sonderfall kann ich auch Interfaces übergeben, die das geprüfte Objekt gar nicht wirklich unterstützt, aber bei denen die Funktion TRUE zurück gibt, wenn das Objekt z.B. eine bestimmte Eigenschaft hat.

So kann ich im Programmablauf zum Einen leicht auf eine Liste von zu akzeptierenden Interfaces prüfen und zum Anderen einfach "Dummy-Interfaces" einführen, die zusätzlich gleich noch irgendwelche anderen Bedingungen prüfen und das Objekt entsprechend durch lassen oder nicht.

Ist natürlich etwas frickelig, aber hat sich für mich als sehr praktikabel bewährt (vereinfacht u.U. eben die Prüfungen in der Geschäftslogik deutlich).

Delphi-Quellcode:

TDetectArray = array of TGUID;

function SupportsIn(const aIntf: IInterface; aArray: TDetectArray): Boolean;
var
  I: Integer;
  lDetectComment_Base: IDetectComment_Base;
begin

  Result := False;

  for I := low(aArray) to high(aArray) do
  begin

    if (aArray[I] = IDetectComment_Real) then // Sonderfall !
    begin
      if Supports(aIntf, IDetectComment_Base, lDetectComment_Base) then
      begin
        if (lDetectComment_Base.RealComment) then
        begin
          Exit(True); // Dummy-Interface wird als "unterstützt" angesehen
        end;
      end;
    end;

    if Supports(aIntf, aArray[I]) then
    begin
      Exit(True);
    end;

  end;
end;


if SupportsIn(myIntf, [IDies, IDas, IDetectComment_Real]) then
  Beep;