Refactoring

Überblick

Im Allgemeinen ist ein Refactoring der Prozess einer Neustrukturierung und Verbesserung eines bestehenden Softwarecodes, ohne dass sein Verhalten geändert wird.

Die Refaktorierung in EcoStruxure Machine Expert stellt Funktionen zum Umbenennen von Objekten und Variablen zur Verfügung. Sie können die Nutzungsorte geänderter Objekte und Variablen anzeigen und alle gemeinsam oder nur einzelne Elemente umbenennen. Sie können festlegen, ob und an welchen Speicherorten Sie nach einem Refactoring gefragt werden möchten. Für eine globale Applikation steht der Befehl Refactoring > Umbenennen zur Verfügung.

Für weitere Informationen siehe auch Optionen, Refactoring.

Befehl Umbenennen

Der Befehl Refactoring > Umbenennen wird für ein globales, projektweites Umbenennen von Objekten und Variablen verwendet.

Er steht im Kontextmenü zur Verfügung, wenn Sie mit der rechten Maustaste in der Deklaration auf einen Variablennamen oder in einem Navigator auf eines der folgenden Objekte klicken:

Funktionen
POUs
GVLs
Methoden
Eigenschaften
Geräte

Der Befehl ist auch verfügbar, wenn Sie im Editor zur Einheitenkonvertierung Variablen und Einheitenkonvertierungen auswählen.

Der Befehl steht nicht im Online-Modus zur Verfügung.

Prozess des Umbenennens

Wenn Sie den Befehl Refactoring > Umbenennen ausführen, wird ein Dialogfeld angezeigt. Es zeigt den Speicherort, an dem der entsprechende Name verwendet wird: im rechten Teil des Fensters die einzelnen Speicherorte, im linken Teil die Navigationsstruktur, in der das betreffende Objekt markiert ist.

Sie können für jeden Speicherort die folgenden Befehle auswählen:

Diese Änderung verwerfen/annehmen: Einzelne Änderungen können Sie im rechten Fenster übernehmen oder zurückweisen.
Dieses Objekt verwerfen/annehmen: Alle Änderungen für das entsprechende Objekt werden übernommen oder zurückgewiesen.
Das gesamte Projekt verwerfen/annehmen: Alle Änderungen im Projekt werden übernommen oder zurückgewiesen.

Übernommene Änderungen werden mit einem gelben Hintergrund angezeigt, zurückgewiesene mit einem grauen.

Befehl <Variable> hinzufügen

Der Befehl Refactoring > <Variable> hinzufügen ermöglicht die Deklaration von Variablen in einer POU und die Durchführung einer automatischen Aktualisierung an verschiedenen Verwendungspunkten.

Er steht im Kontextmenü oder im Menü Bearbeiten > Refactoring zur Verfügung, wenn der Cursor in einem Deklarationseditor platziert ist. Das Dialogfeld Variable deklarierenwird geöffnet.

Nachdem Sie das Dialogfeld Variable deklarieren mit OK bestätigt haben, wird das Dialogfeld Refactoring geöffnet. In dem Dialogfeld erscheint die Baumstruktur des Projekts auf der linken Seite. Die POUs, in denen die neue Variable verwendet wird, sind in der Baumstruktur unterlegt. Mit einem Doppelklick auf eine POU können Sie auf der rechten Seite des Dialogfelds eine detaillierte Ansicht öffnen. In diesem Deklarations- und Implementierungsbereich der POU sind die neuen Deklarationen auf der rechten Seite gelb unterlegt.

Bevor Sie sich für das Akzeptieren bestimmter Änderungen an bestimmten Speicherorten entscheiden, müssen Sie die geeignete Option in der Liste über dem Deklarations- und Implementierungsbereich der POU auf der rechten Seite wählen:

