Verwendung von Interface - Verständnisfrage

[EdAdvokat]

nachdem ich mir das Thema Interface festigend nochmals vorgenommen habe, stelle ich nachfolgend meine Überlegungen in den Raum und bitte zugleich um Eure
Meinung dazu.
Ich nutze eine einfache Berechnung eines Flächeninhaltes und des Umfangs eines Rechtecks als Übungsbeispiel.
Dazu der Auszug aus der unit logic:

Delphi-Quellcode:

type
   TFlaeche = class(TInterfacedObject, ITextValue)
    private
     FLaenge : int32;
     FBreite : int32;
     FFlaeche: int32;
     procedure setLaenge(L:Int32);
     procedure setBreite(B:Int32);
     function GetFlaeche: int32;
    public
      constructor create;
      property Laenge : int32 read FLaenge write FLaenge;
      property Breite : int32 read FBreite write FBreite;
      property Flaeche : int32 read GetFlaeche write FFlaeche;
   end;

type
    TUmfang = class(TInterfacedObject, ITextValue)
      private
        FUmfang: Int32;
        FBreite: int32;
        FLaenge: int32;
      public
        constructor create;
        function GetUmfang: int32;
        function GetFlaeche : Int32;
        procedure SetLaenge(L:int32);
        procedure SetBreite(B:int32);
        property Laenge : int32 read FLaenge write FLaenge;
        property Breite : int32 read FBreite write FBreite;
        property Umfang: int32 read GetUmfang write FUmfang;
    end;

Zugleich habe ich ein Interface in einer gesonderten unit unitInterf deklariert:

Delphi-Quellcode:

type
  ITextValue = interface
    ['{14E563E8-1AE9-41F2-B362-C48D4D0AE8A0}']
    procedure SetLaenge(L : Int32);
    procedure SetBreite(B : Int32);
    function GetFlaeche : int32;
  end;

Da ich in diesem Interface keine Felder deklarieren darf, habe ich ein kleines Problem bei der Zuweisung der Felder im Hauptprogramm, wenn ich
MyFlaeche und MyUmfang mit ITextValue (also dem Interface) referenziere, denn ich soll ja nicht TFlaeche oder TUmfang als Referenz verwenden.
Mit der Zuweisung an das Interface ITextValue wird doch auch die Referenzzählung gelöst.
So habe ich das Problem mal ganz kühn mit einem Cast gelöst:

Delphi-Quellcode:

...
private    
    MyFlaeche : ITextValue;//TFlaeche; Variablenzuweisung an ITextValue
    MyUmfang : ITextValue;//TUmfang;
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}
procedure TForm1.btn1Click(Sender: TObject);
begin
  (MyFlaeche as TFlaeche).Laenge:=StrToInt(edtLaenge.text); //Input für Länge //Cast
  (MyFlaeche as TFlaeche).Breite:=StrToInt(edtBreite.text); //Input für Breite
  lblErgFl.caption := inttostr((MyFlaeche as TFlaeche).Flaeche);
end;

procedure TForm1.btn2Click(Sender: TObject);
begin
  (MyUmfang as TUmfang).Laenge:=strtoint(edtLaenge.text);
  (MyUmfang as TUmfang).Breite:=strtoint(edtBreite.text);
  lblErgUmfang.Caption:=inttostr((MyUmfang as TUmfang).Umfang);
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
  MyFlaeche:=TFlaeche.create;
  MyUmfang:=TUmfang.create;
end;

Meine Fragen:
1. ist das so richtig so oder zu umständlich?
2. würde ich MyFlaeche: TFlaeche und MyUmfang: TUmfang (also der Klasse) zuweisen würde ich zwar den Cast vermeiden, jedoch müsste ich dann auch die Objecte wieder selbst freigeben,
also hätte ich den Vorteil der Referenzzählung durch Interface eingebüßt, obwohl TFlaeche = class(TInterfacedObject, ITextValue) ja TInterfacedObject, ITextValue enthält.
3. ist es richtig bei Verwendung von Interfaces stets eine Referenz auf Interfaces zu verwenden statt auf die Klasse oder ist das egal?

[DeddyH]

Wie wäre es denn so?

Delphi-Quellcode:

