Hallo,

folgende Situation:

markieren

Delphi-Quellcode:

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

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

Darauf will ich jetzt zugreifen:

markieren

Delphi-Quellcode:

ObjektListe.Add(TMyInterfaced.Create);

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

Und jetzt gibt es irgendwo ein Ereignis:

markieren

Delphi-Quellcode:

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

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

markieren

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?

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

ah ja. gut zu wissen.

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

markieren

Delphi-Quellcode:

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

markieren

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.

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...)

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.

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

markieren

Delphi-Quellcode:

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

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

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

Dann geht aber auch

  TMyInterface.Create as IMyInterface und das ohne extra Klasse und Typsicher.

Gruß Hagen