Interfaces - Multiple Inheritance

[stahli]

Zitat von Patito:

IReadWrite = interface(IRead, IWrite) geht nicht. Daher kann leider nur
IReadWrite = interface(IRead) oder IReadWrite = interface(IWrite) machen.

Ich will das gleich nochmal anprangern (weil ich gerade auf das Problem gestoßen bin).

Ist das in XE6 immer noch so?
Eine Mehrfachvererbung von Interfaces wäre wirklich sehr übersichtlich.

Dass Supports die Vererbungen nicht nachvollziehen kann und in den Klassen daher die einzelnen Interfaces angegeben werden müssen finde ich weniger schlimm.

Aber ein Interface von mehreren anderen abzuleiten wäre schon sehr hilfreich.

[Sir Rufo]

Zitat von stahli:

Zitat von Patito:

IReadWrite = interface(IRead, IWrite) geht nicht. Daher kann leider nur
IReadWrite = interface(IRead) oder IReadWrite = interface(IWrite) machen.

Ich will das gleich nochmal anprangern (weil ich gerade auf das Problem gestoßen bin).

Ist das in XE6 immer noch so?
Eine Mehrfachvererbung von Interfaces wäre wirklich sehr übersichtlich.

Dass Supports die Vererbungen nicht nachvollziehen kann und in den Klassen daher die einzelnen Interfaces angegeben werden müssen finde ich weniger schlimm.

Aber ein Interface von mehreren anderen abzuleiten wäre schon sehr hilfreich.

Dadurch gibt es doch nur heilloses Durcheinander und da eine Klasse mehrere Interfaces implementieren kann ist es auch überflüssig.

[himitsu]

Wozu willst du mehrere Interfaces vererben?

IRead und IWrite und dann wird eines von Beiden oder Beides bei den entsprechenden Klassen angegeben.

Sowas geht zwar auch

Delphi-Quellcode:

type
  IRead = interface
    function ReadInt: Integer;
  end;
  IWrite = interface
    procedure WriteInt(Value: Integer);
  end;
  IReadWrite = interface
    function ReadInt: Integer;
    procedure WriteInt(Value: Integer);
  end;

oder sowas

Delphi-Quellcode:

type
  IRead = interface
    function ReadInt: Integer;
  end;
  IWrite = interface
    procedure WriteInt(Value: Integer);
  end;
  IReadWrite = interface(IRead)
    procedure WriteInt(Value: Integer);
  end;

Aber da muß man dann bei den Funktionen, welche auf diese Interfaces prüfen, die Interfaces doppelt abfragen, da es je "Funktion" zwei Interfaces gibt.
Read = IRead oder IReadWrite
Write = IWrite oder IReadWrite

[Sir Rufo]

Zudem man bei der Klasse (wie schon mehrfach erwähnt) jedes Interface angeben muss.

Somit hilft einem dieses Multi-Erben auch nicht wirklich.

BTW Wenn man die implementierende Klasse nicht von TInterfacedObject ableiten möchte.

Delphi-Quellcode:

type
  IMyInterface = interface
  end;

  TMyInterfacedObject = class( TObject, IMyInterface )
    ...
  end;

dann kann man das auch nicht gegen das Basis-Interface IInterface casten.

[stahli]

Da muss ich offenbar noch etwas drauf rum denken...

Mit der Klassendefinition habe ich kein Problem.
Wenn ich die Objekte in einer Factory erzeugen lasse und nur mit den Interfaces weiter arbeite, dann erscheint mir eine Mehrfachvererbung doch sinnvoll.

Delphi-Quellcode:

var RW: IReadWrite;
    X: Integer;
...
RW := TFactory.GetNewRW; // erzeugt ein TReadWrite und gibt es als IReadWrite zurück
...
// folgendes ist möglich
RW.WriteInt(1);
X := RW.ReadInt;
// bzw. auch über Property
RW.Int := 1;
X := RW.Int;

In RW sind beide Funktionalitäten deklariert.

IReadWrite selbst könnte einfach so definiert sein:

Delphi-Quellcode:

IReadWrite = Interface(IRead, IWrite);
end;

Ohne diese Mehrfachvererbung muss man die Funktionen (mindestens zum Teil) in den Interfacedefinitionen doppelt schreiben.

Wenn man RW nicht als IReadWrite definiert sondern als "BasisInterface" muss man immer Supports verwenden und casten.


