In diesem Artikel möchte ich ein paar Argumente für ein regelmäßiges Refactoring liefern. Warum lohnt es sich regelmäßig den Code "zu putzen"? Wie kann man mit Refactoring den Codequalität nachhaltig verbessern? Wo kann man nach Hilfe suchen? Am Anfang eine kleine Definition, was man darunter versteht: Unter Refactoring versteht man die Umstrukturierung des Quellcodes, ohne dass dessen ursprüngliche Funktionalität verändert wird. Mit anderen Worten, alles funktioniert hinterher so wie vorher – „nur“ die Qualität des Quellcodes ist deutlich besser. Es gibt einige gute Gründe, die dafürsprechen:

• Lesbarkeit
• Wiederverwendung
• Wartbarkeit

Refactoring umfasst viele kleinere Anpassungen, welche eine spürbare Verbesserung hinsichtlich der Quellcodequalität mit sich bringen:

Keine Dopplungen
An erster Stelle geht es darum, dass man Redundanzen beseitigt. Wie kommt es dazu? Ganz einfach durch Copy & Paste. Man hat versucht Funktionalität von einer auf eine andere Stelle im Quellcode zu übertragen. Dabei handelt es sich jedoch selten um eine 1:1-Kopie. Vielmehr hat man einige kleinere Teilbereiche, zum Beispiel Objekte, Variablen und andere Bezeichner angepasst. Man nimmt sich vielleicht später, vor diese Dopplungen zu beseitigen. Dieses „später“ wird jedoch immer wieder verschoben, daher sind die doppeln Codeblöcke immer noch vorhanden und der Quellcode erfordert einen höheren Wartungsaufwand. Auch wiederholt vorkommende Variablen, Konstanten usw. sollen an allen Stellen durch eine einzige Entsprechung ersetzt werden.

Entferne toten Quellcode
Quellcode, welcher im aktiven Projekt nicht mehr benötigt wird, sollte gelöscht werden, d.h. „Remove dead Code“. Beispielsweise auskommentierter Quellcode oder Methoden, welche nicht mehr genutzt werden. „Raus damit“ – Umfang und Komplexität werden geringer.

Bessere Namen
Wenn man den Namen einer Variablen, einer Klasse, einer Methode usw. liest, dann sollte man wissen, für was dieses Konstrukt da ist. Hier muss man konsequent alle Bezeichner mit passenden Namen versehen. Dabei werden gleich Rechtschreibfehler beseitigt und auch verschiedene Namensgebungen vereinheitlicht. Beispielsweise die Bezeichnung der beiden Klassen: ClockViewModel und ViewModelForNews folgt einer anderen Logik. Besser ist es hier zu vereinheitlichen also ClockViewModel und NewsViewModel. Damit man alle Verwendungen einer Variable, einer Klasse, eines Bezeichners usw. im Quellcode „erwischt“ macht man die Umbenennung nicht manuell, sondern mit Hilfe eines Tools.

Quellcodeanalyse
Einen Schritt weiter geht der Ansatz, den Quellcode inhaltlich zu untersuchen. „Lange“ Methoden, komplexe Algorithmen, tief verschachtelte Schleifen usw. sind nicht nur schwer lesbar, sondern auch typische Fehlerquellen. Diese beispielsweise zu debuggen ist nicht nur mühsam, sondern manchmal kaum möglich. Daher gilt: „Mach es so einfach wie möglich.“ Dazu sollte man versuchen komplizierte Konstrukte so weit zu zerlegen, dass diese verständlich und nachvollziehbar sind. Auch hier kann man mittels Analysetools den Quellcode analysieren und erhält Vorschläge für den „Umbau“.

Kontinuierlich
Einige Verbesserungen kann man manuell bereits während der Codierung umsetzen. Es gilt das Prinzip: Wenn man Änderungen an einer Stelle des Quellcodes vornimmt, dann sollte man diesen sauberer verlassen, als man diesen vorgefunden hat.
Für ein systematisches Refactoring nutzt man am besten Tools. Basisfunktionen, zum Beispiel das Umbenennen von Bezeichnern (Variablen, Methoden, Klassen, …) ist direkt in Visual Studio möglich. Um weitere Funktionen zu nutzen, installiert man besten eine Extension. Folgende Tools sind für C# und XAML gemacht:

• ReSharper: Umfassendes Tool mit einer Vielzahl von Funktionen aus allen Bereichen des Refactorings, zum Beispiel Code-Analyse, Code-Überarbeitung usw.
• Visual Assist: Ebenso eine Extension mit einer breiten Unterstützung für die vielfältigen Aufgaben der Quellcodeüberarbeitung
• XAML-Styler: Spezialtool, welches bei der Überarbeitung des XAML-Codes für die Oberfläche hilft, d.h. wir können den Quellcode für die Beschreibung der Oberfläche bereinigen
• Code Maid: Extension für die Codesortierung und Bereinigung. Das Tool bietet sich besonders an, wenn man eine Quellcodedatei systematisch aufräumen möchte.

Visual Assist
Ich beschreibe jetzt ein paar „Verwendungsmöglichkeiten“ von Visual Assist. Übrigens ist das Tool auf die beiden Sprachen C# und C++ ausgerichtet. Da die meisten .NET-Entwickler mit C# programmieren, gehe ich darauf ein. Das Tool unterstützt bei den folgenden Aufgaben:

• Navigation
• Refactoring
• Code Generation
• Code Assistance
• Code Understanding
• Code Correction
• Code Snippets

