Hier nochmal ein neuer Zwischenstand.
Im ersten Text ist verkürzt eine Klasse deklariert und nach Tastendruck wird daraus das nachfolgende Ergebnis generiert.
Es geht noch nicht alles, aber die Idee dahinter sollte schon mal gut erkennbar sein.
Es werden die Methoden, Properties und privaten Felder erzeugt und auch die Methoden soweit möglich vorausgefüllt. Das natürlich nur, wenn sie neu generiert werden. Spätere händische Änderungen bleiben natürlich bei künftigen Optimierungen erhalten.
Der Implementationsteil wird analog dem Interfaceteil sortiert. Das gilt auch, wenn die Reihenfolge der Klassen oder Klassenmember im Interfaceteil nachträglich verändert wird. Bei der nächsten Optimierung werden dann die Klassen und Methoden im Implementationsteil an die neue Reihenfolge im Interfaceteil angepasst.
Derzeit habe ich die Getter und Setter mit _get_... und _set_ benannt und die privaten Felder mit "f".
Außerdem habe ich in generierten Methoden ein ? eingesetzt, damit man die Methoden mindestens einmal bearbeitet.
In Settern prüfe ich erst auf eine Werteänderung.
Das alles lässt sich natürlich ggf. auch über Optionen steuern, falls daran Bedarf wäre.
Original:
Delphi-Quellcode:
unit Unit2;
interface
uses
System.Classes,
Vcl.Graphics, System.Types, System.UITypes;
const
aConst = 100;
type
TClass1 =
class
private
procedure PrivProc;
virtual;
public
constructor Create;
virtual;
destructor Destroy;
override;
public
procedure Execute(NewVal:
String);
virtual;
function TestFunc(
var Val1: Integer): Boolean;
prop PropString:
string;
prop PropInteger: Integer rf;
prop PropBoolean: Boolean v ws vi;
prop PropByte: Byte s;
prop PropWord: Word c w rf;
prop PropString2:
string c vi;
end;
implementation
end.
Ergebnis:
Delphi-Quellcode:
unit Unit2;
interface
uses
System.Classes,
Vcl.Graphics, System.Types, System.UITypes;
const
aConst = 100;
type
TClass1 =
class
private
fPropString:
string;
fPropInteger: Integer;
fPropBoolean: Boolean;
fPropByte: Byte;
fPropWord: Word;
fPropString2:
string;
procedure PrivProc;
virtual;
function _get_PropString:
string;
procedure _set_PropString(aValue:
string);
procedure _set_PropBoolean(
var aValue: Boolean);
virtual;
function _get_PropByte: Byte;
stdcall;
procedure _set_PropByte(aValue: Byte);
stdcall;
function _get_PropString2:
string;
virtual;
procedure _set_PropString2(
const aValue:
string);
virtual;
public
constructor Create;
virtual;
destructor Destroy;
override;
procedure Execute(NewVal:
String);
virtual;
function TestFunc(
var Val1: Integer) Boolean
property PropString:
string read _get_PropString
write _set_PropString;
property PropInteger: Integer
read fPropInteger;
property PropBoolean: Boolean
write _set_PropBoolean;
property PropByte: Byte
read _get_PropByte
write _set_PropByte;
property PropWord: Word
read fPropWord;
property PropString2:
string read _get_PropString2
write _set_PropString2;
end;
implementation
{ TClass1 }
constructor TClass1.Create;
begin
end;
destructor TClass1.Destroy;
begin
end
procedure TClass1.PrivProc;
begin
?;
end
function TClass1._get_PropString:
string;
begin
Result := fPropString;
end
procedure TClass1._set_PropString(aValue:
string);
begin
if (fPropString <> aValue)
then
begin
fPropString := aValue;
end;
end
procedure TClass1._set_PropBoolean(
var aValue: Boolean);
begin
if (fPropBoolean <> aValue)
then
begin
fPropBoolean := aValue;
end;
end
function TClass1._get_PropByte: Byte;
begin
Result := fPropByte;
end
procedure TClass1._set_PropByte(aValue: Byte);
begin
if (fPropByte <> aValue)
then
begin
fPropByte := aValue;
end;
end
function TClass1._get_PropString2:
string;
begin
Result := fPropString2;
end
procedure TClass1._set_PropString2(
const aValue:
string);
begin
if (fPropString2 <> aValue)
then
begin
fPropString2 := aValue;
end;
end
procedure TClass1.Execute(NewVal:
String);
begin
?;
end
function TClass1.TestFunc(
var Val1: Integer): Boolean;
begin
Result := ?;
end
end.
Als nächstes will ich jetzt die Optimierung von Interfaces und von Klassen, die Interfaces verwenden, umsetzen.
Dann würden entsprechende Deklarationen wie oben im Interface automatisch auf die das Interface verwendenden Klassen durchschlagen.
In der Klasse gäbe es dann Sektionen wie
Delphi-Quellcode:
private // Intf1
fProp: Integer
protected // Intf1
function _get_Prop: Integer;
public // Intf1
property Prop: Integer read _get_Prop;
Spätere Änderungen im Interface würden automatisch auf die Klassen durchschlagen. Das wird (mit einer entsprechenden Anweisung) sogar für Umbenennungen von Properties und Methoden möglich sein, so dass eine InterfaceMember-Namensänderung nacheinander in mehreren Projekten nacheinander automatisiert durchgeführt werden kann (allerdings dann wohl nur bei den Klassenmembern, nicht als wirkliches Refactoring).
Wird das jetzt interessanter?