Generisches Interface und GUID

[s.h.a.r.k]

Tag zusammen,

habe gerade folgende Frage: wie genau läuft das denn, wenn ich eine generisches Interface habe und darin eine GUID erzeuge?! Gibt es überhaupt eine GUID bei solches Interface-Deklarationen?

Beispiel:

Delphi-Quellcode:

IMyInterface<T> = interface
  ['{FF9D4362-FBD2-4333-B6B0-09B1A026E8A1}']
  function Blub(): T;
end;

Eigentlich müsste hier die GUID doch total ignoriert werden, da diese sich ja bei den später erzeugten Interfaces unterscheiden muss. Eine Angabe einer GUID kann doch nur völlig nutzlos sein, oder? Oder erzeugt der Compiler dann später selbstständig welche, wenn hier eine GUID angegeben ist? Kennt sich hier jemand aus?

[Codewalker]

Es dürfte doch nicht anders sein als bei nicht-generischen Interfaces.

Delphi-Quellcode:

  IInterface = interface
    ['{00000000-0000-0000-C000-000000000046}']

Du hast zwar eine Vorgabe, die kannst du beim Ableiten überschreiben, musst du aber nicht.

Delphi-Quellcode:

IIntegerInterface = interface(IMyInterface<Integer>)
    ['{6919D346-181D-4E80-A485-94542EA566F2}']

(ohne Delphi getippt, also ohne Gewähr)

[himitsu]

Im Prinzip sollten, bei dieser Deklarationen, alle Genericas davon die selbe GUID haben.

[Uwe Raabe]

Zitat von himitsu:

Im Prinzip sollten, bei dieser Deklarationen, alle Genericas davon die selbe GUID haben.

Haben sie auch! IMyInterface<Integer> und IMyInterface<Double> hätten dann beide die gleiche GUID. Ob es wirklich das ist, was man will, ist eine andere Frage.

[jaenicke]

Meistens macht das so auch Sinn. Denn schließlich geht es bei einem generischen Interface (wie bei Klassen) um gleiche Methoden bezogen auf verschiedene Typen um es mal so auszudrücken. Um welchen konkreten Typ es sich handelt, ist also bei der Abfrage, ob ein bestimmtes Interface unterstützt wird, meistens gar nicht relevant. Das ergibt sich ja aus dem Kontext bei der Verwendung.

[Uwe Raabe]

Es ergeben sich dann allerdings ganz lustige Effekte. Der unbedarfte Programmierer könnte annehmen, die Assertions würden anschlagen:

Delphi-Quellcode:

type
  IMyInterface<T> = interface
    ['{FF9D4362-FBD2-4333-B6B0-09B1A026E8A1}']
    function Blub(): T;
  end;

  TMyClass<T> = class(TInterfacedObject, IMyInterface<T>)
  private
    FValue: T;
  public
    constructor Create(AValue: T);
    function Blub(): T;
  end;

function TMyClass<T>.Blub: T;
begin
  result := FValue;
end;

var
  int: IMyInterface<Integer>;
  dbl: IMyInterface<Double>;
begin
  int := TMyClass<Integer>.Create(1);
  dbl := TMyClass<Double>.Create(0.1);

  Assert(Supports(int, IMyInterface<Double>));
  Assert(Supports(dbl, IMyInterface<Integer>));
end;

[himitsu]

Aber so hätte man dann Interfaces mit den selben GUIDs, aber unterschiedlichen Schnittstellen, was eigentlich nicht Sinn der Interfaces ist.

[Uwe Raabe]

Noch besser!

Delphi-Quellcode:

var
  int: IMyInterface<Integer>;
  dbl: IMyInterface<Double>;
begin
  int := TMyClass<Integer>.Create(1);
  dbl := TMyClass<Double>.Create(0.1);

  Assert(Supports(int, IMyInterface<Double>));
  Assert(Supports(dbl, IMyInterface<Integer>));

  int := dbl as IMyInterface<Integer>;
  ShowMessage(IntToStr(int.Blub));
end;

[Uwe Raabe]

Zitat von himitsu:

Aber so hätte man dann Interfaces mit den selben GUIDs, aber unterschiedlichen Schnittstellen, was eigentlich nicht Sinn der Interfaces ist.

Das ist ganz genau das Problem!

[s.h.a.r.k]

Herzlichen Dank an dieser Stelle für die ausführlichen Posts und Beispiele! Ist schon interessant, was dabei alle zu Tage gefördert wird.