Schon wieder: Warum Interfaces

[Aviator]

Zitat von stahli:

Wobei man Ableitungen von Interfaces eher vermeiden sollte. Hier werden ja eher Funktionalitäten beschrieben und dabei ist es i.d.R. sinnvoll, viele kleine eigenständige Funktionalitäten (Interfaces) zu definieren als von anderen abzuleiten.

Du hast mir gerade einen Anreiz gegeben, mein noch am Anfang stehendes Projekt nochmal etwas umzustrukturieren. Allerdings habe ich da dann gerade ein Verständnisproblem.

Folgender Fall:

Delphi-Quellcode:

IMyIntf1 = interface(IInterface)
  procedure SomeMethod1();
  procedure SomeMethod2();
end;

IMyIntf2 = interface(IMyIntf1)  // Hier noch abgeleitet von IMyIntf1
  procedure SomeMethod3();
end;

Delphi-Quellcode:

TMyClass = class(TInterfacedObject, IMyIntf1, IMyIntf2)  // Hier könnte man IMyIntf1 ja denke ich auch weglassen
  procedure SomeMethod1();
  procedure SomeMethod2();
  procedure SomeMethod3();
end;

Delphi-Quellcode:

TMyOtherClass = class(TObject)
type
private
  MyIntfInstance: IMyIntf2;  // Hier die 2 beachten
  procedure CallInterfaceMethod;
end;

implementation

procedure TMyOtherClass.CallInterfaceMethod;
begin
  MyIntfInstance.SomeMethod1();   // Hier die 1 beachten.
end;

In dem Konstrukt mit der Ableitung des Interfaces 2 von 1 ist das oben gezeigte Beispiel kein Problem. Wenn ich aber jetzt IMyIntf2 gesondert behandele und in TMyClass implementiere, dann erhalte ich ja eine Fehlermeldung, dass SomeMethod1() in dem Kontext nicht verfügbar ist.

Nur wie löse ich jetzt das Problem? Ich will ja jetzt nicht so viele Interfacevariablen in meiner Klasse anlegen, wie meine Interfaceklasse Interfaces importiert. Das halte ich für sehr umständlich. Ich kenne zwar vom Hören die Methode Supports(), weiß aber nicht, in wiefern das darauf anzuwenden ist.

Hat da jemand einen Tipp?

[Sherlock]

Ganz wichtig, @Jim Carey: Klassen IMMER! Interfaces dann wenn es sinnvoll ist (darüber streiten sich dann die Experten ) Ein Interface ersetzt keine Klasse, Interfaces sind "nur" Vorschriften darüber wie wirkliche Implementierungen auszusehen haben.

Sherlock

[Jim Carrey]

Zitat von Sherlock:

Klassen IMMER! Interfaces dann wenn es sinnvoll ist

Mit der Antwort kann ich etwas anfangen und bestätigt mich in meiner Meinung, nicht alles sofort auf Interfaces umstellen zu müssen, nur weil es sie gibt

Danke.

[DeddyH]

Ich mache das normalerweise so:

Delphi-Quellcode:

type
  IIntf1 = interface
    ['{AA7958DE-7A80-4F11-A5D5-A70BB3D51320}']
    procedure SomeMethod1;
    procedure SomeMethod2;
  end;

  IIntf2 = interface
    ['{A25606F4-B121-4FA5-BF07-B40C7784FFB7}']
    procedure SomeMethod3;
  end;

  TTestClass = class(TInterfacedObject, IIntf1, IIntf2)
  public
    //IIntf1
    procedure SomeMethod1;
    procedure SomeMethod2;
    //IIntf2
    procedure SomeMethod3;
  end;

{ TTestClass }

procedure TTestClass.SomeMethod1;
begin
  ShowMessage('SomeMethod1');
end;

procedure TTestClass.SomeMethod2;
begin
  ShowMessage('SomeMethod2');
end;

procedure TTestClass.SomeMethod3;
begin
  ShowMessage('SomeMethod3');
end;

procedure TFormTest.Button1Click(Sender: TObject);
var
  Test: IIntf1;
  Intf2: IIntf2;
