Polymorphie und Interfaces in Delphi

[himitsu]

Das wäre aber auch nicht so gut, wenn Delphi das einfach so machen würde, denn es kann ja gewollt sein, daß IBaseInterface nicht supported wird und was macht man dann?

Das mit den GUIDs liegt an Windows und nicht an Delphi.
Nur die GUID ist wichtig und den Namen interessiert keinen.
Du kannst das Interface problemlos umbenennen, bzw. jedes Programm/DLL kann einen anderen Namen vor dem Compilieren verwenden, solange die GUID und die ordinalen Positionen der beliebig benennbaren Methoden gleich bleibt.

[alda]

Zitat:

Das wäre aber auch nicht so gut, wenn Delphi das einfach so machen würde, denn es kann ja gewollt sein, daß IBaseInterface nicht supported wird und was macht man dann?

Genau darauf will ich ja hinaus: Gibt es diesen Fall? Ich hätte gesagt nein, da ich über das IExtendedInterface auch das IBaseInterface implementiere.

[Uwe Raabe]

Zitat von alda:

Zitat:

Das wäre aber auch nicht so gut, wenn Delphi das einfach so machen würde, denn es kann ja gewollt sein, daß IBaseInterface nicht supported wird und was macht man dann?

Genau darauf will ich ja hinaus: Gibt es diesen Fall? Ich hätte gesagt nein, da ich über das IExtendedInterface auch das IBaseInterface implementiere.

Diesen Fall wird es spätestens in dem Moment geben, wo Delphi das nicht mehr unterstützen würde. Die Tatsache, daß wir uns vielleicht im Moment keinen derartigen Fall vorstellen können, ist allenfall ein Zeichen unseres beschränkten Denkens und kein Beweis, daß es ihn nicht gibt oder geben wird.

[Mikkey]

Zitat von Uwe Raabe:

Zitat von alda:

Zitat:

Das wäre aber auch nicht so gut, wenn Delphi das einfach so machen würde, denn es kann ja gewollt sein, daß IBaseInterface nicht supported wird und was macht man dann?

Genau darauf will ich ja hinaus: Gibt es diesen Fall? Ich hätte gesagt nein, da ich über das IExtendedInterface auch das IBaseInterface implementiere.

Diesen Fall wird es spätestens in dem Moment geben, wo Delphi das nicht mehr unterstützen würde. Die Tatsache, daß wir uns vielleicht im Moment keinen derartigen Fall vorstellen können, ist allenfall ein Zeichen unseres beschränkten Denkens und kein Beweis, daß es ihn nicht gibt oder geben wird.

Tut mir leid, wenn ich da widerspreche, aber wenn ein Objekt das Interface IExtendedInterface anbietet muss es per Definition auch IBaseInterface anbieten.

Wenn ich eine Klasse definiere, die IExtendedInterface implementiert, bekomme ich schließlich auch einen Compilerfehler, wenn sie nicht die Methoden von IBaseInterface implementiert.

Wenn ich den obigen Code leicht modifiziere, wird er vom Compiler anstandslos geschluckt:

Delphi-Quellcode:

var obj: TKlasse;
begin
  // ...
  Irgendwas(IExtendedInterface(obj));
end;

Es fehlt also schlicht und einfach der implizite Cast von Objektreferenz auf das implementierte Interface.

[alda]

Zitat:

Diesen Fall wird es spätestens in dem Moment geben, wo Delphi das nicht mehr unterstützen würde. Die Tatsache, daß wir uns vielleicht im Moment keinen derartigen Fall vorstellen können, ist allenfall ein Zeichen unseres beschränkten Denkens und kein Beweis, daß es ihn nicht gibt oder geben wird.

Da kann ich natürlich nicht widersprechen, schön gesagt

Dennoch bin ich da auch auf Mikkey's Seite.

Zitat:

Es fehlt also schlicht und einfach der implizite Cast von Objektreferenz auf das implementierte Interface.

-> Das sehe ich genau so.

Man verwendet die Ableitung (also die Abhängigkeit) von Interfaces ja aus einem trifftigen Grund .. und der ist für mich: jemand der das Subinterface implementiert, muss auch das Superinterface bereitstellen (implementieren).

Beispiel:

Delphi-Quellcode:

IObjectReader = interface
 GetName: String;

 property Name: String read GetName;
end;

IObjectWriter = interface(IObjectReader)
 SetName(const AValue: String);

 property Name: String read GetName write SetName;
end;

Also eine Klasse die den Schreibzugriff über IObjectWriter anbietet, muss auch den Lesezugriff über IObjectReader anbieten (sonst würde der Compiler meckern aufgrund der Property).

[Patito]

Zitat von Mikkey:

Delphi-Quellcode:

var obj: TKlasse;
begin
  // ...
  Irgendwas(IExtendedInterface(obj));
end;

Es fehlt also schlicht und einfach der implizite Cast von Objektreferenz auf das implementierte Interface.