Dazu ein paar Beispiele:

Suchen und Finden
Echt hilfreich ist die Funktion Suche und Navigation. In großen Projekten besteht eine Herausforderung darin, dass man sich im Quellcode zu recht findet. Mittels der Funktion Find by Context werden Verweise auf ein Symbol anhand seines Kontext gesucht. Markieren Sie das Symbol im Quelltext und klicken Sie auf die entsprechende Funktion in der Symbolleiste. Das Ergebnis wird Ihnen in einem eigenen Dialogfeld angezeigt. Die Suchfunktion Find References rüstet die Suche nach der Verwendung eines Objektes in älteren Versionen von Visual Studio nach. Beide Suchfunktionen durchsuchen den Quellcode „intelligent“. Ebenso hilfreich ist die Suchfunktion VA View. Wir können hier nach einer Datei in der gesamten Solution suchen. Gibt es schon die Datei ClockViewModel oder haben wir diese noch nicht angelegt oder liegt sie nur in einem anderen Ordner?

Umbenennen
Diese Funktion erweitert die Basisfunktion von Visual Studio zum Umbenennen und bietet mehr Komfort. Man sieht beispielsweise, eine Vorschau der geplanten Änderungen.

Quellcode erstellen
Quellcode-Snippets werden genutzt, um das Schreiben regelmäßiger Statements zu beschleunigen. Auch dazu gibt es in Visual Studio bereits eine Basisfunktion. In Visual Assist werden diese erweitert wichtig(!) wir können eigene Vorlagen definieren. Auf diese Weise entsteht eine individuelle Schnellschreibhilfe. Das funktioniert auch für XAML-Code, beispielsweise ein <Grid /> kann mit einer typischen Struktur dann mit wenigen Buchstaben geschrieben werden. Ein konkretes Beispiel: Nehmen wir an, wir wollen öfters ein Grid in einer bestimmten Struktur definieren, zum Beispiel für Kopfzeile, Navigations-Bereich, Content-Bereich und Footer-Bereich. Dazu müssten wir in XAML schreiben:

<Grid>
    <Grid.ColumnDefinitions>
        <ColumnDefinition Width="300"/>
        <ColumnDefinition />
    </Grid.ColumnDefinitions>
    <Grid.RowDefinitions>
        <RowDefinition Height="300"/>
        <RowDefinition/>
        <RowDefinition Height="200"/>
    </Grid.RowDefinitions>
</Grid>

Wir definieren dazu eine Vorlage, zum Beispiel MyGrid. Wenn wir dieses Schnipsel im XAML-Code schreiben, erscheint der gezeigte Quellcode von allein. Das geht auch mit deutlich umfangreicheren Strukturen. Ich verwende es, um das Layout einer Seite mit wenigen Klicks zu erstellen.

XAML-Styler
Dieses Tool verbessert den XAML-Code. Wenn Sie das User Interface in XAML gestalten, dann definieren Sie die Eigenschaften zu Objekten nacheinander. Dabei achten wir i.d.R. nicht auf eine sinnvolle Reihenfolge oder auf eine schöne Struktur des XAML-Quellcodes. Mit einem Klick – direkt im XAML-Code – wird dieser sortiert und formatiert. Alle Zeilen haben eine vordefinierte Länge, der Quellcode wird sinnvoll und leserlich auf mehrere Zeilen aufgeteilt und die Eigenschaften werden alphabetisch sortiert.

Was denkt Ihr? Wie wichtig ist Refactoring und Clean Code für Euch in der Praxis? Nutzt Ihr Tools? Was sind die wichtigsten Funktionen dieser Tools?

Hallo vkry

Die Gelegenheit möchte in nutzen und einen besonders wichtigen Punkt hervorheben und ergänzen:

Zitat von vkry

Kontinuierlich Einige Verbesserungen kann man manuell bereits während der Codierung umsetzen. Es gilt das Prinzip: Wenn man Änderungen an einer Stelle des Quellcodes vornimmt, dann sollte man diesen sauberer verlassen, als man diesen vorgefunden hat.

Bei der täglichen Arbeit steht der Entwickler für gewöhnlich unter einem gewissen Zeitdruck. Für explizite Refactorings bekommt er nicht immer Zeit. Deswegen ist es wichtig, kontinuierlich sauberen Code zu entwickeln. Dafür muss klar definiert sein, wie der Code strukturiert sein soll und die Architektur aussieht.

Im Entwickler-Team sollten also unter anderem folgende Punkte geklärt sein:

• UnitTests:
  - wo kommen die hin
  - in welchen Fällen kann darauf verzichtet werden
  - wird TDD gemacht.
  
• Schichten:
  - welche gibt es: Domain, DB, UI, ..
  - welche Schicht, hat wo Zugriff
  
• technische oder fachliche Aufteilung von Code
• wann und wie wird die Architektur angepasst

Die Liste ist natürlich nicht vollständig. Meiner Erfahrung nach, ist das oft nicht ausreichend geklärt. Meiner Meinung nach ist es aber essentiell, für sauberen Code.

Gruss
Alf

Das Prinzip wird übrigens auch Pfadfinder-Prinzip genannt.

Arbeitest du für Visual Assist?

Hallo,
danke für Deinen Beitrag. Das hast mit den von Dir genannten Maßnahmen, dass viel unschöner Code erst gar nicht entsteht. Mit den o.g. Technologien und Tools soll es um eine Bereinigung gehen, also gewissermaßen um eine Verbesserung des bisherigen Codes.