Option	Beschreibung
Eingänge mit Platzhalter hinzufügen	Wählen Sie diese Option, um den Standardplatzhaltertext `_REFACTOR_` immer dann einzugeben, wenn die neue Variable im Implementierungscode erscheint. Sie können auch zu einem späteren Zeitpunkt nach diesem Standardtext suchen, um die betroffenen Speicherorte zu identifizieren.
Eingänge mit folgendem Wert eingeben	Wählen Sie diese Option, um immer dann einen Initialisierungswert einzufügen, wenn die neue Variable im Implementierungscode erscheint. Geben Sie den Initialisierungswert im Textfeld auf der rechten Seite der Option Eingänge mit folgendem Wert hinzufügen ein.

Zum Annehmen oder Ablehnen der Änderungen klicken Sie mit der rechten Maustaste auf die geänderten Speicherorte oder führen die Befehle im linken oder rechten Abschnitt des Dialogfelds aus, wie im Abschnitt Prozess des Umbenennens in diesem Kapitel beschrieben ist.

Beispiele für das Hinzufügen einer Variablen

Beispiel 1:

Beim Refactoring empfängt der Baustein fun eine neue Eingangsvariable input3 mit dem Initialisierungswert 1. Die Änderung wirkt sich wie folgt aus:

Vor dem Refactoring:

fun(a + b, 3, TRUE);
fun(input1:= a + b , input2 :=3 , inputx := TRUE);

Nach dem Refactoring:

fun(a + b, 3, input3:=1, TRUE);
fun(input1:= a + b , input2 :=3 , input3:=_REFACTOR_,inputx := TRUE);

Beispiel 2:

Beim Refactoring empfängt der Baustein fun eine neue Eingangsvariable input3 mit dem Platzhaltertext _REFACTOR_:

Vor dem Refactoring:

inst(input1 := a + b, input2 := 3, inputx := TRUE);
fun(a + b, 3, TRUE);

Nach dem Refactoring:

inst(input1 := a + b, input2 := 3, input3 := _REFACTOR_, inputx := TRUE);
fun(a + b, 3, input3:=_REFACTOR_, TRUE);

Befehl <Variable> entfernen

Der Befehl Refactoring > <Variable> entfernen ermöglicht das Entfernen der Ein- oder Ausgangsvariablen aus einer POU. Die Variable wird automatisch an den verschiedenen Verwendungspunkten aus der POU entfernt.

Der Befehl ist im Kontextmenü oder im Menü Bearbeiten > Refactoring verfügbar, wenn der Cursor im Deklarationseditor auf der Kennung der zu entfernenden Variablen platziert wird. Ein Dialogfeld mit Informationen über das Entfernen wird geöffnet. Wenn Sie die Meldung bestätigen, wird das Dialogfeld Refactoring geöffnet.

Sobald Sie die im Dialogfeld Refactoring vorgeschlagenen Änderungen akzeptieren, werden die entsprechenden Ein- und Ausgangsvariablen automatisch aus der entsprechenden POU an den verschiedenen Verwendungspunkten entfernt.

HINWEIS: In CFC wird nur die Verbindung zwischen dem entfernten Eingang oder Ausgang und dem Baustein entfernt. Der Eingang bzw. der Ausgang selbst bleibt im Diagramm bestehen.

Beispiel für das Entfernen einer Variablen in ST

In einer POU entfernt das Refactoring die Eingangsvariable input4. Die Variable wird automatisch an den verschiedenen Verwendungspunkten aus der POU entfernt:

Vor der Entfernung:

inst(input1 := a + b, input2 := 3, input4 := 1, input5 := TRUE);
fun(a + b, 3, 1, TRUE);

Nach der Entfernung:

inst(input1 := a + b, input2 := 3, input5 := TRUE);
fun(a + b, 3, TRUE);

Befehl Referenzierte Anschlüsse aktualisieren

Der Befehl Refactoring > Referenzierte Anschlüsse aktualisieren gilt nur für den CFC- und den FBD/LD/IL-Editor. Er entspricht den Befehlen Anschlüsse zurücksetzen und Parameter aktualisieren.

