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.:wink:

[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:

Zitat von Bernhard Geyer (Beitrag 1047788)

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:

Zitat von Uwe Raabe (Beitrag 1047795)

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:

Zitat von hansmaad (Beitrag 1047800)

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:

Zitat von Bernhard Geyer (Beitrag 1047801)

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

Delphi-Quellcode:

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

Delphi-Quellcode:

const

verwenden, das vermeidet Fehler und ist außerdem noch schneller.

Gruß
xaromz

[Bernhard Geyer]

Zitat:

Zitat von quantum (Beitrag 1047827)

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:

Zitat von xaromz (Beitrag 1047834)

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

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

[quantum]

Zitat:

Zitat von Bernhard Geyer (Beitrag 1047864)

Zitat:

Zitat von quantum (Beitrag 1047827)

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.

Da gebe ich dir Recht. Mir selbst ist das suspekt. Besser ein Interface für die benötigten Methoden einführen und nichts anderes als die Interfaces benutzen.

Delphi-Quellcode:

IMachtWasAnderes = interface
  procedure WasAnderes;
end;

Foo = class(TInterfacedObject, IMachtBuh, IMachtWasAnderes)

[hansmaad]

Zitat:

Zitat von xaromz (Beitrag 1047834)

Hallo,

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

Delphi-Quellcode:

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

Delphi-Quellcode:

const

verwenden, das vermeidet Fehler und ist außerdem noch schneller.

Gruß
xaromz

:thumb: Guter Tipp. Dazu aber (wenn zur Zeit für mich zwar nicht relevant) mal die Frage, ist der Referenzzähler von Interfaces Thread sicher? Denn wenn MachBuh(const b : IMachtBuh); den Referenzzähler nicht inkrementiert, könnte ein anderer Thread das Objekt löschen. Oder ist die Sicherheit generell nicht gegeben.

Zitat:

Zitat von quantum (Beitrag 1047869)

...Besser ein Interface für die benötigten Methoden einführen und nichts anderes als die Interfaces benutzen.

Delphi-Quellcode:

IMachtWasAnderes = interface
  procedure WasAnderes;
end;

Foo = class(TInterfacedObject, IMachtBuh, IMachtWasAnderes)

Danach hatte ich ja auch schon gefragt. Wie würdest du denn damit die Funktion aus dem ersten Beitrag schreiben?

[mjustin]

Zitat:

Zitat von hansmaad (Beitrag 1047919)

ist der Referenzzähler von Interfaces Thread sicher?

Interfaces in Delphi haben keinen Referenzzähler. Die konkreten Klassen wie z.B. TTinterfacedObject, TInterfacedPersistent oder TComponent sorgen für die Referenzzählung - daher muss man wissen, wie diese implementiert ist, um Probleme mit Threads oder Speicherlecks zu vermeiden.

• Bei TTinterfacedObject kann man im Code direkt sehen, dass threadsicher vorgegangen wird

• Bei TTinterfacedPersistent wird die Referenzzählung an ein 'FOwnerInterface' Feld delegiert (das vorhanden sein kann aber nicht muss...)

• Bei TComponent wird eine Referenzzählung an ein IVCLComObject delegiert, falls es vorhanden ist

Es gibt noch weitere Varianten der Referenzzählung (zum Beispiel bei der TRemotable für Soap). Interfaces in Delphi erlauben Freiheiten bei der Implementierung, die es in anderen Sprachen nicht gibt - wer mag, kann das natürlich auch als Vorteil sehen.

[generic]

Notfalls erzeugt man sich eine eigene Klasse, die das gewünschte verhalten hat.

[hansmaad]

Zitat:

Zitat von mjustin (Beitrag 1047933)

• Bei TTinterfacedObject kann man im Code direkt sehen, dass threadsicher vorgegangen wird

Dann muss eine Funktion, die ein IMachBuh Parameter als const nimmt trotzdem aufpassen, dass ein anderer Thread das Objekt nicht weglöscht, denn sie inkrementiert den Zähler überhaupt nicht ??

[xaromz]

Hallo,

Zitat:

Zitat von hansmaad (Beitrag 1047939)

Dann muss eine Funktion, die ein IMachBuh Parameter als const nimmt trotzdem aufpassen, dass ein anderer Thread das Objekt nicht weglöscht, denn sie inkrementiert den Zähler überhaupt nicht ??

klar musst Du bei mehreren Threads aufpassen. Das ist aber kein spezifischer Interfaceproblem. Jeder Thread kann Objekte freigeben, die in einem anderen gerade verwendet werden. Das kannst Du nur ausschließen, wenn Du ausschließlich Interfaces verwendest, dann wird nämlich die Referenz in der aufrufenden Methode gehalten und das const ist damit nur eine Optimierung:

Delphi-Quellcode:

type
  IIntf = interface
    procedure Blubb;
  end;

  TIntf = class(TInterfacedObject, IIntf)
    procedure Blubb;
  end;

procedure bla;
var
  A: IIntf;
begin
  A := TIntf.Create; // Referenz 1

  Machwas(A); // keine Änderung
end; // hier Referenz 0 -> Objekt wird zerstört

procedure Machwas(const B: IInf) // Keine Änderung
begin
  B.Blubb; // hier kann jeder Thread etwas mit dem Interface machen, der Referenzzähler bleibt immer >= 1
end;

Gruß
xaromz

[hansmaad]

Zitat:

Zitat von xaromz (Beitrag 1047969)

...

Delphi-Quellcode:

type
  IIntf = interface
    procedure Blubb;
  end;

  TIntf = class(TInterfacedObject, IIntf)
    procedure Blubb;
  end;

procedure bla;
var
  A: IIntf;
begin
  A := TIntf.Create; // Referenz 1

  Machwas(A); // keine Änderung
end; // hier Referenz 0 -> Objekt wird zerstört

procedure Machwas(const B: IInf) // Keine Änderung
begin
  B.Blubb; // hier kann jeder Thread etwas mit dem Interface machen, der Referenzzähler bleibt immer >= 1
end;

Gruß
xaromz

Natürlich muss man immer aufpassen. Dazu muss ich aber erstmal wissen was die Interfaces (oder die Basisklassen) machen. Wenn ein anderer Thread ein explizites Free ruft, ist die Sache ja klar. Die Frage war speziell auf die const und nicht const Parameter bezogen:. Dein Beispiel:

Delphi-Quellcode:

procedure Machwas(const B: IInf);
procedure MachwasNichtConst(B: IInf);

procedure bla;
var
  A: IIntf;
begin
  A := TIntf.Create; // Referenz 1
  StartThread(Machwas(A)); // keine Änderung
end; // hier Referenz 0 -> Objekt wird zerstört. MachWas() hat Pech gehabt.

procedure blaAnders;
var
  A: IIntf;
begin
  A := TIntf.Create; // Referenz 1
  StartThread(MachwasNichtConst(A)); // Referenz 2
end; // hier Referenz 1 -> Objekt wird nicht zerstört. MachWasNichtConst() hat Glück gehabt.

Ist das richtig?
Ich kanns leider nicht mal eben ausprobieren, weil ich in Delphi noch überhaupt keine Ahnung von threads habe. War nur schonmal vorweg gefragt.

[xaromz]

Hallo,

Zitat:

Zitat von hansmaad (Beitrag 1047970)

Ist das richtig?
Ich kanns leider nicht mal eben ausprobieren, weil ich in Delphi noch überhaupt keine Ahnung von threads habe. War nur schonmal vorweg gefragt.

das müsste so stimmen.

Gruß
xaromz