Vorher/Nachher ist schwierig, da man die gesamte
Unit sehen muss.
Die Codevervollständigung ist m.E. umfangreicher und komfortabler als die von Delphi.
Man muss weniger schreiben und es wird mehr vervollständigt.
Auch Member benutzter Interfaces werden automatisch in Klassen übernommen.
Mal ein Beispiel einer einfachen Klasse:
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 wn;
prop PropBoolean: Boolean rn vi pv;
prop PropByte: Byte sc;
prop PropWord: Word rf wn;
prop PropString2:
string pc 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.
Zur Interface-Unterstützung wäre noch mehr zu sagen. Da verweise ich mal auf den vorherigen Thread:
https://www.delphipraxis.net/193733-...stuetzung.html bzw. auf das Video.
Weiterhin wird der Code im Implementationsteil so sortiert, wie er in den Klassendeklarationen angeordnet ist. Die Reihenfolge ist also oben wie unten immer identisch. (Ausnahme sind standardmäßig contructor und destructor, die im Implementationsteil immer als erstes kommen.)
Bei Umsortierungen und Formatierungen werden gesetzte Haltepunkte und Bookmarks im Code immer beibehalten.
Die Codeformatierung habe ich noch nicht umgesetzt.
Ich habe aber z.B. vor, verkettete Anweisungen zu berücksichtigen (wenn die neue Zeile mit einem Punkt beginnt und Methoden eines Objektes oder Interfaces aufrufen) und z.B. read und write von aufeinanderfolgenden Properties untereinander auszurichten.
Um das richtig einzuordnen, ist sicherlich sinnvoll, mal das Video anzuschauen.
Aus meiner Sicht löst das eigentlich genau das, was mir an Delphi schon lange auf die Nerven ging - abgesehen davon, dass es noch nicht ganz fertig ist. Daher bin ich überrascht, dass es da so wenig Resonanz gab bisher.
Ich dachte, es lag vielleicht an dem bisherigen Schwerpunkt auf Interfaces, so dass es die Leute vielleicht übersehen haben, die (noch) nicht mit Interfaces arbeiten. Daher der neue Thread.
PS: Einen Metadateneditor habe ich nicht vor. Da bringen aber aktuelle Delphi IDEs m.E. ja auch schon etwas mit.