Interface und 'normale' Referenz

[hansmaad]

Hallo zusammen,
folgendes Problem. Ich möchte ein Konzept über ein Interface definieren.

Delphi-Quellcode:

type
    IMachtBuh = interface
        procedure Buh;
    end;

Implementiert wird das z.B. von

Delphi-Quellcode:

type
    Foo = class(TInterfacedObject, IMachtBuh)
    public
        procedure Buh;
        procedure WasAnderes;
    end;

procedure Foo.Buh;
begin
    WriteLn('Foo Buh');
end;

procedure Foo.WasAnderes;
begin
    WriteLn('Was anderes');
end;

So, schön. Solche Objekt können jetzt Buh machen.

Delphi-Quellcode:

procedure MachBuh(b : IMachtBuh);
begin
    b.Buh;
end;

Das Problem ist jetzt, dass eine Foo Referenz im Aufruf von MachBuh implizit in ein IMachtBuh konvertiert wird, dass die Instanz am Ende von MachBuh auffrisst.

Delphi-Quellcode:

var
    f : Foo;
begin
    f := Foo.Create;
    MachBuh(f);
    /// ...
    f.WasAnderes;  // haha, denkste! f is futsch.
    FreeAndNil(f);
end.

Natürlich kann ich f als IMachtBuh deklarieren, dann hab ich aber keinen Zugriff mehr auf die Konzepte die Foo selber defineirt oder über andere Interfaces erbt. Oder ich mach sowas:

Delphi-Quellcode:

var
    f : Foo;
    dummy : IMachtBuh;
begin
    f := Foo.Create;
    dummy := f;
    MachBuh(f);
    /// ...
    f.WasAnderes;
end.

Was aber auch nicht besonders elegant ist. Oder ich lass mir von Euch erklären wie man es am besten macht.

[Bernhard Geyer]

Kombinierte Verwendung von Interface + Objektreferenz macht Probleme mit automatisher Referenzzählung.
Wenn du mit Interfaces arbeitest dann nur noch mit diesen!

[Uwe Raabe]

Wenn du weißt, was du tust, kannst du statt von TInterfacedObject auch von TInterfacedPersistent (classes.pas) ableiten. Dann musst du aber selbst auch für die Freigabe sorgen.

[hansmaad]

Zitat von Bernhard Geyer:

Kombinierte Verwendung von Interface + Objektreferenz macht Probleme mit automatisher Referenzzählung.
Wenn du mit Interfaces arbeitest dann nur noch mit diesen!

Das Problem hab ich ja schon erkannt. Die Frage ist wie es zu lösen ist. Ein IWasAnders Interface einführen? Aber wie sieht dann Foos Erzeugung aus?

Zitat von Uwe Raabe:

Wenn du weißt, was du tust, kannst du statt von TInterfacedObject auch von TInterfacedPersistent (classes.pas) ableiten. Dann musst du aber selbst auch für die Freigabe sorgen.

Ursprünglich hatte ich mich ja über die Referenzzählung bei Interfaces gefreut. Für so Fälle wo das stört klingt das aber interessant, wobei der Name ...Persistent irgendwie verwirrt. Muss ich mir mal anschauen.

[Bernhard Geyer]

Zitat von hansmaad:

Das Problem hab ich ja schon erkannt. Die Frage ist wie es zu lösen ist. Ein IWasAnders Interface einführen? Aber wie sieht dann Foos Erzeugung aus?

erzeugung ist genauso. Du darfst es halt keinen Referenzzeiger mehr zuweisen:

Delphi-Quellcode:

var
    f : IMachtBuh;
begin
    f := Foo.Create;

Hier nehm ich mir of COM als vorbild und leg mit eine Co-Funktion an und die Implementierende Klasse soweit verstecken das keiner mehr darauf kommt diese entsprechend über Refernzzeiger zu verwenden:

Delphi-Quellcode:

funktion CoFoo: IMachtBuh;
begin
  result = Foo.Create;
end;

[hansmaad]

Zitat von Bernhard Geyer:

erzeugung ist genauso. Du darfst es halt keinen Referenzzeiger mehr zuweisen:

Delphi-Quellcode:

var
    f : IMachtBuh;
begin
    f := Foo.Create;

Ja nu ruf aber mal Foo.WasAnderes auf.

[quantum]

Seit Delphi 2010 kann man endlich von Interface auf Instanz casten.

Code:

var
    f : IMachtBuh;
begin
    f := Foo.Create;
    (f as Foo).WasAnderes;

[xaromz]

Hallo,

wenn es nur darum geht, eine Funktion aufzurufen, kannst Du auch mit const arbeiten:

Delphi-Quellcode:

procedure MachBuh(const b : IMachtBuh);
begin
    b.Buh;
end;

Dadurch wird der Referenzzähler beim Aufruf nicht verändert und folglich das Objekt am Ende nicht freigegeben. Man sollte übrigens immer const verwenden, das vermeidet Fehler und ist außerdem noch schneller.

Gruß
xaromz

[Bernhard Geyer]

Zitat von quantum:

Seit Delphi 2010 kann man endlich von Interface auf Instanz casten.

Das halte ich für nicht sinnvoll. Man verwendet ja Interfaces um von den Objektinstanz-Klassen wissen zu müssen.

[Bernhard Geyer]

Zitat von xaromz:

Dadurch wird der Referenzzähler beim Aufruf nicht verändert und folglich das Objekt am Ende nicht freigegeben.

Guter Tipp Sonst mach ich bei Strings/Records alles immer mit const. Aber das das bei Interfaces auch was positives bewirkt ist ja schön.