Thema: UnitOptimizer

Einzelnen Beitrag anzeigen

Benutzerbild von stahli
stahli
Online

Registriert seit: 26. Nov 2003
Ort: Halle/Saale
4.243 Beiträge
 
Delphi 10.4 Sydney
 
#3

AW: UnitOptimizer

  Alt 25. Mai 2018, 12:46
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.
Stahli
http://www.StahliSoft.de
---
"Jetzt muss ich seh´n, dass ich kein Denkfehler mach...!?" Dittsche (2004)

Geändert von stahli (25. Mai 2018 um 14:38 Uhr)
  Mit Zitat antworten Zitat