type
  ITextValue = interface
    ['{14E563E8-1AE9-41F2-B362-C48D4D0AE8A0}']
    procedure SetLaenge(L : Int32);
    function GetLaenge: Int32;
    procedure SetBreite(B : Int32);
    function GetBreite: Int32;
    function GetFlaeche : int32;
    property Laenge: Int32 read GetLaenge write SetLaenge;
    property Breite: Int32 read GetBreite write SetBreite;
    property Flaeche: int32 read GetFlaeche;
  end;

  TFlaeche = class(TInterfacedObject, ITextValue)
  private
    FLaenge: int32;
    FBreite: int32;
  public
    procedure SetLaenge(L : Int32);
    function GetLaenge: Int32;
    procedure SetBreite(B : Int32);
    function GetBreite: Int32;
    function GetFlaeche : int32;
    // Die Neudeklaration der Properties ist nicht zwingend notwendig
    // Wenn man die Klasse aber einmal als solche ansprechen möchte,
    // erspart das einen Cast
    property Laenge: Int32 read GetLaenge write SetLaenge;
    property Breite: Int32 read GetBreite write SetBreite;
    property Flaeche: int32 read GetFlaeche;
  end;

...

function TFlaeche.GetBreite: Int32;
begin
  Result := FBreite;
end;

function TFlaeche.GetFlaeche: int32;
begin
  Result := FBreite * FLaenge;
end;

function TFlaeche.GetLaenge: Int32;
begin
  Result := FLaenge;
end;

procedure TFlaeche.SetBreite(B: Int32);
begin
  FBreite := B;
end;

procedure TFlaeche.SetLaenge(L: Int32);
begin
  FLaenge := L;
end;

Beispielverwendung:

Delphi-Quellcode:

procedure TFormTest.ButtonTestClick(Sender: TObject);
var
  lTest: ITextValue; // Wenn wir den Interface-Typen nehmen, brauchen wir keine manuelle Freigabe
begin
  lTest := TFlaeche.Create;
  lTest.Breite := 4;
  lTest.Laenge := 5;
  ShowMessage(lTest.Flaeche.ToString);
end;

[venice2]

Jo könnte gehen..
Aber es fehlen diverse Einträge im Interface für die Class TUmfang die ja ebenfalls als ITextValue definiert ist.
Oder?
EDIT:
Und beißen sich die Variablen nicht von class TUmpfang und TFläche wenn diese gleich sind?

[DeddyH]

Ich denke mal, dass der TE in der Lage ist, das Interface selbst dahingehend zu erweitern. Es ging ja nicht um eine C&P-Lösung, sondern u.a. darum, wie man die Typecasts vermeiden kann.

[venice2]

Zitat:

Zitat von DeddyH (Beitrag 1503230)

Ich denke mal, dass der TE in der Lage ist, das Interface selbst dahingehend zu erweitern. Es ging ja nicht um eine C&P-Lösung, sondern u.a. darum, wie man die Typecasts vermeiden kann.

Na ja das hätte er spätestens bemerkt wenn er sein Projekt kompiliert hätte das noch diverse Funktionen der class im Interface fehlen.
Nur der Richtigkeit halber.

Darf erlaubt sein Oder?
Keine Ahnung zu was der TE in der Lage ist. Deshalb habe ich darauf hingewiesen.

[DeddyH]

Zitat:

Zitat von venice2 (Beitrag 1503229)

Und beißen sich die Variablen nicht von class TUmpfang und TFläche wenn diese gleich sind?

Welche Variablen?

[Blup]

Wenn man ein Objekt erst einmal einer Interface-Variablen zugewiesen wurde, niemals wieder zurück auf die Object-Klasse gehn.
Auch keine Variablen mit Referenz auf das Object halten.
Sonst kommt man über kurz oder lang in Teufels Küche.

Aber so ein Konstrukt zur Initialisierung ist zulässig:

Delphi-Quellcode:

function CreateMyInterface(AParam1, AParam2: Integer): IMyIntegerface;
var
  MyObject: TMyObject;
begin
  MyObject := TMyObject;
  MyObject.Param1 := AParam1;
  MyOpject.Param2 := AParam2;
  {Referenzzählung startet, nur noch auf Interface zugreifen}
  Result := MyObject;
end;

Properties im Interface sind unabhängig von den Properties einer Klasse.
Es genügt z.B. die Getter und Setter in der Klasse zu definieren und die Properties ausschließlich im Interface.

[venice2]

Zitat:

Zitat von DeddyH (Beitrag 1503232)

Zitat:

Zitat von venice2 (Beitrag 1503229)

Und beißen sich die Variablen nicht von class TUmpfang und TFläche wenn diese gleich sind?

Welche Variablen?

Laenge als bsp.

Wenn beides auf das Interface ITextValue ausgerichtet ist.

Was passiert wenn
Laenge = 20 der class TFläche zugewiesen wird und anschließend dem gleichen Interface über TUmpfang dieser wert geändert oder abgefragt wird.
Für wen ist dann der wert für Laenge im Interface gültig?

Zitat:

Es genügt z.B. die Getter und Setter in der Klasse zu definieren und die Properties ausschließlich im Interface.

Dann bekommst du den Error..

Zitat:

[DCC Error] uInterface.pas(1148): E2168 Field or method identifier expected

