Unsere Datenschutzrichtlinie wird in Kürze aktualisiert. Bitte sehen Sie sich die Vorschau an.

Visual Studio 2013 Grundkurs

Quellcode umstrukturieren

Testen Sie unsere 2016 Kurse

10 Tage kostenlos!

Jetzt testen Alle Abonnements anzeigen
Visual Studio 2013 beinhaltet zahlreiche Hilfsmittel für das Umstrukturieren von bestehendem Quellcode. Diese dienen dazu, hierbei Fehler zu vermeiden sowie die Arbeitsdauer zu reduzieren.
11:06

Transkript

Zur Tätigkeit eines Entwicklers in Visual Studio zählen sehr, sehr viele verschiedene Arten von Arbeiten. Eine der Arbeiten, die bei Entwicklern sehr beliebt sind, aber auch sehr, sehr riskant, ist das so genannte Refactoring. Jeder von Ihnen, der Visual Studio wie ich in der deutschen Version installiert hat, dem sei ge-glückwünscht: "Bitte deinstallieren Sie es sofort oder holen Sie sich ein Language Pack", denn die Übersetzungen in Visual Studio sind einfach absolute Katastrophe. Und wenn Sie irgendwann mal Hilfe zu Visual Studio benötigen, werden Sie mit Ihren deutschen Begriffen nicht weit kommen. Der englische Begriff Refactoring, den es gibt, heißt, dass man die Struktur des Codes verändert, aber das Verhalten nicht verändert. Das heißt, wenn ich irgendwo erkenne, dass ich Redundanzen im Code habe oder etwas vielleicht ein bisschen eleganter programmieren könnte oder etwas kommentieren möchte, ändere ich die Struktur, aber das Verhalten ist nach dieser Tätigkeit genauso wie vorher auch. Diese Tätigkeit Refactoring wurde vom Visual-Studio-Team einfach mal plump übersetzt mit 'Umgestalten'. Also, werden wir mal ein bisschen rum 'umgestalten' hier in diesem Video und schauen uns mal dazu die Unterstützung in Visual Studio an. Refactoring, wir einigen uns auf Refactoring. Es gibt viele verschiedene Refactoring-Möglichkeiten auf dem Markt, und ein Paradebeispiel ist das Tool ReSharper. Und das bietet sehr viele verschiedene Refactoring-Techniken an. Visual Studio ist ein bisschen eingeschränkter, wir haben 4 oder 5 verschiedene Refactoring-Techniken, und jeder, der da ein bisschen mehr braucht, der vielleicht größere Refactorings innerhalb eines Projektes macht, denken Sie einfach mal drüber nach, dass Sie ein entsprechendes Tool nachkaufen, wie gesagt, da sind die Möglichkeiten vom Visual Studio sehr begrenzt, wahrscheinlich auch deshalb, weil man natürlich möchte, dass die entsprechenden Fremdhersteller oder Dritthersteller auch ihre Tools verkaufen und den da keine Konkurrenz bieten möchten. Schauen wir uns das Ganze einfach mal an. Wir gucken mal, was Visual Studio so alles bietet. Wenn wir jetzt hier sind, können wir einen Rechtsklick machen und direkt der erste Punkt oben "Umgestalten" - ich liebe dieses Wort - dort können wir verschiedene Refactorings machen. Eine Möglichkeit wäre, zum Beispiel "Umbennenen", und an dieser Stelle könnte ich jetzt die Methodennamen hier umbennenen. Was ich niemals machen soll in Visual Studio, das hier umbenennen, dann kompilieren und dann alle Aufrufstellen umbenennen. dafür haben wir Entwicklungsumgebungen, die uns helfen, das muss man nicht von Hand machen. Wir nennen das jetzt mal um in "FooBar", und ich kann jetzt hier unten noch sagen, okay, was soll denn noch gleichzeitig gemacht sein. Es soll uns erst eine Vorschau oder Verweisänderung angezeigt werden. Das sehen wir gleich im nächsten Schritt. Dann könnte ich sagen: Gucke auch, ob du irgendwo in Kommentaren dieses "Foo" erkennst, und dann benenne es bitte mit um. Und es soll auch in Zeichenfolgen also in Strings suchen, und Überladungen sollen auch umbenannt werden, das heißt, wenn ich jetzt mehrere Überladungen der Methode "Foo" hätte, würden diese ebenfalls umbenannt. Wir gehen jetzt hier mal auf OK, nachdem wir das "FooBar" geändert haben, und dann wird uns hier angezeigt, welche Änderungen dafür überall durchgeführt werden. Also, wir ändern das jetzt hier in "FooBar", und in "Class2" wird diese Methode "Foo" aufgerufen, das heißt, hier würde der Aufruf auch in "FooBar" umgeändert, das heißt, wenn ich das Ganze mit Refactoring-Unterstützung mache, dann kann ich das Ganze an einer Stelle umbennenen. Und die IDE kümmert sich darum, dass alle anderen Aufrufstellen ebenfalls umbenannt werden, Wir machen das mal, sehen hier, das ist jetzt auf "FooBar" umbenannt, und hier unten auch. Das Ganze funktioniert für Methoden, das funktioniert aber auch für alle anderen Elemente, das heißt, ich nenne jetzt hier mal die lokale Variable um in "class2Foo", und schaue mir nochmal hier die Vorschau der Änderung an und übernehme das Ganze und sehe dann hier, wurde es ebenfalls umbenannt. Das ist ganz nett das so zu machen, aber wenn Sie kein Freund der Maus sind mit "Umgestalten", dann macht man das normalerweise so. Ich gehe einfach hier rein und ändere diesen Variablenamen, und Sie sehen unten schon diesen kleinen Smarttag, der sich unterhalb meines Cursor befindet, dieses kleine rote Rechteck, und das deutet immer an, dass es entsprechende Hilfe an der Stelle gibt vom Visual Studio. Ich könnte jetzt mit dem Maus dort drüber gehen, und dann in diesem Smarttag sagen: "Okay, ich möchte 'class2Foo' umbennenen in 'class2FooBar', ohne die Vorschau, die wir gerade gesehen haben, und hiermit würde ich dann das Ganze machen mit Vorschau. Wir machen das mal mit Escape und das hier auch, und normalerweise, wenn Sie jetzt hier im Quellcode irgend etwas umbennenen, dann wollen Sie nicht die Maus zu Hilfe nehmen, das heißt, normal schreibt man einfach hier, nachdem er die Veränderung durchgeführt hat, drückt man Strg+. , das ist der Shortcut, um diesen Smarttag aufzurufen, drückt einmal noch Enter, Vorschau braucht man eher selten, und dann ist das Ganze im Quellcode umbenannt. Das heißt, die Refactoring-Technik ist toll, jeweils Menü auszuwählen, weiß ich nicht, irgendwie nicht so wirklich elegant, und stört einen noch ein bisschen in seinem Arbeitsfluss. Schauen uns mal die nächsten Refactoring-Techniken an. Wir gucken mal hier, "Umgestalten", unten haben wir zum Beispiel "Methode extrahieren". Wenn ich jetzt hier merke, dass ich irgendwie eine gewisse Regelmäßigkeit in meinem Code habe, das heißt, ich habe hier ganz viele Aufrufe von "Foo" und hier auch, dann sollte man sich im Quellcode nicht wiederholen, "don't repeat yourself". Deswegen bietet es sich an, das in einer separate Methode auszulagern, und diese Methode hier und dort entsprechend aufzurufen. Ich könnte von Hand eine Methode schreiben, die all diese Dinge macht, aber ich könnte auch einfach sagen: Rechtsklick Umgestalten Dann schlägt er mir hier unten die Methodensignatur vor. Wenn ich irgendwelche Variablen in diesem Block verwenden würde, die außerhalb dieser Markierung jetzt deklariert wurden, würde er auch automatisch Parameter und Rückgabewerte bestimmen, er würde auch bestimmen, wo diese statische Methode sein soll. Das brauchen wir alles nicht. Wir nennen diese Methode jetzt mal "Blubb", klicken auf OK, und dann sehen wir oben, das Ganze hier wurde jetzt durch den Methodenaufruf "Blubb" ersetzt, und in unserer Methode "Blubb", die hat er nach hier unten geschoben, hier ist sie, die hat er "private void" gemacht. Dort sind jetzt die "Foo"-Aufrufe, und an dieser Stelle könnte ich jetzt auch ebenfalls den Aufruf "Blubb" verwenden, und dann hätte ich quasi die Redundanz innerhalb meines Codes entfernt. Okay, und was gibt es noch? Wir schauen weiter. Wir haben hier den Bereich "Feld kapseln". Was heißt "Feld kapseln"? Wenn ich hier ein Feld habe, dann sollte man niemals das machen, was ich jetzt mache, nämlich "public int age", Klassen enthalten Daten, Daten sollen dann nach außen gekapselt werden, das heißt, ihr Zugriff soll von draußen beschränkt werden, Felder sollten also immer "private" und nach außen gekapselt sein. Also machen wir das Ganze mal "private", und Kapseln tut man solche Felder normalerweise in C-Sharp mit Properties, in VB ist das ähnlich, und jetzt müsste ich ein kapselndes Property da oben schreiben. Ich kann aber auch einfach sagen: "Okay, ich habe mein Feld, bitte kapsel mir das mal." Und dann würde ich dieses Property außenrum automatisch generieren. Ich sage jetzt hier, wie soll mein Property heißen. Ich brauche keine Vorschau, Kommentare brauche auch nicht suchen, Verweise soll er bitte auch alle aktualisieren, das heißt, alle, die vorher mit dem Feld "age" gearbeitet haben, was ja public war, sollen jetzt in Zukunft mit dem Property "Age", also groß geschrieben, arbeiten. Und dann klicke ich auf OK, und jetzt hat er mir hier entsprechend den Code generiert, um das Feld im Hintergrund zu kapseln, wären jetzt von außen Verweise gewesen auf "_age", hätte er die auch umgebogen auf das normale "Age". Okay, was haben wir noch? Wir haben die "Schnittstelle extrahieren". Wenn wir so eine Klasse hier haben, sollte man niemals gegen die Implementierung arbeiten, sondern immer gegen Schnittstellen. So, wenn ich das aber jetzt hier erkenne, dass ich diese "class2" in der anderen Klasse verwenden möchte und dazu eine Schnittstelle brauche. Es ist natürlich mühselig zu sagen, okay, ich brauche jetzt die Methode "FooBar", "Foo2" und "_age", das heißt, ich nehme diese Methodensignaturen, lege mir neues Interface an und füge die Methodensignaturen da ein. Zwischendrin muss ich hin und her springen, weil ich nicht mehr genau weiß, wie die Parameter hießen und so weiter. Auch das ist natürlich ein Task, der schreit geradezu danach automatisiert zu werden, das heißt, ich gehe hin, sage "Schnittstelle extrahieren", dann schlägt er mir schon vor, "iClass2", anhand der Microsoft-Konvention für die Benennung von Schnittstellen. Das nehmen wir auch so, Name der neuen Datei passt auch, und ich möchte gerne das Age-Property in der Schnittstelle haben, "Bar" und "FooBar", dann gehe ich auf OK, und wird mir hier das Interface entsprechend erstellt, genau mit diesen Signaturen und hier an der Stelle wieder gleichzeitig das Interface in meiner Klasse implementiert. Okay, was haben wir noch? Wir haben die Möglichkeit, Parameter zu löschen. Stellen Sie sich mal vor, ich stelle in der Methode fest, okay, Parameter "a" brauche ich überhaupt gar nicht mehr. Ich könnte den jetzt von Hand löschen, könnte dann kompilieren, würde dann sehen, an 20 Aufrufstellen, wo ich den Parameter übergeben habe, muss ich den jetzt von Hand entfernen. Kann man machen, man kann aber Visual Studio einfach diese Dinge überlassen. Wir sagen jetzt hier "Parameter entfernen". Ich entferne an der Stelle einfach mal "a", und sage "Vorschau der Verweisänderungen", ganz wichtig. Auch ganz wichtig die Information "Das Entfernen eines Parameters dessen Aufrufsite ein Argument übergibt, das den Zustand des Programms ändert, kann zu unerwartetem Laufzeitverhalten führen". Wenn irgendjemand weiß, was mit dieser Fehlermeldung gemeint ist, bitte, ich würde mich da über eine Benachrichtigung freuen. Wahrscheinlich wieder eine der Opfer der katastrophalen Übersetzungen in Visual Studio. Wir waren an etwas anderem interessiert, wie entfernen also hier den Parameter. Wir sehen hier die ge-updated-te Signatur und bestätigen das Ganze mit OK. Und dann sagt er mir: "überschreibt/implementiert andere Member." Das kommt dadurch, dass das Interface eben extrahiert wurde. "Der Vorgang hat Updateweitergaben zur Folge", das heißt, der wird jetzt nicht nur den Parameter aus meiner Methode rausziehen, sondern gleichzeitig oben aus dem Interface. All das überprüft Visual Studio für uns. Hätte ich das gerade von Hand gemacht, muss ich Ihnen ehrlich sagen, hätte ich genau das vergessen, und hätte meine Anwendung nicht komplilieren können. Visual Studio prüft das natürlich und erkennt das. Wir möchten das Ganze fortsetzen. Hier sehen wir die Änderungen, die gemacht werden. Einmal hier oben im Interface sagt er uns hier: "Hier werden wir jetzt 'FooBar' anpassen, und in 'Class2' werden wir unten den Aufruf von 'FooBar', - man sieht, das jetzt nicht unbedingt, der wird gerade mit 5 aufgerufen - da entfernen wir diesen Parameter einfach. Er wird in der Methode nicht mehr gebraucht, das heißt, die Aufrufstelle dort kann er auch einfach entfernen. Und dann klicke ich auf ÜBERNEHMEN. Der Parameter ist hier oben entfernt, hier unten in der Aufrufstelle auch. Und wenn ich in das Interface gehe, es ist ebenfalls entfernt. So, jetzt haben wir noch eine andere Methode, und in dieser anderen Methode haben wir ein Parameter "int b", "int c" und "int a". Und irgendwann kommt man zu der grandiosen Idee, irgendwie ist die Reihenfolge suboptimal, die wir haben - ich kommentiere den Aufruf aus. Und wir möchten gerne die Reihenfolge ändern. Ich kommentiere das nicht aus, ich füge hier mal "1, 2, 3" hinzu, dann sehen wir das gleich auch noch. Wir wollen also die Reihenfolge ändern, damit das Ganze besser lesbar ist und logischer für den jeweiligen Entwickler. Dann können wir jetzt hier einen Rechtsklick machen Umgestalten und sagen, Parameter neu anordnen. Und jetzt haben wir die Parameterliste und sehen eine Vorschau, und ich sage jetzt einfach mal okay, "a" soll an erster Stelle stehen, dann "b", dann "c". Jetzt markiere ich hier wieder die "Vorschau der Verweisänderungen", lasse das Ganze vom Visual Studio im Hintergrund durchführen, und jetzt sehe ich hier, okay, das wird hier geändert, klar. Was wird noch geändert? Diese Stelle wird geändert, und natürlich das wird auch geändert. Wir sehen schon, eben haben wir die Reihenfolge. Hier sieht man es doch, 1, 2, 3 angewählt, und der tauscht auch automatisch die Parameter in den jeweiligen Aufruflisten. Also, um all solche Dinge kümmert sich Visual Studio, an der Stelle müssen wir nichts mehr machen, und übernehmen, haben wir das Ganze dann fertig. Wir haben jetzt gerade gesehen, das waren die Umgestaltungsvarianten, die uns Visual Studio bietet, also "Umbennenen", "Methode extrahieren", "Feld kapseln", "Schnittstelle extrahieren", "Parameter entfernen" und "Neu anordnen". Ich denke, wenn Sie es vorher noch nie gemacht haben, haben Sie gerade so eine leichte Idee davon bekommen, wie mächtig solche Refactoring-Tools sind, wie viel Arbeit sie ihnen abnehmen können, und wieviel Strukturänderungen Sie im Code machen können, oder bei Unterstützung von so einem Tool bekommen, damit Sie nichts kaputt machen. Gerade haben wir das im Beispiel wunderschön gesehen, ich hätte die Überladung beziehungsweise die Implementierung im Interface vergessen und hätte meine Anwendung nicht mehr kompilieren können. Wenn Sie größere Refactorings machen, nehmen Sie sich bitte die paar 100 Euro und kaufen Sie Tools, wie zum Beispiel ReSharper. ReSharper kostet, glaube ich, 230 Euro in der Einzelplatzlizenz. So was lohnt sich auf jeden Fall, wenn Sie große Refactorings machen, auf solche Tool-Unterstützung zurückzugreifen. Visual Studio, haben wir gesehen, implementiert an der Stelle die rudimäntersten Features, und Sie haben in diesem Videotraining gesehen, wie Sie das Ganze einsetzen.

Derzeit sind keine Feedbacks vorhanden...
 

Dieser Online-Kurs ist als Download und als Streaming-Video verfügbar. Die gute Nachricht: Sie müssen sich nicht entscheiden - sobald Sie das Training erwerben, erhalten Sie Zugang zu beiden Optionen!

Der Download ermöglicht Ihnen die Offline-Nutzung des Trainings und bietet die Vorteile einer benutzerfreundlichen Abspielumgebung. Wenn Sie an verschiedenen Computern arbeiten, oder nicht den ganzen Kurs auf einmal herunterladen möchten, loggen Sie sich auf dieser Seite ein, um alle Videos des Trainings als Streaming-Video anzusehen.

Wir hoffen, dass Sie viel Freude und Erfolg mit diesem Video-Training haben werden. Falls Sie irgendwelche Fragen haben, zögern Sie nicht uns zu kontaktieren!