Ein Problem mit solchen impliziten Cast hat man, wenn die Klasse implizit mehrere Versionen des Basis-Interfaces hat.
Z.B. TKlasse = class(TObject, IExtendedInterface_1, IExtendedInterface_2). Welche Implementierung soll man nehmen? (Die
Implementierungen können unterschiedlich delegiert sein...)

Der Compiler könnte sich natürlich etwas mehr Mühe machen in eindeutigen Fällen ein passendes Interface zu suchen,
aber die mit impliziten Cast verbundene Raterei verursacht eigentlich immer an unerwarteter Stelle Probleme.

[Mikkey]

Zitat von Patito:

Ein Problem mit solchen impliziten Cast hat man, wenn die Klasse implizit mehrere Versionen des Basis-Interfaces hat.
Z.B. TKlasse = class(TObject, IExtendedInterface_1, IExtendedInterface_2). Welche Implementierung soll man nehmen? (Die
Implementierungen können unterschiedlich delegiert sein...)

Der Compiler könnte sich natürlich etwas mehr Mühe machen in eindeutigen Fällen ein passendes Interface zu suchen,
aber die mit impliziten Cast verbundene Raterei verursacht eigentlich immer an unerwarteter Stelle Probleme.

Dein Beispiel zieht nicht, weil die Delphi-Syntax keine zwei Implementierungen einer Funktion der Vorfahrenklasse erlaubt. Im folgenden Code habe ich das mal über zwei voneinander erbenden Klassen versucht, aber damit bekommt man auch nicht den Aufruf verschiedener Implementierungen hin:

Delphi-Quellcode:

unit IFTest;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs;

type
  IBase = interface(IInterface)
    function f1(): Integer;
  end;

  IExtend1 = interface(IBase)
    function f2(): Integer;
  end;

  IExtend2 = interface(IBase)
    function f3(): Integer;
  end;

  TK1 = class(TInterfacedObject, IExtend1)
    function f1(): Integer; virtual;
    function f2(): Integer;
  end;

  TK2 = class(TK1, IExtend2)
    function f1(): Integer; override;
    function f3(): Integer;
  end;

  TForm1 = class(TForm)
    procedure FormCreate(Sender: TObject);
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure testF(i: IBase);
begin
end;

function TK1.f1(): Integer;
begin
  result := 11;
end;

function TK1.f2(): Integer;
begin
  result := 12;
end;

function TK2.f1(): Integer;
begin
  result := 21;
end;

function TK2.f3(): Integer;
begin
  result := 23;
end;


procedure TForm1.FormCreate(Sender: TObject);
var
  o1: TK1;
  o2: TK2;
  i1, i2, i3: Integer;
begin
  o1 := TK1.Create();
  o2 := TK2.Create();
  testF(IExtend1(o1));
  testF(IExtend2(o2));
  i1 := o1.f1();
  i2 := o2.f1();
  i3 := (TK1(o2)).f1();
  ShowMessage(Format('o1: %d, o2: %d, Base(o2): %d', [i1, i2, i3]));
  // Ausgabe: 11 / 21 / 21 
end;

end.

Möglicherweise könnte das aber irgendwann mal klappen, insoweit könnte Uwe Raabes Einwand gerechtfertigt sein.

Edit:
Ziehe meinen Einwand zurück, mit "reintroduce" in der TK2-Definition (anstelle "virtual"/"override") wird tatsächlich 11/21/11 ausgegeben.

[Patito]

Zitat von Mikkey:

Dein Beispiel zieht nicht, weil die Delphi-Syntax keine zwei Implementierungen einer Funktion der Vorfahrenklasse erlaubt.

Schau Dir die Syntax zum implementieren und deligieren von Interfaces noch mal genau an....

[himitsu]

Zitat von alda:

Genau darauf will ich ja hinaus: Gibt es diesen Fall? Ich hätte gesagt nein, da ich über das IExtendedInterface auch das IBaseInterface implementiere.

Vererben ist bei Interfaces halt ein bissl anders.
Von außen kann man nicht auf die Methoden des Vorfahren zugreifen.
Man kommt da nur daran, wenn man die Interfaceinstanz auf den Vorfahren castet (als Typcast und nicht über Supports), wenn man weiß, daß dort etwas drin ist.

Ich hatte das mal verwendet, um in der Codevervollständigung die Liste kürzer zu halten, da man in Interfaces keine private-Abschnitt deklarieren kann, worin sich Getter und Setter verstecken lassen.

[alda]

Zitat:

Man kommt da nur daran, wenn man die Interfaceinstanz auf den Vorfahren castet (als Typcast und nicht über Supports), wenn man weiß, daß dort etwas drin ist.

Das ist ein Spezialfall. Der Vorfahre alleine repräsentiert nur zwei alleinstehende, öffentliche Methoden (Setter und Getter, ohne zugehörige Property). Sobald Du über den Nachfahren gehst, erkennt Delphi, dass die Getter und Setter zu der Property gehören. In meinem Beispiel hättest Du auf dem Nachfahren auch den Zugriff auf die Methoden des Vorfahren (also wie auch bei normalen Methoden, ohne Properties)