Der Befehl Refactoring > Referenzierte Anschlüsse aktualisieren aktualisiert die Ein- und Ausgangsanschlüsse der POU an allen Verwendungspunkten, entsprechend der aktuellen POU-Deklaration.

Er steht im Kontextmenü oder im Menü Bearbeiten > Refaktorierung zur Verfügung, wenn der Cursor auf dem POU-Namen in der ersten Zeile der POU-Deklaration oder im Geräteeditor platziert wird.

Befehl Variablen neu ordnen

Über den Befehl Refactoring > Variablen neu ordnen können Sie die Reihenfolge der Variablendeklarationen in den Bereichen VAR_INPUT, VAR_OUTPUT oder VAR_IN_OUT ändern.

Beispiel:

VAR_INPUT
  invar2 : INT;
  invar1 : INT;
  in : DUT;
  bvar : BOOL;
  invar3 : INT;

Gehen Sie vor wie folgt, um die Reihenfolge der Deklarationen zu ändern:

Schritt	Aktion
1	Klicken Sie mit der rechten Maustaste auf den Deklarationsteil und führen Sie den Befehl Refactoring > Variablen neu ordnen aus. Ergebnis: Das Dialogfeld Neu ordnen wird mit einer Liste der VAR_INPUT-Variablen geöffnet.
2	Ziehen Sie den Eintrag invar1 : INT; an die Position vor dem Eintrag invar2.. Ergebnis: Die invar1-Deklaration befindet sich an der obersten Position.
3	Klicken Sie auf OK, um das Dialogfeld zu schließen. Ergebnis: Das Dialogfeld Refactoring wird geöffnet. Die betroffenen Elemente werden in gelb dargestellt.
4	Klicken Sie auf OK, um die neue Reihenfolge der Parameter des Funktionsbausteins zu übernehmen. Beachten Sie, dass die geänderte Reihenfolge der Parameter ebenfalls für die Aufrufverwaltung der POUs übernommen wird.

Ändern einer Variablendeklaration und automatisches Anwenden des Refactorings

Refactoring kann Sie bei der Umbenennung von Variablen (mithilfe von Variable deklarieren) wie in nachstehendem Beispiel gezeigt unterstützen.

Voraussetzung für dieses Beispiel ist die Verfügbarkeit eines Funktionsbausteins fb_A mit einem Eingang iA.

Schritt	Aktion	Kommentar
1	Führen Sie den Befehl Tools > Optionen... aus.	Ergebnis: Das Dialogfeld Optionen wird geöffnet.
2	Wählen Sie die Kategorie Refactoring auf der linken Seite aus.	–
3	Wählen Sie im Bereich Variable deklarieren die Optionen Beim Hinzufügen oder Entfernen von Variablen oder beim Ändern des Bereichs und Beim Umbenennen von Variablen aus.	–
4	Doppelklicken Sie auf den Funktionsbaustein fb_A.	–
5	Wählen Sie eine Variablen in der Deklaration von fb_A aus, z. B. iA.	Sie können auch den Cursor vor oder in die Variable setzen.
6	Führen Sie den Befehl Bearbeiten > Variable deklarieren... aus.	Oder verwenden Sie das Tastaturkürzel Umschalt + F2. Ergebnis: Das Dialogfeld Variable deklarieren wird geöffnet. In diesem Dialogfeld werden die Einstellungen für die Variable iA angezeigt.
7	Bearbeiten Sie den Namen und ändern Sie iA zu iCounter_A.	Ergebnis: Das Dialogfeld Refactoring - iA zu iCounterA umbenennen wird geöffnet. Die POUs, in denen die Variable verwendet wird, werden in der Baumstruktur optisch hervorgehoben.
8	Kicken Sie auf OK, um die Umbenennung anzuwenden und das Dialogfeld zu schließen.	–