begin
  Test := TTestClass.Create;
  Test.SomeMethod1;
  if Supports(Test, IIntf2, Intf2) then
    Intf2.SomeMethod3;
end;

[stahli]

Genau so.

Ich will nur noch ergänzen:

Um Supports nutzen zu können muss das Interface eine Guid haben.
Und Supports liefert im letzten Parameter automatisch den Cast des übergebenen Objektes/Interfaces auf das im zweiten Parameter übergebene Interface zurück. Oder Nil wenn Supports nicht true ist.

Ich hatte mich damit (auch?) zunächst schwer getan, aber es ist eigentlich ganz simpel.

[Aviator]

@DeddyH: Danke. Super Beispiel. Wird aber dann doch immer etwas aufwendig wenn man immer wieder mit Supports() abfragen muss.

Zitat von stahli:

Um Supports nutzen zu können muss das Interface eine Guid haben.

Das wa rmir bekannt, aber gut das du das für alle anderen hier auch nochmal erwähnst.

Zitat von stahli:

Und Supports liefert im letzten Parameter automatisch den Cast des übergebenen Objektes/Interfaces auf das im zweiten Parameter übergebene Interface zurück. Oder Nil wenn Supports nicht true ist.

Ok. Das wusste ich jetzt noch nicht, wäre aber das nächste gewesen, was ich mir angeschaut hätte.

[DeddyH]

Ob ich nun Supports() aufrufen muss oder Dinge der Art

Delphi-Quellcode:

if MyObject is TDingens then
  TDingens(myObject).Machwas;

, komfortabler wird es nicht.

[edit] Nachtrag: stahli hat Recht, man kann das übrigens auch anders formulieren.

Delphi-Quellcode:

Supports(Test, IIntf2, Intf2);
if Assigned(Intf2) then
  Intf2.SomeMethod3;

[/edit]

[Aviator]

Hmm, ja stimmt auch wieder.

Was sagt denn der TE "Exilant" mittlerweile zu dem Thema? Ist das alles jetzt etwas verständlicher?

[exilant]

Zitat von Aviator:

Was sagt denn der TE "Exilant" mittlerweile zu dem Thema? Ist das alles jetzt etwas verständlicher?

Zunächst mal vielen Dank an alle Schreiber hier. Eine Menge Input. So eine Resonanz habe ich nicht erwartet. Das Thema treibt doch viele um. Wie weit mich das weiter gebracht hat kann ich noch nicht abschätzen. Ich muss mir das erst mal in Ruhe zu Gemüte führen. Dazu werde ich etwas Zeit brauchen. Dieser Thread wird dazu sehr nützlich sein. Danke auch besonders an stahli, der mich auf diesen Thread hingewiesen hat.

Das mit der "Verständlichkeit" war wie ich geschrieben hatte nicht so das Problem. Interfaces setze ich seit Ewigkeiten für die Office Atomation ein. Ausserdem kommuniziere ich hier mit OPC Servern (nicht UA) - das ist auch COM/DCOM und das klappt. Auch wenn die Programmierung von dem Zeugs eine Strafe ist.

Ich suche/suchte ja nach dem Nutzen von Interfaces in eigenen Anwendungen. Und in denen verzichte ich natürlich auf COM/DCOM und DLLs solange ich es selbst in der Hand habe. Interfaces als wie Lemmy es sagt "logische oder zwingende Weiterentwicklung klassicher OOP" zu sehen: Da muss ich erstmal hinkommen.

Ich denke das in einigen Beiträgen in diesem Thread echtes Gold steckt und mich die Nützlichkeit von Interfaces in eigenen Anwendungen jenseits von COM erkennen lässt. Ich werde lesen, testen und wieder lesen.

Nochmal vielen Dank an alle. Ich werde mich bestimmt noch zu dem Thema melden sowie ich das hier durchgeackert habe. Ich denke da werden noch ein paar Dinge offen bleiben...

[bra]

Zitat von DeddyH:

Delphi-Quellcode:

Supports(Test, IIntf2, Intf2);
if Assigned(Intf2) then
  Intf2.SomeMethod3;

Könnte man das nicht kürzen?

Delphi-Quellcode:

if Supports(Test, IIntf2, Intf2) then
  Intf2.SomeMethod3;