Ich arbeite viel mit Interfaces. Mich nervt, dass die
IDE (m.E.) das kaum unterstützt.
So muss man redundant und wiederholt ständig das gleiche schreiben und man findet die Methoden nicht vernünftig in der
Unit, da diese beliebig einsortiert werden.
Also folgendes Beispiel mit anschließender Erklärung...
UnitMyIntf.pas
Delphi-Quellcode:
IMyIntf1 = Interfaces
property MyProp1: string read write;
procedure Do1(P: string);
end;
IMyIntf2 = Interfaces
property MyProp2: string read;
procedure Do2(P: string);
end;
UnitMyClass.pas
Delphi-Quellcode:
TMyClass = class(TInterfacedObject, IMyIntf1, IMyIntf2)
protected { IMyIntf1 }
fMyProp1: string;
function _get_MyProp1: string;
procedure _set_MyProp1(Value: string);
protected { IMyIntf2 }
fMyProp2: string;
function _get_MyProp2: string;
public
constructor Create; virtual;
destructor Destroy; override;
public { IMyIntf1 }
property MyProp1: string read _get_MyProp1 write _set_MyProp1;
procedure Do1(P: string);
public { IMyIntf2 }
property MyProp2: string read _get_MyProp2;
procedure Do2(P: string);
end;
...
{ TMyClass }
constructor TMyClass.Create;
begin
end;
destructor TMyClass.Destroy;
begin
inherited;
end;
{ TMyClass / IMyIntf1 }
function TMyClass._get_MyProp1: string;
begin
Result := fMyProp1;
end;
procedure TMyClass._set_MyProp1(Value: string);
begin
fMyProp1 := Value;
end;
procedure TMyClass.Do1(P: string);
begin
end;
{ TMyClass / IMyIntf2 }
function TMyClass._get_MyProp2: string;
begin
Result := fMyProp2;
end;
procedure TMyClass.Do2(P: string);
begin
end;
Ich hätte gern folgende Aspekte:
1) Im Interface möchte ich die Getter und Setter nicht komplett definieren müssen. Dies würde die Sache vereinfachen und die Übersichtlichkeit erhöhen.
Der Compiler könnte ja eigentlich - wenn dort "read" und/oder "write" steht, einfach "gedanklich" Standardgetter und -setter voraussetzen.
2) In den Klassen hätte ich gern die Abschnitte, die Interfaces zugewiesen sind, entsprechend geordnet und beschrieben.
Im Implementationsteil sollte das entsprechend gehandhabt werden. Zunächst sollten Constructor und Destructor kommen, dann die normalen Methoden und dann die Interface-Methoden mit entsprechender Gliederung und Sortierung.
3) Sofern in den Interfaces Getter und Setter definiert sind und diese in den Klassen erstmalig erzeugt werden, sollten auch gleich private Felder "fMyProp: MyType;" eingerichtet und in den Gettern und Settern benutzt werden. Da ist ja bestimmt zu 95% der Normalfall und mich nervt, dass man das jedesmal neu von Hand machen muss (zumal Getter und Setter ja wild in der
Unit verteilt sind).
4) Refactoring von Interfaces zu Klassen sollte möglich sein. Wenn ich z.B.
procedure Do1(P: string);
im Interface ändere in
procedure Do1(const aValue: string);
sollte das auch in die Klassendeklarationen übertragbar sein, die dieses Interface verwenden (im Interface- und Implementationsteil).
Die Methoden können dann zwar ggf. nicht kompiliert werden, aber ich brauch nur noch die logischen Dinge anpassen und bin sicher, dass die Änderungen im Interface (z.B. Propertynamen) auch in den Klassen angepasst wird.
Ich wüsste mal gern Eure Meinung dazu.
Haltet Ihr die Überlegungen für sinnvoll/wichtig?
Gibt es dazu vielleicht schon Möglichkeiten, die ich bisher übersehen habe (Ich würde mich in den A... beißen und davon ein Foto hochladen
)).
Hättet Ihr (die Ihr mit Interfaces arbeitet) Interesse an so einer Lösung?
Auf Emba setze ich diesbezüglich leider nicht. Wenn diese Dinge demnächst richtig gut unterstützt würden, dann würde ich sogar nochmal ein Update in Erwägung ziehen. Aber da gibt es ja sicher andere Prioritäten.
Aber ich habe eine Idee zu einem Tool, das den Interface-Quelltext analysiert, die fehlenden Getter und Setter (wie oben im Beispiel) ergänzt und dann die verwendenden Klassen zerlegt, ordnet, ergänzt, anhand der Interface-Vorgaben korrigiert und entsprechend dem obigen Beispiel neu zusammenbaut. So könnten viele, immer gleiche Arbeitsschritte deutlich reduziert werden.
(Angefangen habe ich damit schon.)
Meiner Meinung nach kann das extrem viel Arbeit ersparen und gleichzeitig die Übersichtlichkeit deutlich erhöhen.
Was meint Ihr dazu?
Habt Ihr Interesse an solch einem Tool?
Ist das überflüssig?
Gruß
Stahli
PS: Die externe Umsetzung halte ich für mich für machbar (so dass die Units einfach von der Exe geladen und aufbereitet werden). Damit das richtig komfortabel wäre müsste man das durch einen
IDE-Experten realisieren, der auch scannen kann, welche Units unter "uses" stehen und diese nach der Interface-Deklaration durchsuchen. Dazu habe ich noch keine Vorstellung, wie das geht...