Refactorings in Delphi?

[PeterPanino]

Hallo! Ich habe mir gerade die Seite http://refactoring.com/catalog/index.html angesehen und frage mich, welche mehr oder weniger intelligenten Refactorings es für die Delphi IDE in externen Zusatz-Tools gibt (denn die in der Delphi IDE vorhandenen Refactorings sind wohl nicht gerade das Gelbe vom Ei, oder?). Ein Beispiel ist mir dabei eingefallen, für das ich bis jetzt kein verfügbares Refactoring in Delphi gefunden habe, nämlich die automatisierte Umwandlung einer Berechnung in eine Funktion, und optional zusätzlich die Auslagerung dieser Funktion in eine vorhandene oder neue Klasse, und optional zusätzlich die Auslagerung dieser Klasse in eine vorhandene oder neue Unit:

Wir haben folgenden Code:

Delphi-Quellcode:

var
  a, b, c: Integer;
//...
  a := 2;
  b := 3;
  c := a + b;

Wir wählen die Berechnung a + b mit der Maus aus, drücken auf einen Knopf und das Refactoring macht daraus:

Delphi-Quellcode:

function MyUnit.MyClass.MySum(const a, b: Integer): Integer;
begin
  Result := a + b;
end;

D.h. das Refactoring hat aus der Berechnung a + b die Funktion MySum sowie ggf. eine neue Klasse und ggf. in einer neuen Unit erzeugt, natürlich aus unseren Vorgaben in einem Refactoring-Dialog.

Gibt es dieses Refactoring "FunktionAusBerechnung" für Delphi? Das ist natürlich nur ein einfaches Beispiel, aber bei größeren Berechnungen könnte man könnte sich dadurch eine Menge Tipparbeit ersparen, vor allem wenn die Berechnung "verschachtelt" ist.

[Namenloser]

Zitat von PeterPanino:

Gibt es dieses Refactoring "FunktionAusBerechnung" für Delphi? Das ist natürlich nur ein einfaches Beispiel, aber bei größeren Berechnungen könnte man könnte sich dadurch eine Menge Tipparbeit ersparen, vor allem wenn die Berechnung "verschachtelt" ist.

Gab es zumindest in Delphi 2006 unter dem Namen „Methode extrahieren“. Fand ich aber in der Praxis nicht so nützlich wie es sich zunächst anhört...

[Furtbichler]

Refactorings sind sehr nützlich, wenn man weiß, wozu sie gut sind.

Die Refactoring-Tools sind sehr nützlich, wenn sie schneller gehen, als das manuelle Umschichten.

Es gibt imho keine externen Refactoring-Tools für Delphi, weil es kaum einen Markt dafür gibt. Und vielleicht auch, weil die OTA (IDE-API) nicht dafür geeignet ist, aber letzteres ist nur eine Vermutung.

[Bernhard Geyer]

http://www.modelmakertools.com/ bietet laut Beschreibung auch Refactoring-Features

[dummzeuch]

Zitat von PeterPanino:

frage mich, welche mehr oder weniger intelligenten Refactorings es für die Delphi IDE in externen Zusatz-Tools gibt

Castalia hat einige Refactorings. Ich kenne es allerdings nur aus der Beschreibung.

Die eingebauten in Delphi finde ich durchaus nuetzlich, zumindest die zum Umbenennen von Variablen und Methoden sowie Extract Method und Search Unit verwende ich regelmaessig.

[jaenicke]

Extract Method würde ich auch gerne mehr nutzen, aber leider stolpert das immer wieder über die eigenen Füße und funktioniert nicht...
Das liegt wohl vor allem an neueren Features in Object Pascal, die ich eben sehr gerne nutze (nested types, generics, ...). Denn in Units, die nur Code nutzen, der auch vor Delphi 2009 kompilierbar wäre, funktioniert es in der Regel.

Prinzipiell finde ich die eingebauten Refactorings schon für die meisten Fälle ausreichend, wenn sie denn funktionieren. Und die CnWizards haben auch noch ein paar Automatiken für die Codetransformation dabei (Zuweisung links rechts austauschen usw.), beides zusammen reicht mir gut.

[Namenloser]

Bei mir geht es erfahrungsgemäß schneller und zuverlässiger, einfach den Code zu copy-pasten und dann ggf. die Variablen mit dem Sync-Editor oder dem Umbenenn-Refactoring-Tool (z.B. in "Result") umzubenennen, wenn ich Code in eine Funktion auslagern will.

[PeterPanino]

Ausgehend von folgendem Code wurde testweise die Code-Auswahl c := a + b mit Delphis Refactoring-Methode bearbeitet:

Delphi-Quellcode:

procedure TForm1.FormCreate(Sender: TObject);
var
  a, b, c: Integer;
begin
  a := 2;
  b := 3;
  c := a + b;
end;

Das in Delphi XE2 eingebaute "Methode extrahieren" macht daraus:

Delphi-Quellcode:

procedure TForm1.FormCreate(Sender: TObject);
var
  a, b: Integer;
begin
  a := 2;
  b := 3;
  ExtractedMethod(a, b);
end;

procedure TForm1.ExtractedMethod(a: Integer; b: Integer);
var
  c: Integer;
begin
  c := a + b;
end;

D.h. es wird einfach und simpel die Anweisung c := a + b in eine Prozedur ausgelagert. Eine Parameter-Bearbeitung ist im Refactoring-Dialog nicht möglich. Die Rückgabe eines Ergebnisses ist nicht vorgesehen, da der Code selbst eine solche ja nicht benötigt. Streng nach Compiler-Logik eben.

Die erzeugte Prozedur sieht jedoch anders aus, wenn die Variable c NACH der Codeauswahl c := a + b noch verwendet wird:

Delphi-Quellcode:

procedure TForm1.FormCreate(Sender: TObject);
var
  a, b, c, d: Integer;
begin
  a := 2;
  b := 3;
  c := a + b;
  d := a + b + c;
end;

In diesem Fall erzeugt das Delphi-Refactoring diesen Code:

Delphi-Quellcode:

procedure TForm1.FormCreate(Sender: TObject);
var
  a, b, c, d: Integer;
begin
  a := 2;
  b := 3;
  ExtractedMethod(a, b, c);
  d := a + b + c;
end;

procedure TForm1.ExtractedMethod(a: Integer; b: Integer; var c: Integer);
begin
  c := a + b;
end;

Mit dem var-Parameter berücksichtigt das Delphi-Refactoring intelligenterweise, dass die Variable c später noch verwendet wird.

(ModelMaker Code Explorer setzt hier unnötigerweise 3 var-Parameter, obwohl an die Variablen a und b innerhalb der Prozedur ja gar nichts zugewiesen wird):

Delphi-Quellcode:

procedure TForm1.FormCreate(Sender: TObject);
var
  a, b, c, d: Integer;
begin
  a := 2;
  b := 3;
  (*TODO: extracted code
  c := a + b;
  *)
  NewMethod(a, b, c);
  d := a + b + c;
end;

procedure TForm1.NewMethod(var a, b, c: Integer);
begin
  c := a + b;
end;

Das bedeutet also: Wenn man die Rückgabe eines Ergebnisses benötigt, kann man dies mit einem einfachen Trick erreichen. Man verwendet einfach die gewünschte Rückgabe-Variable in einer Dummy-Anweisung NACH der Code-Auswahl:

Delphi-Quellcode:

procedure TForm1.FormCreate(Sender: TObject);
var
  a, b, c: Integer;
begin
  a := 2;
  b := 3;
  c := a + b;
  c := c; // Dummy-Anweisung
end;

Das Delphi-Refactoring macht daraus:

Delphi-Quellcode:

procedure TForm1.FormCreate(Sender: TObject);
var
  a, b, c: Integer;
begin
  a := 2;
  b := 3;
  ExtractedMethod(a, c, b);
  c := c; // Dummy-Anweisung
end;

procedure TForm1.ExtractedMethod(a: Integer; var c: Integer; b: Integer);
begin
  c := a + b;
end;

[jaenicke]

Zitat von PeterPanino:

Das bedeutet also: Wenn man die Rückgabe eines Ergebnisses benötigt, kann man dies mit einem einfachen Trick erreichen. Man verwendet einfach die gewünschte Rückgabe-Variable in einer Dummy-Anweisung NACH der Code-Auswahl:

Naja, entweder braucht man sie, dann braucht man auch keinen Dummy, oder man braucht sie nicht, dann hat man das Problem gar nicht.

[PeterPanino]

Zitat von jaenicke:

Naja, entweder braucht man sie, dann braucht man auch keinen Dummy, oder man braucht sie nicht, dann hat man das Problem gar nicht.

Naja, meine Überlegung war, dass man die extrahierte Methode sowie den Aufruf dann an anderer Stelle verwenden würde.

Aber ich habe mir jetzt ModelMaker Code Explorer näher angesehen: Das ist ein phantastisches Werkzeug, das WEIT über die Delphi-Refactorings hinausgeht! Ich werde es mir sicher zulegen.