gerade getestet.

[DeddyH]

Das sind keine Variablen, sondern private Felder. Jede neue Instanz hat auch ihre eigenen Felder, erst recht, wenn es sich um unterschiedliche Klassen handelt, auch wenn sie dieselben Interfaces implementieren.

[venice2]

Zitat:

Das sind keine Variablen, sondern private Felder.

Ja, ja Pfennigfuchser

Zitat:

Jede neue Instanz hat auch ihre eigenen Felder, erst recht, wenn es sich um unterschiedliche Klassen handelt, auch wenn sie dieselben Interfaces implementieren.

Ok dann, deshalb habe ich gefragt.

[EdAdvokat]

vielen Dank an alle.
Ich habe die Berechnung übungsweise bewußt mit Feldern gestaltet, um die Frage zu klären, wie man damit umgeht, dass in Interface keine Felder deklariert werden können. (also Cast)
Daraus ergibt sich für mich folgendes:
1. Wenn schon Interface genutzt werden, dann unbedingt und möglichst immer eine Referenz auf Interface, also var irendwas: IblaInterface;
2. Für die Referenzzählung und damit zur Vermeidung der manuellen Freigabe von Objecten ist die Referenzierung auf Interface notwendig. Ist dafür die Verwendung von
IInterfacedObject als Teil der Objectzuweisung (also beispielsweise TFlaeche = class(TInterfacedObject, ITextValue) unbedingt notwendig oder reicht es für die
Referenzzählungsfrage auch aus nur IInterface zuzuweisen?
3. Auch im Fall der Klasse: TFlaeche = class(TInterfacedObject, ITextValue) nicht auf TFlaeche referenzieren sondern immer beispielsweise auf ITextValue, also auf ein Interface.
4. In die Deklaration des Interface soweit wie möglich alle Methoden und ggf. Eigenschaften (Properties) aufnehmen, die für die Klasse dann gebraucht werden.

Frage 2 Antwort?
Liege ich sonst mit den 4 Punkten so richtig?

Frage an Blup: wie sieht das entspr. Interface dazu aus? So richtig verstanden habe ich die Deklaration der Funktion nicht.

Delphi-Quellcode:

function CreateMyInterface(AParam1, AParam2: Integer): IMyIntegerface;

[DeddyH]

Es scheint noch ein paar Verständnisprobleme bzgl. Interfaces zu geben. Prinzipiell kann man sagen, dass ein Interface einfach nur eine Vereinbarung bzw. eine Zusicherung ist, dass eine Klasse, die das Interface implementiert, dies garantiert vollständig tut. Soll heißen: will man auf eine Klasse mit dem implementierten Interface IBla, welches die Methode Dings und die String-Eigenschaft Bums hat, zugreifen, kann man sich sicher sein, dass beides auch garantiert vorhanden ist, egal welche Klasse dahintersteckt. In Delphi sind Interfaces historisch bedingt COM-lastig, d.h. sie deklarieren mindestens die 3 Methoden QueryInterface, _AddRef und _Release. Die letzteren beiden sind für die Referenzzählung zuständig. Man kann sie selbst implementieren oder erbt einfach von TInterfacedObject (Referenzzählung aktiv) oder TInterfacedPersistent (Referenzzählung inaktiv). Bei der Deklaration einer Klasse muss man von einer anderen Klasse erben (und sei es TObject), kann aber mehrere Interfaces implementieren.

[delphifan2004]

Zitat:

Zitat von DeddyH (Beitrag 1503228)

Wie wäre es denn so?

Delphi-Quellcode:

type
  ITextValue = interface
    ['{14E563E8-1AE9-41F2-B362-C48D4D0AE8A0}']
    procedure SetLaenge(L : Int32);
    function GetLaenge: Int32;
    procedure SetBreite(B : Int32);
    function GetBreite: Int32;
    function GetFlaeche : int32;
    property Laenge: Int32 read GetLaenge write SetLaenge;
    property Breite: Int32 read GetBreite write SetBreite;
    property Flaeche: int32 read GetFlaeche;
  end;

  TFlaeche = class(TInterfacedObject, ITextValue)
  private
    FLaenge: int32;
    FBreite: int32;
  public
    procedure SetLaenge(L : Int32);
    function GetLaenge: Int32;
    procedure SetBreite(B : Int32);
    function GetBreite: Int32;
    function GetFlaeche : int32;
    // Die Neudeklaration der Properties ist nicht zwingend notwendig
    // Wenn man die Klasse aber einmal als solche ansprechen möchte,
    // erspart das einen Cast
    property Laenge: Int32 read GetLaenge write SetLaenge;
    property Breite: Int32 read GetBreite write SetBreite;
    property Flaeche: int32 read GetFlaeche;
  end;

...

function TFlaeche.GetBreite: Int32;
begin
  Result := FBreite;
end;

function TFlaeche.GetFlaeche: int32;
begin
  Result := FBreite * FLaenge;
end;

function TFlaeche.GetLaenge: Int32;
begin
  Result := FLaenge;
end;

procedure TFlaeche.SetBreite(B: Int32);
begin
  FBreite := B;
end;

procedure TFlaeche.SetLaenge(L: Int32);
begin
  FLaenge := L;
end;

Beispielverwendung:

Delphi-Quellcode:

procedure TFormTest.ButtonTestClick(Sender: TObject);
var
  lTest: ITextValue; // Wenn wir den Interface-Typen nehmen, brauchen wir keine manuelle Freigabe
begin
  lTest := TFlaeche.Create;
  lTest.Breite := 4;
  lTest.Laenge := 5;
  ShowMessage(lTest.Flaeche.ToString);
end;

Ok, so definiere ich mein Interface. Aber wie verwende ich das dann? ANgenommen ich besitze von diesem Code hier nur die .dcu Datei und will das Interface nutzen. Hier wird es nur implementiert.

Wie verwende ich dann ITextValue?

So wie oben geht ja schon mal, aber wie sind solche Interfaces denn standardmäßig dokumentiert? Ich fürchte, dass ich dann nur von ITextValue weiß, aber nichts davon, dass es da eine Klasse TFläche gibt, die wie oben zu sehen, auf das Interface zugreift. Ich benötige diese Technik auch für ein Projekt das aus mehreren Quellen von unterschiedlichen Programmautoren stammt, für das ich mit dem Interface eine einheitliche Schnittstelle schaffen will. Am Ende sollen nicht die verschiedenen Klassen, sondern eben das Interface für die weitere Codierung benutzt werden.

Ist der Weg oben da der Einzzige oder gibt es bessere Lösungen?

Könnte ich auch ohne TFläche.Create eine Variable vom Typ ITextvalue definieren und verwenden? Wenn zum Beispiel diese Unit hier vorläge, der Create Konstruktor im Initialisierungsteil der Unit aufgerufen würde und ich von einer anderen Unit aus dann diese Inerface ITextValue benutzen wollte?

[himitsu]

Du braucht dann irgendwo nur die Interface-Definition (selbst geschrieben oder importiert)
und mußt die Funktion aufrufen, welche dir eine Interface-Instanz gibt.

[jaenicke]

Zitat:

Zitat von delphifan2004 (Beitrag 1506762)

So wie oben geht ja schon mal, aber wie sind solche Interfaces denn standardmäßig dokumentiert? Ich fürchte, dass ich dann nur von ITextValue weiß, aber nichts davon, dass es da eine Klasse TFläche gibt, die wie oben zu sehen, auf das Interface zugreift. Ich benötige diese Technik auch für ein Projekt das aus mehreren Quellen von unterschiedlichen Programmautoren stammt, für das ich mit dem Interface eine einheitliche Schnittstelle schaffen will. Am Ende sollen nicht die verschiedenen Klassen, sondern eben das Interface für die weitere Codierung benutzt werden.

Das ist genau der Punkt. Du holst dir z.B. über eine DLL-Funktion oder eine Funktion einer kompilierten Unit das Interface ITextValue. Die Klasse, die dieses implementiert, sollst du gar nicht kennen. Es genügt, wenn sie derjenige kennt, der dir dieses fertig implementierte Interface liefert. Denn derjenige erstellt dafür ja dann eine Instanz dieser Klasse.

Eine solche Schnittstelle, z.B. auch für DLL-Plugins, muss dann lediglich das Interface definieren, das die andere Seite erwartet. Welche Klasse dann dahintersteckt, muss nur der Lieferant wissen, nicht aber derjenige, der das Interface bekommt und damit arbeitet.

[MyRealName]

Zitat:

Zitat von DeddyH (Beitrag 1503247)

Es scheint noch ein paar Verständnisprobleme bzgl. Interfaces zu geben. Prinzipiell kann man sagen, dass ein Interface einfach nur eine Vereinbarung bzw. eine Zusicherung ist, dass eine Klasse, die das Interface implementiert, dies garantiert vollständig tut.

Ich denke, dass geht noch weiter. Nicht nur, dass die 1 oder mehrere Klassen dasselbe Interface implementieren, sondern auch Dir egal sein kann, wo in der Klasse das implementiert ist. Eine Klasseninstanz ist ja nur ein Pointer und jede Variable, procedure etc dieser Klasse ist eion Offset zu diesem Pointer. Mit einem Interface musst Du Dich dann nicht noch drum kümmern, dass alles am gleichen Offset steht. In jeder Implementierung kann es ein anderes Offset haben und das interface geht trotzdem :)