<\/p>\n
André Minhorst, Duisburg<\/b><\/p>\n
Refactoring ist eines der Schlagwörter des Extreme Programming und untrennbar mit dem Unit-Testing und der testgetriebenen Entwicklung verbunden. Durch Refactoring verbessern Sie die Struktur und Lesbarkeit des Codes einer Anwendung unter Beibehaltung der Funktionalität und erleichtern damit änderungen und Erweiterungen der Funktion der Anwendung.<\/b><\/p>\n
Refactoring ist eine Tätigkeit, die Chefs und Managern vermutlich nicht gefallen wird, weil sie erstmal keinen Gewinn bringt und ein Projekt nicht sichtbar vorantreibt – immerhin bezeichnet man Refactoring ausdrücklich als Vorgehensweise, die sich nicht auf die Funktion einer Anwendung auswirkt. Genau genommen kann man es als Aufräumen bezeichnen – man sortiert hier ein wenig aus, stellt dort ein wenig um und wirft vielleicht sogar ein paar Dinge weg. Die Analogie zum wirklichen Leben hinkt nur insofern, als dass Sie nicht Platz für etwas Neues, sondern die Voraussetzungen für dessen einfache Integration schaffen.<\/p>\n
Refactoring optimiert noch nicht einmal die Performance – im Gegenteil: Viele Refactoring-Maßnahmen führen zu einer Verlangsamung der betroffenen Teile um wenige Prozentpunkte. <\/p>\n
Aber – und das ist das Wichtigste – Sie bereiten den Quellcode durch Refactoring auf die Anwendung von Performance-Optimierungen vor, weil Sie diesen wesentlich besser lesbar machen und damit das Erkennen und Beseitigen von Performance-Bremsen erleichtern.<\/p>\n
Die wichtigsten Ziele des Refactoring sind folgende:<\/p>\n
Refactoring besteht aus einem oder mehreren Refactoring-Maßnahmen – je nachdem, wie gute Vorarbeit man geleistet hat und wie viel Verbesserungspozential der Code noch bietet. Mit diesen Maßnahmen können Sie den Code Stück für Stück besser strukturieren und lesbarer machen.<\/p>\n
Refactoring ist in Zusammenhang mit objektorientierten Programmiersprachen entstanden. Da VBA nicht alle Aspekte der Objektorientiertheit beinhaltet, lassen sich längst nicht alle in Literatur und Internet beschriebenen Refactoring-Maßnahmen auf VBA-Code anwenden.<\/p>\n
In den nachfolgenden Kapiteln lernen Sie ausschließlich solche Refactorings kennen, die für mit VBA entwickelte Anwendungen geeignet sind. Zu jedem Refactoring finden Sie ein Beispiel und – soweit sinnvoll – eine Abbildung zur Veranschaulichung der Vorgehensweise.<\/p>\n
In manchen Fällen stellen wir auch Refactorings vor, die in der Literatur nicht beschrieben sind – beispielsweise die Umwandlung einer Funktion mit mehreren Rückgabeparametern in eine Klasse mit entsprechenden Eigenschaften.<\/p>\n
Unbewusst werden Sie vielleicht schon das eine oder andere Refactoring an Ihrem Code vorgenommen haben, weil es Ihnen einfach sinnvoll erschien. Ein gutes Beispiel dafür ist das Extrahieren einer Methode, bei dem man eine oder mehrere Zeilen Code, die an mehreren Stellen in einer oder mehreren Prozeduren vorkommen, in eine neue Prozedur ausgliedert.<\/p>\n
Im Internet gibt es eine Menge Informationen zum Thema Refactoring, meist in Verbindung mit objektorientierten Sprachen wie Java oder VB.NET. Wenn Sie im Internet nach zusätzlichem Informationsmaterial suchen, sollten Sie als Suchbegriff zusätzlich noch den Namen Martin Fowler eingeben. Die in diesem Beitrag und den geplanten Fortsetzungen vorgestellten Refactoring-Maßnahmen lehnen sich an die auf der folgenden Internetseite aufgeführten Informationen an und sind den speziellen Gegebenheiten unter Microsoft Access beziehungsweise VBA angepasst: http:\/\/www.refactoring.com\/catalog\/index.html <\/p>\n
Refactoring sollte unter zwei Voraussetzungen erfolgen:<\/p>\n
Die erste Voraussetzung ist nirgends festgelegt, weil Refactoring ohnehin aus der objektorientierten Programmierung stammt und dort zusammenhängende Methoden und Eigenschaften in Klassenmodulen untergebracht sind. Standardmodule wie in VBA werden dort nicht verwendet. Viele Refactoring-Maßnahmen beziehen sich ausdrücklich auf Klassen. Es gibt zwar einige, die auf Eigenschafts- oder Methodenebene anwendbar und damit auch für VBA-Prozeduren in Standardmodulen geeignet sind, aber die Kapselung von Funktionalität in Klassen kommt dem Refactoring-Prozess in den meisten Fällen entgegen.<\/p>\n
Die zweite Voraussetzung ist die Absicherung der vom Refactoring betroffenen Funktionalität. Und hier kommen die weiter oben erwähnten Unit-Tests und die testgetriebene Entwicklung ins Spiel: Wenn Sie die Anforderungen an die Eigenschaften und Methoden durch das vorherige Schreiben von Tests festlegen und auch überprüfen, können Sie auch ohne Sorge änderungen in Form von Refactoring-Maßnahmen durchführen. Dazu stellen Sie einfach sicher, dass die Anwendung vor dem Refactoring funktioniert, führen die änderungen durch und testen anschließend, ob weiterhin alles reibungslos läuft. Dazu können Sie die Tests verwenden, mit denen Sie auch die entsprechenden Methoden entwickelt haben – der einzige Unterschied ist, dass die Tests in diesem Zusammenhang „Regressionstests“ genannt werden.<\/p>\n
Testen Sie so oft wie möglich – je kleiner die änderungen zwischen zwei Tests sind, umso schneller finden Sie eventuell auftretende Fehler.<\/p>\n
Weitere Informationen über die testgetriebene Entwicklung finden Sie im Beitrag Testgetriebene Entwicklung mit Access in Ausgabe 4\/2004 von Access im Unternehmen. <\/p>\n
In den folgenden Abschnitten geht es los: Sie lernen die ersten Refactoring-Maßnahmen kennen. In diesem Beitrag stellen wir Ihnen gängige Maßnahmen für das Refactoring von Variablen und Methoden vor.<\/p>\n
Variablen bieten gute Ansatzpunkte für Refactoring. Nachfolgend finden Sie einige Refactoring-Maßnahmen, die je nach Situation Variablen hinzufügen, entfernen oder einfach ändern.<\/p>\n
Public Sub EinsBisZehn()\r\n Dim i As Integer\r\n For i = 1 To 10\r\n Debug.Print i\r\n Next i\r\nEnd Sub<\/pre>\nQuellcode 1<\/b><\/p>\n
Private Sub KombinationsfeldFuellen(intErstesJahr As Integer, intLetztesJahr As Integer)\r\n Dim i As Integer\r\n Dim strJahre As String\r\n For i = intErstesJahr To intLetztesJahr\r\n strJahre = strJahre & i & \";\"\r\n Next i\r\n strJahre = Mid(strJahre, 1, Len(strJahre) - 1)\r\n Me.cboJahreszahlen.RowSource = strJahre\r\nEnd Sub<\/pre>\nQuellcode 2<\/b><\/p>\n
Public Sub Rechteck(a As Integer, b As Integer)\r\n Dim temp As Integer\r\n temp = a * b\r\n Debug.Print \"Fläche: \" & temp\r\n temp = 2 * (a + b)\r\n Debug.Print \"Umfang: \" & temp\r\nEnd Sub<\/pre>\nQuellcode 3<\/b><\/p>\n
Hinweis<\/h3>\n
In den Schritt-für-Schritt-Anweisungen der einzelnen Refactoring-Maßnahmen finden Sie oft den Hinweis, die Anwendung zu kompilieren. Damit sollen meist bei der änderung von Variablen vergessene Vorkommen der jeweiligen Variablen gefunden werden. Damit der Debugger sich meldet, wenn eine nicht deklarierte Variable im Quellcode enthalten ist, müssen Sie zu Beginn des Moduls die Zeile Option Explicit einfügen. Es dürfen dann keine Variablen mehr ohne Deklaration verwendet werden. <\/p>\n
Temporäre Variable zerlegen<\/h2>\n
Es gibt mehrere Möglichkeiten, temporäre Variablen mehrfach zu verwenden. Die erste Möglichkeit ist die Verwendung in einer Schleife, was vollkommen legitim und außerdem unausweichlich ist, wie das Beispiel aus Quellcode 1 zeigt.<\/p>\n
Die zweite Möglichkeit ist gegeben, wenn der Inhalt der Variablen sukzessiv erweitert wird, etwa um den Inhalt eines Kombinationsfeldes zu erzeugen (im Fall des Beispiels aus Quellcode 2 handelt es sich um Jahreszahlen).<\/p>\n
Die dritte Möglichkeit besteht in der Verwendung einer Variablen für verschiedene Zwecke, wie in dem Beispiel aus Quellcode 3.<\/p>\n
Die Methode speichert nacheinander zwei völlig unterschiedliche Informationen in einer Variablen.<\/p>\n
Im vorliegenden Fall ist das noch überschaubar, aber wenn Sie sich noch 30 Zeilen Code zwischen den beiden Verwendungen der Variablen temp vorstellen, nimmt die übersichtlichkeit rasch ab. <\/p>\n
Beschreibung der Vorgehensweise<\/h3>\n
Verwenden Sie jede Variable nur einmal und vergeben Sie außerdem sprechende Namen für jede Variable. Damit erhöhen Sie die übersichtlichkeit und können außerdem später auf alle temporären Variablen zugreifen, ohne deren Werte erneut ermitteln zu müssen. Gehen Sie folgendermaßen vor:<\/p>\n
Benennen Sie die temporäre Variable in der Deklaration nach dem Zweck des ersten Vorkommens.<\/li>\n ändern Sie den Variablennamen an allen Stellen im Code, die sich auf die erste temporäre Variable beziehen.<\/li>\n Public Function AnzahlPersonen()\r\n AnzahlPersonen = DCount(\"[Kunden-Code]\", \"Kunden\") _ + DCount(\"[Personal-Nr]\", \"Personal\")\r\nEnd Function<\/pre>\nQuellcode 4<\/b><\/p>\n
Public Function AnzahlPersonen()\r\n Dim intAnzahlKunden As Integer\r\n Dim intAnzahlMitarbeiter As Integer\r\n intAnzahlKunden = DCount(\"[Kunden-Code]\", \"Kunden\")\r\n intAnzahlMitarbeiter = DCount(\"[Personal-Nr]\", \"Personal\")\r\n AnzahlPersonen = intAnzahlKunden + intAnzahlMitarbeiter\r\nEnd Function<\/pre>\nQuellcode 5<\/b><\/p>\n
Deklarieren Sie eine neue Variable mit einem Namen, der sich nach dem Zweck des zweiten Auftretens dieser Variablen richtet.<\/li>\n Passen Sie den Namen der Variablen im Code an.<\/li>\n Verfahren Sie genauso für alle weiteren Vorkommen.<\/li>\n Kompilieren Sie um sicherzugehen, dass Sie die ursprüngliche Variable an allen Stellen im Code ersetzt haben. (<\/li>\n Die Beispielprozedur aus Quellcode 3 sieht nach dieser Behandlung wie folgt aus (änderungen fett gedruckt):<\/p>\n
Public Sub Rechteck(a As Integer, b As Integer)\r\n Dim intFlaeche As Integer\r\n Dim intUmfang As Integer\r\n intFlaeche = a * b\r\n Debug.Print \"Fläche: \" & intFlaeche\r\n intUmfang = 2 * (a + b)\r\n Debug.Print \"Umfang: \" & intUmfang\r\nEnd Sub <\/pre>\nErklärende Variable einführen<\/h2>\n
Man verwendet oft komplizierte und aus mehreren Teilen bestehende Ausdrücke in Methoden, deren Ergebnis nicht unbedingt offensichtlich ist.<\/p>\n
<\/p>\n
Auf eine Domänenfunktion müssen Sie schon einen genaueren Blick werfen, um genau zu erkennen, welche Information sie ermittelt, um welche Domänenfunktion es sich handelt (DLookup, DMax, DCount, …), auf welche Datenherkunft sie sich bezieht, welches Feld die Funktion betrifft und wie ein eventuell vorhandenes Kriterium die Datenherkunft einschränkt. Folgende Funktion soll beispielsweise die Gesamtanzahl der Mitarbeiter und Kunden einer Firma ermitteln – zum Beispiel, um die richtige Menge Weihnachtskarten zu beschaffen (s. Quellcode 4).<\/p>\n
Zugegeben: Die Funktion lässt sich noch relativ schnell erfassen. Folgende Variante ist aber wesentlich freundlicher. Sie sehen, dass dort mit irgendeiner Funktion die Anzahl der Kunden und mit einer weiteren Funktion die Anzahl der Mitarbeiter ermittelt wird und dass diese beiden Werte addiert werden (s. Quellcode 5).<\/p>\n
Beschreibung der Vorgehensweise<\/h3>\n
Diese Refactoring-Maßnahme enthält folgende Schritte:<\/p>\n
Deklarieren Sie eine temporäre Variable mit einem aussagekräftigen Namen für jede Teilfunktion, für die es lohnenswert erscheint.<\/li>\n Weisen Sie den temporären Variablen den entsprechenden Teilausdruck zu.<\/li>\n Public Function AnzahlPersonen()\r\n Dim intAnzahlKunden As Integer\r\n Dim intAnzahlMitarbeiter As Integer\r\n intAnzahlKunden = AnzahlKunden\r\n intAnzahlMitarbeiter = DCount(\"[Personal-Nr]\", \"Personal\")\r\n AnzahlPersonen = intAnzahlKunden + intAnzahlMitarbeiter\r\nEnd Function\r\nPrivate Function AnzahlKunden() As Integer\r\n AnzahlKunden = DCount(\"[Kunden-Code]\", \"Kunden\")\r\nEnd Function<\/pre>\nQuellcode 6<\/b><\/p>\n
Public Function AnzahlPersonen()\r\n Dim intAnzahlMitarbeiter As Integer\r\n intAnzahlMitarbeiter = DCount(\"[Personal-Nr]\", \"Personal\")\r\n AnzahlPersonen = AnzahlKunden + intAnzahlMitarbeiter\r\nEnd Function<\/pre>\nQuellcode 7<\/b><\/p>\n
Private Function AnzahlMitarbeiter() As Integer\r\n AnzahlMitarbeiter = DCount(\"[Personal-Nr]\", \"Personal\")\r\nEnd Function<\/pre>\nQuellcode 8<\/b><\/p>\n
Public Function AnzahlPersonen()\r\n AnzahlPersonen = AnzahlKunden + AnzahlMitarbeiter\r\nEnd Function<\/pre>\nQuellcode 9<\/b><\/p>\n
Setzen Sie den ursprünglichen Ausdruck aus den Teilausdrücken zusammen. (<\/li>\n Temporäre Variable durch Funktion ersetzen<\/h2>\n
Diese Refactoring-Maßnahme heißt eigentlich Temporäre Variable durch Abfrage ersetzen. Mit Abfrage ist hier allerdings keine SQL-Abfrage, sondern das Pendant anderer Programmiersprachen zu einer VBA-Funktion gemeint.<\/p>\n
Als Beispiel greifen wir die Funktion auf, die durch die Refactoring-Maßnahme Erklärende Variable einführen entstanden ist (s. Quellcode 5). Voraussetzung ist weiterhin, dass die Methode der temporären Variablen nur einmal einen Wert zuweist. Ist das gegeben, gehen Sie beispielsweise folgendermaßen vor:<\/p>\n
Erstellen Sie eine private Funktion für die Ermittlung der Anzahl der Kunden und ersetzen Sie die DCount-Anweisung in der ursprünglichen Funktion durch die neue Funktion (s. Quellcode 6).<\/p>\n
Setzen Sie die Funktion AnzahlKunden überall ein, wo dieser Wert benötigt wird – außer bei der temporären Variablen intAnzahlKunden. Diese entfernen Sie ebenso wie die entsprechende Zuweisung (s. Quellcode 7).<\/p>\n
Erstellen Sie eine entsprechende private Funktion für die Variable intAnzahlMitarbeiter wie in Quellcode 8 und verwenden Sie den Aufruf dieser Funktion statt der Variablen wie in Quellcode 9.<\/p>\n
Damit hat die ursprüngliche Funktion deutlich an Gewicht verloren und ist wesentlich überschaubarer geworden. Zusätzlich haben Sie zwei Funktionen zur Ermitlung der Anzahl der Mitarbeiter und Kunden gewonnen, die Sie auch an anderer Stelle in dieser Klasse einsetzen können.<\/p>\n
Public Sub SpielereiMitNamen(strName As String)\r\n Dim strVorname As String\r\n Dim strNachname As String\r\n Call NameAufteilen(strName, strVorname, strNachname)\r\n Debug.Print \"Vorname: \" & strVorname\r\n Debug.Print \"Nachname: \" & strNachname\r\nEnd Sub\r\nPublic Sub NameAufteilen(strName As String, _ strVorname As String, strNachname As String)\r\n Dim intPos As Integer\r\n intPos = InStr(1, strName, \" \")\r\n strVorname = Mid(strName, 1, intPos)\r\n strNachname = Mid(strName, intPos + 1)\r\nEnd Sub<\/pre>\nQuellcode 10<\/b><\/p>\n
Public Sub SpielereiMitNamen_OO(strName As String)\r\n Dim objPerson As clsPerson\r\n Set objPerson = New clsPerson\r\n objPerson.NameAufteilen strName\r\n Debug.Print \"Vorname: \" & objPerson.Vorname\r\n Debug.Print \"Nachname: \" & objPerson.Nachname\r\n Set objPerson = Nothing\r\nEnd Sub<\/pre>\nQuellcode 11<\/b><\/p>\n
Beschreibung der Vorgehensweise<\/h3>\n
Mit den nachfolgenden Schritten ersetzen Sie eine Variable durch eine Funktion:<\/p>\n
Erzeugen Sie eine private Funktion, die den der Variablen zugewiesenen Inhalt ermittelt.<\/li>\n Ersetzen Sie die Variable überall dort, wo ihr Wert verwendet wird, durch den Funktionsaufruf.<\/li>\n Entfernen Sie die Deklaration der Variablen und die ursprüngliche Zuweisung. (<\/li>\n Zuweisung an Parameter entfernen<\/h2>\n
Parameter von Methoden dienen entweder dazu, einen Wert von der aufrufenden an die aufgerufene Methode zu übergeben oder umgekehrt oder beides. Genau von dem jeweiligen Fall sollte man auch abhängig machen, wie man einen solchen Parameter behandelt.<\/p>\n
Den letzteren Fall können Sie, wenn Sie objektorientiert und dementsprechend mit Klassen arbeiten möchten, ausschließen. Damit hätten Sie hier ein Refactoring, das in den üblichen Katalogen nicht beschrieben sein dürfte.<\/p>\n
Die Vorgehensweise, Ergebnisse einer Methode über die Parameter an die aufrufende Methode zu übergeben, ist immer dann angezeigt, wenn mehr als ein Parameter zurückgegeben werden und kein Array oder ein Type dafür verwendet werden soll. Die folgende Prozedur SpielereiMitNamen (s. Quellcode 10) ruft die Prozedur NameAufteilen auf, die den übergebenen Namen aufteilt und die resultierenden Teile in die Parameter strVorname und strNachname schreibt. Die aufrufende Prozedur kann diese anschließend auswerten. <\/p>\n
Mit einer Klasse sind keine Parameter mehr erforderlich, wenn eine Methode mehrere Rückgabewerte enthält. Diese Aufgabe übernehmen dann öffentliche Eigenschaften mit Lesezugriff. Das folgende Beispiel zeigt, wie es funktioniert. Die aufrufende Routine sieht so wie in Quellcode 11 aus.<\/p>\n
Die Routine deklariert und instanziiert ein Objekt, das auf der Klasse clsPerson basiert. Sie ruft deren Methode NameAufteilen mit dem kompletten Namen als Parameter auf und ermittelt aus den entsprechenden öffentlichen Eigenschaften die Werte für den Vor- und den Nachnamen.<\/p>\n
Dim mVorname As String\r\nDim mNachname As String\r\nPublic Property Get Vorname() As String\r\n Vorname = mVorname\r\nEnd Property\r\nPublic Property Get Nachname() As String\r\n Nachname = mNachname\r\nEnd Property\r\nPublic Sub NameAufteilen(strName As String)\r\n Dim intPos As Integer\r\n intPos = InStr(1, strName, \" \")\r\n mVorname = Mid(strName, 1, intPos)\r\n mNachname = Mid(strName, intPos + 1)\r\nEnd Sub<\/pre>\nQuellcode 12<\/b><\/p>\n
Public Sub NameGrossSchreiben(strName As String)\r\n Dim objPerson As clsPerson\r\n Set objPerson = New clsPerson\r\n Debug.Print objPerson.NameGrossSchreiben(strName)\r\n Debug.Print strName\r\n Set objPerson = Nothing\r\nEnd Sub<\/pre>\nQuellcode 13<\/b><\/p>\n
Public Function NameGrossSchreiben(strName As String)\r\n strName = StrConv(strName, vbProperCase)\r\n NameGrossSchreiben = strName\r\nEnd Function<\/pre>\nQuellcode 14<\/b><\/p>\n
Das instanziierte Objekt basiert auf einer Klasse, die ein Klassenmodul namens clsPerson mit folgendem Inhalt besitzt (s. Quellcode 12).<\/p>\n
Die beiden vorherigen Parameter zur übergabe von Vor- und Nachname sind nun als öffentliche Eigenschaften der Klasse ausgeführt. Sie sollen nur gelesen werden, daher gibt es je eine Property Get-Prozedur für jede Eigenschaft. Der aufzuteilende Name wird der Methode NameAufteilen per Parameter mitgeteilt.<\/p>\n
Hinweis<\/h3>\n
Die in diesem Beispiel beschriebene Umwandlung einer Prozedur mit Rückgabeparametern in eine Klasse mit speziell für die Rückgabe von Ergebnissen angelegten Eigenschaften kann aus Platzgründen hier leider nicht im Detail beschrieben werden. Weitere Informationen zur Verwendung von Klassen in Access finden Sie im Beitrag Objektorientiert programmieren mit Klassen in der Ausgabe 4\/2004 von Access im Unternehmen. <\/p>\n
Das eigentliche Motiv der Refactoring-Maßnahme Zuweisung an Parameter entfernen ist aber noch anders gelagert:<\/p>\n
Ausgangspunkt ist eine Methode, die den Wert eines Eingangsparameters verändert.<\/p>\n
Das kann gerade unter VBA gefährlich werden, da solche Werte im Normalfall als Referenz (ByRef) und nicht als Wert (ByVal) übergeben werden. Somit wirken sich – wie in obigem und auch in folgendem Beispiel – änderungen an den Parametern bis auf die aufrufende Routine aus.<\/p>\n
Den Aufruf der Methode können Sie Quellcode 13 entnehmen.<\/p>\n
Und nachfolgend finden Sie die entsprechende Methode in der bereits oben vorgestellten Klasse clsPerson (s. Quellcode 14).<\/p>\n
In dieser Konstellation wird der Parameter strName verändert, was sich auch auf die entsprechende Variable der aufrufenden Routine auswirkt. Um das zu verhindern, verwenden Sie einfach eine Hilfsvariable wie im Beispiel aus Quellcode 15. In dieser speichern Sie zunächst den Eingangswert zwischen, und beziehen sich im Anschluss auf die Variable, die den Wert nun enthält.<\/p>\n
Public Function NameGrossSchreiben(strName As String)\r\n Dim strTemp As String\r\n strTemp = StrConv(strName, vbProperCase)\r\n NameGrossSchreiben = strTemp\r\nEnd Function<\/pre>\nQuellcode 15<\/b><\/p>\n
Beschreibung der Vorgehensweise<\/h3>\n
Die nachfolgende Beschreibung bezieht sich auf den im letzten Beispiel dargestellten Fall.<\/p>\n
Deklarieren Sie eine temporäre Variable in der Methode.<\/li>\n Ersetzen Sie den Parameter jedes Mal, wenn ihm ein Wert zugewiesen wird, durch die temporäre Variable. (<\/li>\n Temporäre Variable entfernen<\/h2>\n
Temporäre Variablen sind manchmal nicht wirklich notwendig. Das ist meist der Fall, wenn der Inhalt des zugewiesenen Ausdrucks durch den Ausdruck ausreichend beschrieben wird – also beispielsweise, wenn Sie einer Variablen den Inhalt eines Feldes einer Datensatzgruppe zuweisen (s. Quellcode 16).<\/p>\n
Manchmal wird eine temporäre Variable auch erst mit der Zeit überflüssig – etwa wenn Sie den in der Variablen gespeicherten Wert zu Beginn oft benötigt haben, dessen Einsätze aber nach und nach bis auf einen zusammengestrichen haben.<\/p>\n
Eine Variable wie strFirma etwa macht nur dann Sinn, wenn der Inhalt nach der Zuweisung mehr als einmal verwendet wird. Ansonsten sollten Sie diese – ausgehend von Quellcode 16 – streichen und die Zuweisung direkt vornehmen wie in Quellcode 17.<\/p>\n
Beschreibung derVorgehensweise<\/h3>\n
Wenn eine Variable entfernt werden soll, gehen Sie folgendermaßen vor:<\/p>\n
Ersetzen Sie die Variable an allen Stellen des Auftretens durch den dieser Variablen zugewiesenen Ausdruck.<\/li>\n Kommentieren Sie die Deklaration der Variablen und die Zuweisung des Ausdrucks an die Variable aus.<\/li>\n Kompilieren Sie, um sicherzustellen, dass Sie kein Auftreten der Variablen übersehen haben. (<\/li>\n ''...\r\nDim strFirma As String\r\n''...\r\nDo While Not rst.EOF\r\n strFirma = rst!Firma\r\n Debug.Print strFirma\r\n rst.MoveNext\r\nLoop \r\n''...<\/pre>\nQuellcode 16<\/b><\/p>\n
''...\r\nDo While Not rst.EOF\r\n Debug.Print rst!Firma\r\n rst.MoveNext\r\nLoop \r\n''...<\/pre>\nQuellcode 17<\/b><\/p>\n
Nachdem Sie sich mit verschiedenen Refactoring-Maßnahmen in Zusammenhang mit Variablen befasst haben, folgen nun größere Bestandteile von Methoden: nämlich solche, die sich komplett aus- oder auch eingliedern lassen. Natürlich spielen Variablen auch hier wieder eine Rolle, sie können das Ausgliedern von Code erheblich erschweren.<\/p>\n
Public Sub MethodeExtrahieren_I()\r\n If SysCmd(acSysCmdGetObjectState, acForm, \"frmBeispiel\") Then\r\n ''...\r\n End If\r\n ''...\r\n If SysCmd(acSysCmdGetObjectState, acForm, \"frmBeispiel\") Then\r\n ''...\r\n End If\r\nEnd Sub<\/pre>\nQuellcode 18<\/b><\/p>\n
Extrahieren von Methoden<\/h2>\n
Der Name dieser Refactoring-Maßnahme ist möglicherweise etwas irreführend, da diese eigentlich das Erstellen neuer Methoden aus einer oder mehreren Anweisungen einer bestehenden Methode beinhaltet.<\/p>\n
Für diese Vorgehensweise kann es mehrere Gründe geben:<\/p>\n
Eine Anweisung oder mehrere zusammenhängende Anweisungen wiederholen sich.<\/li>\n Eine Methode ist zu lang und enthält Anweisungen, die man gruppieren und in einer eigenen Methode unterbringen kann.<\/li>\n Wiederholung von Anweisungen oder Gruppen von Anweisungen<\/h3>\n
Erstere Variante ist sicher jedem schon mal untergekommen, im einfachsten Fall in Form eines Einzeilers. <\/p>\n
Folgendes Beispiel überprüft beispielsweise zweimal, ob ein bestimmtes Formular geöffnet ist, und verwendet dazu eine eingebaute Funktion mit wenig aussagekräftigem Namen, deren Zweck sich erst aus dem Studium der Parameter ergibt (s. Quellcode 18).<\/p>\n
Hier gibt es mindestens drei Argumente für ein Extrahieren dieser Anweisung in eine eigene Methode:<\/li>\n Die Funktion hat einen aussagekräftigeren Namen verdient.<\/li>\n Die Funktion tritt mehrmals auf, der Pflegeaufwand könnte reduziert werden.<\/li>\n Die Funktion könnte man noch erweitern, um etwa die aktuelle Ansicht des Formulars zu ermitteln – das erfordert wesentlich weniger Aufwand, wenn es nur an einer Stelle erfolgen muss.<\/li>\n Der exakt gleiche Aufruf der SysCmd-Funktion in diesem Beispiel könnte auf den ersten Blick auch dazu verleiten, eine temporäre Variable für das Ergebnis zu verwenden und die Funktion nur einmal aufzurufen – das wäre aber sehr gefährlich, da sich der Zustand des Formulars durchaus ändern könnte, während die Routine abläuft.<\/p>\n
Beschreibung der Vorgehensweise<\/h3>\n
Um die betreffenden Anweisungen in eine neue Methode zu extrahieren, gehen Sie folgendermaßen vor:<\/p>\n
Erstellen Sie eine neue Methode mit dem gewünschten Namen. Verwenden Sie dabei eine Function- oder eine Sub-Prozedur – je nachdem, ob die Anweisung(en) einen Rückgabewert liefern.<\/li>\n Kontrollieren Sie, ob temporäre Variablen der alten Methode sowohl von den verbleibenden als auch von den zu extrahierenden Anweisungen verwendet werden. Fügen Sie diese der Methode als Parameter hinzu.<\/li>\n Kontrollieren Sie, ob temporäre Variablen der alten Methode nur in den zu extrahierenden Anweisungen verwendet werden, und extrahieren Sie diese gegebenenfalls mit.<\/li>\n Public Function IstfrmBeispielGeoeffnet()\r\n IstfrmBeispielGeoeffnet = SysCmd(acSysCmdGetObjectState, acForm, \"frmBeispiel\")\r\nEnd Function<\/pre>\nQuellcode 19<\/b><\/p>\n
Public Function IstFormularGeoeffnet(strFormular As String)\r\n IstFormularGeoeffnet = SysCmd(acSysCmdGetObjectState, acForm, strFormular)\r\nEnd Function<\/pre>\nQuellcode 20<\/b><\/p>\n
Fügen Sie die zu extrahierenden Anweisungen in die neue Methode ein.<\/li>\n Löschen Sie die Anweisungen in der alten Methode.<\/li>\n Fügen Sie den Aufruf der neuen Methode an Stelle der extrahierten Anweisungen ein. Vergessen Sie nicht, die Parameter anzugeben. (<\/li>\n Für unser Beispiel sieht das Ergebnis folgendermaßen aus – zuerst die alte Methode:<\/p>\n
Public Sub MethodeExtrahieren_II()\r\n If IstfrmBeispielGeoeffnet Then\r\n ''...\r\n End If\r\n ''...\r\n If IstfrmBeispielGeoeffnet Then\r\n ''...\r\n End If\r\nEnd Sub<\/pre>\nDie neue Methode sieht nun wie in Quellcode 19 aus. Für diesen Zweck wäre diese Konfiguration durchaus ausreichend, aber es macht natürlich keinen Sinn, eine Methode zu verwenden, die den Zustand genau eines festgelegten Formulars ermittelt.<\/p>\n
Damit die Funktion auch mit anderen Formularen arbeitet, ersetzen Sie den Namen des zu untersuchenden Formulars durch einen Parameter (s. Quellcode 20).<\/p>\n
Der Aufruf in der alten Methode sieht nun so aus:<\/p>\n
If IstFormularGeoeffnet(\"frmBeispiel\") _ Then\r\n ''...\r\nEnd If<\/pre>\nLange und unübersichtliche Methoden aufteilen<\/h3>\n
Das Extrahieren von Methoden dient nicht zwangsläufig nur zum „Ausklammern“ von Codeteilen. Es kann auch oft hilfreich sein, wenn eine Methode zu lang ist, um schnell verstanden zu werden. Ob und wann das so ist, können Sie schnell herausfinden, indem Sie prüfen, ob der enthaltene Code dem Namen der Methode entspricht oder ob dort vielleicht viel mehr passiert, als der Name der Prozedur erahnen lässt. Wenn das der Fall ist, sollten Sie alle entsprechenden Teile des Codes in Methoden mit aussagekräftigen Namen extrahieren.<\/p>\n
Integrieren von Methoden<\/h2>\n
Der Inhalt mancher Methode ist so einfach und selbsterklärend, dass eigentlich keine Methode mit einem eigenen Namen dafür nötig ist.<\/p>\n
In manchen Fällen ist es daher sinnvoll, eine Methode aufzulösen und die darin enthaltenen Anweisungen in die aufrufende Methode zu integrieren.<\/p>\n
Ob man eine Methode in eine andere integriert, hängt auch davon ab, an wie vielen Stellen auf diese verwiesen wird. Passiert das oft, verlieren Sie durch die Integration die Möglichkeit, änderungen komfortabel an einer Stelle durchzuführen.<\/p>\n
Public Function BeispielMethodeIntegrieren()\r\n Dim intSumme As Integer\r\n Dim intA As Integer\r\n Dim intB As Integer\r\n intA = 10\r\n intB = 5\r\n ''...\r\n intSumme = Summe(intA, intB)\r\n Debug.Print intSumme\r\nEnd Function\r\nPrivate Function Summe(intA As Integer, intB As Integer)\r\n Summe = intA + intB\r\nEnd Function<\/pre>\nQuellcode 21<\/b><\/p>\n
Public Function BeispielMethodeIntegrieren()\r\n Dim intSumme As Integer\r\n Dim intA As Integer\r\n Dim intB As Integer\r\n intA = 10\r\n intB = 5\r\n ''...\r\n intSumme = intA + intB\r\n Debug.Print intSumme\r\nEnd Function<\/pre>\nQuellcode 22<\/b><\/p>\n
Ist die Funktion der Methode hingegen so speziell, dass sie nur in einer Methode und dort auch nur wenige Male aufgerufen wird, kann man sie dort guten Gewissens integrieren. Das Beispiel aus Quellcode 21 enthält den Aufruf einer mehr als trivialen Funktion, die dringend in die aufrufende Methode integriert werden sollte. Hier ersetzen Sie einfach den rechten Teil des Aufrufs durch den rechten Teil der einzigen Anweisung der Funktion (s. Quellcode 22). Die Funktion Summe können Sie anschließend entfernen.<\/p>\n
Beschreibung der Vorgehensweise<\/h3>\n
Die Anwendung dieser Refactoring-Maßnahme umfasst folgende Schritte:<\/p>\n
Ersetzen Sie alle Aufrufe durch den Inhalt der zu integrierenden Methode.<\/li>\n Kommentieren Sie die zu integrierende Methode aus.<\/li>\n Kompilieren Sie, um zu prüfen, ob alle Aufrufe der Methode durch deren Inhalt ersetzt wurden.<\/li>\n Entfernen Sie die auskommentierte Methode entgültig. (<\/li>\n Achten Sie darauf, dass korrespondierende Parameter im Aufruf und in der ersten Zeile der Methode theoretisch unterschiedliche Namen haben können.<\/p>\n
Im diesem Beitrag haben wir Ihnen einige Maßnahmen zur Verbesserung des Quellcodes vorgestellt, von denen Sie die eine oder andere – bewusst oder unbewusst – schon verwendet haben. Wenn Sie die Refactoring-Maßnahmen konsequent anwenden, erhalten Sie gut lesbaren Code, den auch andere Entwickler leicht warten und weiterentwickeln können.<\/p>\n
Hin und wieder sollten Sie die vorgenommen änderungen hinsichtlich eventueller Performance-Einbußen kontrollieren. In der Regel liegen diese aber in vernachlässigbaren Bereichen und können in Kauf genommen werden.<\/p>\n
In den folgenden Ausgaben von Access im Unternehmen stellen wir Ihnen in loser Folge weitere Refactoring-Maßnahmen vor.<\/p>\n","protected":false},"excerpt":{"rendered":"
Refactoring ist eines der Schlagwörter des Extreme Programming und untrennbar mit dem Unit-Testing und der testgetriebenen Entwicklung verbunden. Durch Refactoring verbessern Sie die Struktur und Lesbarkeit des Codes einer Anwendung unter Beibehaltung der Funktionalität und erleichtern damit Änderungen und Erweiterungen der Funktion der Anwendung.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"_uf_show_specific_survey":0,"_uf_disable_surveys":false,"footnotes":""},"categories":[662004,66062004,44000025],"tags":[],"class_list":["post-55000241","post","type-post","status-publish","format-standard","hentry","category-662004","category-66062004","category-VBA_und_Programmiertechniken"],"yoast_head":"\n
Refactoring - Access im Unternehmen<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/access-im-unternehmen.de\/Refactoring\/\" \/>\n<meta property=\"og:locale\" content=\"de_DE\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Refactoring\" \/>\n<meta property=\"og:description\" content=\"Refactoring ist eines der Schlagwörter des Extreme Programming und untrennbar mit dem Unit-Testing und der testgetriebenen Entwicklung verbunden. Durch Refactoring verbessern Sie die Struktur und Lesbarkeit des Codes einer Anwendung unter Beibehaltung der Funktionalität und erleichtern damit Änderungen und Erweiterungen der Funktion der Anwendung.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/access-im-unternehmen.de\/Refactoring\/\" \/>\n<meta property=\"og:site_name\" content=\"Access im Unternehmen\" \/>\n<meta property=\"article:published_time\" content=\"2020-05-06T15:17:52+00:00\" \/>\n<meta property=\"og:image\" content=\"http:\/\/vg06.met.vgwort.de\/na\/4306b148f3824c4f836a527a79302104\" \/>\n<meta name=\"author\" content=\"Andr\u00e9 Minhorst\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Verfasst von\" \/>\n\t<meta name=\"twitter:data1\" content=\"Andr\u00e9 Minhorst\" \/>\n\t<meta name=\"twitter:label2\" content=\"Gesch\u00e4tzte Lesezeit\" \/>\n\t<meta name=\"twitter:data2\" content=\"21\u00a0Minuten\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Refactoring\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Refactoring\\\/\"},\"author\":{\"name\":\"Andr\u00e9 Minhorst\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/person\\\/13395c4bcd7d7963efe33be9c584d93f\"},\"headline\":\"Refactoring\",\"datePublished\":\"2020-05-06T15:17:52+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Refactoring\\\/\"},\"wordCount\":3663,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Refactoring\\\/#primaryimage\"},\"thumbnailUrl\":\"http:\\\/\\\/vg06.met.vgwort.de\\\/na\\\/4306b148f3824c4f836a527a79302104\",\"articleSection\":[\"2004\",\"6\\\/2004\",\"VBA und Programmiertechniken\"],\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/access-im-unternehmen.de\\\/Refactoring\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Refactoring\\\/\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Refactoring\\\/\",\"name\":\"Refactoring - Access im Unternehmen\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Refactoring\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Refactoring\\\/#primaryimage\"},\"thumbnailUrl\":\"http:\\\/\\\/vg06.met.vgwort.de\\\/na\\\/4306b148f3824c4f836a527a79302104\",\"datePublished\":\"2020-05-06T15:17:52+00:00\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Refactoring\\\/#breadcrumb\"},\"inLanguage\":\"de\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/access-im-unternehmen.de\\\/Refactoring\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Refactoring\\\/#primaryimage\",\"url\":\"http:\\\/\\\/vg06.met.vgwort.de\\\/na\\\/4306b148f3824c4f836a527a79302104\",\"contentUrl\":\"http:\\\/\\\/vg06.met.vgwort.de\\\/na\\\/4306b148f3824c4f836a527a79302104\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/Refactoring\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Refactoring\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#website\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\",\"name\":\"Access im Unternehmen\",\"description\":\"Das Magazin f\u00fcr Datenbankentwickler auf Basis von Microsoft Access\",\"publisher\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/access-im-unternehmen.de\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"de\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#organization\",\"name\":\"Andr\u00e9 Minhorst Verlag\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/access-im-unternehmen.de\\\/wp-content\\\/uploads\\\/2019\\\/09\\\/aiu_wp.png\",\"contentUrl\":\"https:\\\/\\\/access-im-unternehmen.de\\\/wp-content\\\/uploads\\\/2019\\\/09\\\/aiu_wp.png\",\"width\":370,\"height\":111,\"caption\":\"Andr\u00e9 Minhorst Verlag\"},\"image\":{\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/logo\\\/image\\\/\"}},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/access-im-unternehmen.de\\\/#\\\/schema\\\/person\\\/13395c4bcd7d7963efe33be9c584d93f\",\"name\":\"Andr\u00e9 Minhorst\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"de\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g\",\"caption\":\"Andr\u00e9 Minhorst\"}}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Refactoring - Access im Unternehmen","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/access-im-unternehmen.de\/Refactoring\/","og_locale":"de_DE","og_type":"article","og_title":"Refactoring","og_description":"Refactoring ist eines der Schlagwörter des Extreme Programming und untrennbar mit dem Unit-Testing und der testgetriebenen Entwicklung verbunden. Durch Refactoring verbessern Sie die Struktur und Lesbarkeit des Codes einer Anwendung unter Beibehaltung der Funktionalität und erleichtern damit Änderungen und Erweiterungen der Funktion der Anwendung.","og_url":"https:\/\/access-im-unternehmen.de\/Refactoring\/","og_site_name":"Access im Unternehmen","article_published_time":"2020-05-06T15:17:52+00:00","og_image":[{"url":"http:\/\/vg06.met.vgwort.de\/na\/4306b148f3824c4f836a527a79302104","type":"","width":"","height":""}],"author":"Andr\u00e9 Minhorst","twitter_card":"summary_large_image","twitter_misc":{"Verfasst von":"Andr\u00e9 Minhorst","Gesch\u00e4tzte Lesezeit":"21\u00a0Minuten"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/access-im-unternehmen.de\/Refactoring\/#article","isPartOf":{"@id":"https:\/\/access-im-unternehmen.de\/Refactoring\/"},"author":{"name":"Andr\u00e9 Minhorst","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/person\/13395c4bcd7d7963efe33be9c584d93f"},"headline":"Refactoring","datePublished":"2020-05-06T15:17:52+00:00","mainEntityOfPage":{"@id":"https:\/\/access-im-unternehmen.de\/Refactoring\/"},"wordCount":3663,"commentCount":0,"publisher":{"@id":"https:\/\/access-im-unternehmen.de\/#organization"},"image":{"@id":"https:\/\/access-im-unternehmen.de\/Refactoring\/#primaryimage"},"thumbnailUrl":"http:\/\/vg06.met.vgwort.de\/na\/4306b148f3824c4f836a527a79302104","articleSection":["2004","6\/2004","VBA und Programmiertechniken"],"inLanguage":"de","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/access-im-unternehmen.de\/Refactoring\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/access-im-unternehmen.de\/Refactoring\/","url":"https:\/\/access-im-unternehmen.de\/Refactoring\/","name":"Refactoring - Access im Unternehmen","isPartOf":{"@id":"https:\/\/access-im-unternehmen.de\/#website"},"primaryImageOfPage":{"@id":"https:\/\/access-im-unternehmen.de\/Refactoring\/#primaryimage"},"image":{"@id":"https:\/\/access-im-unternehmen.de\/Refactoring\/#primaryimage"},"thumbnailUrl":"http:\/\/vg06.met.vgwort.de\/na\/4306b148f3824c4f836a527a79302104","datePublished":"2020-05-06T15:17:52+00:00","breadcrumb":{"@id":"https:\/\/access-im-unternehmen.de\/Refactoring\/#breadcrumb"},"inLanguage":"de","potentialAction":[{"@type":"ReadAction","target":["https:\/\/access-im-unternehmen.de\/Refactoring\/"]}]},{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/access-im-unternehmen.de\/Refactoring\/#primaryimage","url":"http:\/\/vg06.met.vgwort.de\/na\/4306b148f3824c4f836a527a79302104","contentUrl":"http:\/\/vg06.met.vgwort.de\/na\/4306b148f3824c4f836a527a79302104"},{"@type":"BreadcrumbList","@id":"https:\/\/access-im-unternehmen.de\/Refactoring\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/access-im-unternehmen.de\/"},{"@type":"ListItem","position":2,"name":"Refactoring"}]},{"@type":"WebSite","@id":"https:\/\/access-im-unternehmen.de\/#website","url":"https:\/\/access-im-unternehmen.de\/","name":"Access im Unternehmen","description":"Das Magazin f\u00fcr Datenbankentwickler auf Basis von Microsoft Access","publisher":{"@id":"https:\/\/access-im-unternehmen.de\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/access-im-unternehmen.de\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"de"},{"@type":"Organization","@id":"https:\/\/access-im-unternehmen.de\/#organization","name":"Andr\u00e9 Minhorst Verlag","url":"https:\/\/access-im-unternehmen.de\/","logo":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/logo\/image\/","url":"https:\/\/access-im-unternehmen.de\/wp-content\/uploads\/2019\/09\/aiu_wp.png","contentUrl":"https:\/\/access-im-unternehmen.de\/wp-content\/uploads\/2019\/09\/aiu_wp.png","width":370,"height":111,"caption":"Andr\u00e9 Minhorst Verlag"},"image":{"@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/logo\/image\/"}},{"@type":"Person","@id":"https:\/\/access-im-unternehmen.de\/#\/schema\/person\/13395c4bcd7d7963efe33be9c584d93f","name":"Andr\u00e9 Minhorst","image":{"@type":"ImageObject","inLanguage":"de","@id":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/1b9d010cf1716692cb9c34f21554e07d17d461acaea5b61b8cb21cbec678d48a?s=96&d=mm&r=g","caption":"Andr\u00e9 Minhorst"}}]}},"_links":{"self":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts\/55000241","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/comments?post=55000241"}],"version-history":[{"count":0,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/posts\/55000241\/revisions"}],"wp:attachment":[{"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/media?parent=55000241"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/categories?post=55000241"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/access-im-unternehmen.de\/data\/wp\/v2\/tags?post=55000241"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}