Interface-Übergabe

[DGL-luke]

Hallo,

folgende Situation:

Delphi-Quellcode:

type
  IMyInterface = interface(IInterface)
    [(GUID-Zeuch)]
    funktionen(zeuch);
  end;

  TMyInterfaced = class(TInterfacedObject,IMyInterface)
    funktionen(zeuch);
  end;

Darauf will ich jetzt zugreifen:

Delphi-Quellcode:

ObjektListe.Add(TMyInterfaced.Create);

SomeControl.Data := Liste[0];  // Data is Pointer

Und jetzt gibt es irgendwo ein Ereignis:

Delphi-Quellcode:

procedure Bla(Sender: TObject);
begin
  MethodeDieIMyInterfaceWill(IMyInterface(SomeControl.Data));
end;

So, und da knallts, aber gewaltig... was bisher der Compiler nicht wollte:

Delphi-Quellcode:

var obj: TObject;

obj := TObject(SomeControl.Data);
MethodeDieIMyInterfaceWill(obj as IMyInterface);

Und so einiges anderes an wildem rumgecaste... er scheint TObject nicht als mit IInterface kompatibel anzuerkennen. wie sag ic h ihm, er solls trotzdem machen, ohne ihm irgendeine Vertreterklasse (in der ich das Interface implementiere) hinzucasten, was ja eigentlich nicht der Sinn von interfaces ist?

[Dax]

Wenn du statt TList TInterfaceList nimmst und statt Referenzen auf die Klassen direkt das Interface ablegst, gehts ;)

[DGL-luke]

ah ja. gut zu wissen.

[DGL-luke]

ähm... immer noch av... ich machs jetzt so:

Delphi-Quellcode:

InterfaceListe.Add(TMyInterfaced.Create);
SomeControl.Data := Pointer(InterfaceListe[0]);

Delphi-Quellcode:

Pointer(intf) := SomeControl.Data;
MethodeDieIMyInterfaceWill(intf); <- knallt hier

EDIT: 3_of_8 hat mich drauf hingewiesen.... TMyInterfaced ist natürlich von TInterfacedObject abgeleitet.

[DGL-luke]

Soo... hab das ganze jetzt komplett gekippt und verwende eine Managerklasse, die Klassen und Elemente hält und bei Bedarf ein Interface rausgibt... da geht der Refcount zwar ganz schnell auf 25, aber das krieg ich schon noch hin.

Für mich ist die Sache erledigt, und nein, den anderen Code zeige ich nicht, das ist Produktionscode, den ich nicht offenlegen darf (bisheriger Code war "anonymisiert" ;) )

PS: Bitte keine blöden Kommentare dazu, wie bereits gesagt, der neue Code hat mit dem alten nichts gemein.
(ich sag das nur, weils den fall schon mal gab...)

[Bernhard Geyer]

Hallo Lukas,

deine Versuch mittels Casten eines Interfacezeigers auf einen untypisierten Pointer ist eine ganz böse sache da du hiermit dem Compiler keine Chance läßt die Referenzzählung durchzuführen. Wenn Du den Destruktor deiner TMyInterfaced-Klasse mal debuggen würdest, würdest Du vermutlich feststellen das die Klasse schon zu einem Zeitpunkt freigegeben wird, zu dem du es nicht erwartest.

Ich würde ebenfalls noch eine Co-Klassen definieren damit du ähnich wie bei COM-Interfaces nur noch mit Interfaces arbeitest und nicht in die Versuchung kommst einen gemischten Betrieb zu fahren.

[DGL-luke]

CoKlasse? Hab ich schonmal gehört... wie macht man das?

[Bernhard Geyer]

Delphi-Quellcode:

type
  CoMyInterfaced = class
    class function Create: IMyInterfaced;
  end;

class function CoMyInterfaced.Create: IMyInterfaced;
begin
  result := TMyInterfaced.Create;
end;

[DGL-luke]

ah... na das ist natürlich elegant.

[negaH]

Dann geht aber auch

Delphi-Quellcode:

  TMyInterface.Create as IMyInterface

und das ohne extra Klasse und Typsicher.

Gruß Hagen

[Bernhard Geyer]

Aber mit der Co-Klasse kann man die eigentliche Implementierungsklasse so gut "verstecken" (in Implementierungsabschnitt von Unit) das keiner sie direkt verwenden kann sondern nur über das Interface.