PS:
Gibt es denn irgendwo ein Delphi-Tutorial, wie man korrekt mit einer Factory und komplexen Schnittstellen arbeitet?
So ganz konkret habe ich dazu noch nichts gefunden. Vielleicht bin ich ja noch etwas auf dem Holzweg...
(Das Entwufsmusterbuch habe ich jetzt zwar erhalten, aber das bleibt ja auch noch etwas abstrakt und ich konnte mich bisher noch nicht länger damit befassen.)

[Sir Rufo]

Warum denn nicht einfach kreativ so

Delphi-Quellcode:

IRead = interface
  function Read : Integer;
end;

IWrite = interface
  procedure Write( Value : Integer );
end;

IReadWrite = Interface;
  function Reader : IRead;
  function Writer : IWrite;
end;

TReadWrite = class( TInterfacedObject, IRead, IWrite, IReadWrite )
private
  FValue : Integer;
public
  // IRead
  function Read : Integer;
  // IWrite
  procedure Write( Value : Integer );
  // IReadWrite
  function Reader : IRead;
  function Writer : IWrite;
end;

function TReadWrite.Read : Integer;
begin
  Result := FValue;
end;

procedure Write( Value : Integer );
begin
  FValue := Value;
end;

function Reader : IRead;
begin
  Result := Self;
end;

function Writer : IWrite;
begin
  Result := Self;
end;

[sahimba]

Nur als Einwurf, etwas OT aber auch nicht ganz. Interface-Vererbung, zumal mehrfache/tiefe Vererbung, halte ich so ganz aus dem Bauch heraus für mitunter fragwürdig. Oft endet es dann, dass man eine komplexe Hierarchie Interfaces definiert, welche dann fast 1:1 als Hierarchie von Klassen implementiert wird. Der Gedanke, ein Interface als eine Art "Service" zu sehen, den ein Objekt anbietet/unterstützt, fällt dabei vollkommen heraus. Die meisten Interfaces sollten wohl eher "schlank" sein.
Und jetzt lese ich mir mal durch, warum man in Delphi die implementierten Interfaces explizit angeben muss. Mich hat das schon mehr als einmal genervt...
Schöne Feiertage btw!

[stahli]

Das ist ein guter Einwand.

Wenn man aber die Instanziierung der Klassen (Erzeugen der Objekte) auslagert und fortan nur noch mit Interfaces arbeiten will, dann braucht man wiederum mächtige Interfaces, die die gesamte Funktionalität veröffentlichen.
Andernfalls müsste man immer prüfen, ob das vorliegende (Objekt-)Interface nun gerade zufällig IRead oder IWrite unterstützt, darauf casten und dann auf die Propertys zugreifen.

Andererseits bringt das natürlich auch wieder Vorteile, da man so sehr flexibel mit den Objekt-Interfaces umgehen kann.
Eigentlich bräuchte man dann IReadWrite gar nicht sondern würde einfach mit IInterface arbeiten:

Delphi-Quellcode:

var RW: IInterface;
     X: Integer;
 ...
 RW := TFactory.GetNewRW; // erzeugt ein TReadWrite und gibt es als IInterface zurück
 ...
 if Supports(RW, IWrite) then 
   (RW as IWrite).WriteInt(1);
 if Supports(RW, IRead) then 
   X := (RW as IRead).ReadInt;
// bzw. auch über Property
 if Supports(RW, IWrite) then 
   RW.Int := 1;
 if Supports(RW, IRead) then 
   X := (RW as IRead).Int;

Dann braucht man sich gar nicht mehr kümmern, was genau da für ein Objekt vorliegt (eigentlich ja der Sinn von Interfaces).
Wenn man sicher ist, was man übergibt kann man Supports ja notfalls weg lassen.

Alternativ könnte man natürlich noch Variablen wie R: IRead und W: IWrite einführen.

Auf jeden Fall könnte man auf mächtige Schnittstellen als Klassenkopien so verzichten.

Aktuell scheint mir der Ansatz eigentlich sinnvoll zu sein (kann sich aber wieder ändern ).
Ginge das so?

[himitsu]

Zitat von Sir Rufo:

Zudem man bei der Klasse (wie schon mehrfach erwähnt) jedes Interface angeben muss.

Drum meinte ich ja, daß man sonst alle drei Interfaces auswerten muß, da wo auf die Interfaces getestet wird.
Dann braucht man nur noch jeweils Eines der Drei anzugeben.