Code-Debugging

MetaEditor hat einen eingebauten Debugger, mit dem Sie die Programmausführung Schritt für Schritt (durch einzelne Funktionen) überprüfen können. Setzen Sie Haltepunkte in den Code. Dies sind die Stellen, an denen die Programmausführung angehalten werden soll. Dann starten Sie das Programm auf einem normalen Chart oder dem Strategietester. Sobald das Programm einen Haltepunkt erreicht, wird es angehalten. Dadurch können Sie die Werte der berechneten Variablen sehen und die Programmausführung Schritt für Schritt fortsetzen, indem Sie den Ausführungsalgorithmus überprüfen.

• Voreinstellung
• Haltepunkte
• Debugging starten
• Beobachtete Ausdrücke
• Anzeigen eines Aufrufstapels
• Debuggen Schritt-für-Schritt
• Pausieren, Fortsetzen und Beenden des Debuggens
• Fehlersuche in der Historie

Voreinstellung #

Setzen Sie vor dem Debuggen die allgemeinen Parameter in MetaEditor Einstellungen. Sie können ein Symbol und einen Zeitrahmen angeben, auf dem das Debugging von Anwendungen stattfinden soll. Ein solches Chart wird jedes Mal, wenn Sie mit dem Debuggen beginnen, temporär erstellt und sofort nach seiner Beendigung wieder entfernt.

Haltepunkte #

Ein Haltepunkt (Breakpoint) ist ein Befehl, der ausgelöst wird, wenn eine Programmausführung eine bestimmte Zeile erreicht. Der Befehl stoppt die Ausführung an dieser Zeile. Haltepunkte erlauben es, das Verhalten eines Programms in einem bestimmten Codebereich zu untersuchen: die Variablenwerte und den Funktionsstapel anzuzeigen. In Zukunft kann der Debugging-Prozess wieder aufgenommen oder abgebrochen werden.

Setzen Sie vor dem Start eines Debuggens mindestens einen Haltepunkt im Programmcode. Dafür machen Sie einen Doppelklick im grauen Bereich links von der Codezeile. Sie können auch einen Cursor auf die Zeile positionieren und auf die Schaltfläche Aktivieren/Deaktivieren eines Haltepunktes im Menü Debug oder mit F9. Haltepunkte werden auf die gleiche Weise wieder deaktiviert.

Wenn Sie zu dem Punkt springen müssen, an dem die Programmausführung gestoppt wurde, machen Sie einen Doppelklick auf die Funktion im Aufrufstapel des Ansichtsfensters. Außerdem können Sie über das Kontextmenü des Fensters die Liste aller Haltepunkte des aktuell debuggten Programms öffnen:

Sie können zu einem beliebigen Haltepunkt springen, indem Sie darauf einen Doppelklick machen.

Debugging starten #

Um zu debuggen, öffnen Sie die Hauptprogrammdatei oder ein Projekt. Debugging kann in zwei Modi durchgeführt werden:

• Mit echter Daten. Das Debugging wird gestartet durch mit dem Befehl Mit echten Daten beginnen im Menü Debug oder F5. In diesem Modus läuft das debuggte Programm auf einem eigenen Chart in der Handelsplattform. Das Debugging erfolgt unter realen Bedingungen mit Hilfe von Preisdaten, die vom Server kommen.
• Mit historischen Daten Das Debugging wird gestartet durch den Befehl mit historischen Daten beginnen Start im Menü Debug oder Strg+F5. Ein Programm in diesem Modus wird im Strategietester gestartet. Verwenden Sie ihn, um die Programmleistung in jedem gewünschten Zeitraum der Historie zu testen, ohne auf bestimmte Marktbedingungen zu warten. Der nicht-visuelle Testmodus wird standardmäßig verwendet, um zusätzlichen Ressourcenverbrauch für das Rendern von Grafikelementen zu vermeiden. Bei Bedarf können Sie den visuellen Modus in den MetaEditor-Einstellungen aktivieren.

Sobald die Programmausführung im Debugging-Modus einen Haltepunkt erreicht, wird sie angehalten. Die Zeile, bei der die Ausführung angehalten wird, ist gekennzeichnet mit dem Symbol Symbol. Der Reiter Debug erscheint ebenfalls im Fenster der Toolbox. Im linken Teil zeigt die Funktion den Aufrufstapel.

Beobachtete Ausdrücke #

Während des Debuggens können die Werte verschiedener Ausdrücke (Variablen) nach dem aktuellen Programmschritt kontrolliert werden. Im rechte Teil des Reiters Debug des Fensters der Toolbox zeigt die entsprechenden Ergebnisse an. Um die Ausdruckswerte zu verfolgen, fügen Sie sie zu den beobachteten hinzu:

• Stellen Sie während des Debuggens den Cursor auf einen Ausdruck im Quelltext und klicken Sie auf Watch im Kontextmenü hinzufügen.
• Tippen Sie auf Hinzufügen im Kontextmenü des rechten Teils des Reiters Debug. Geben Sie den Namen des Ausdrucks in der neu erscheinenden Zeile ein.
• Um den Namen des verfolgten Ausdrucks zu ändern, klicken Sie doppelt darauf.

Sie können auch die automatische Anzeige von lokalen Variablen in der Watchlist des Debuggers aktivieren. Die Anzeige kann über den Befehl "Lokal" im Kontextmenü aktiviert werden. Wenn die Debugger-Operation durch den Code fortschreitet, werden die Variablen des aktuellen Bereichs automatisch in der Liste angezeigt.

Im Fenster der Werte der Ausdrücke können Sie einfache mathematische Berechnungen (Addition, Subtraktion, Multiplikation und Division) durchführen sowie bestimmte Werte eines Arrays anzeigen, z.B. durch Angabe von A[3][4], wobei A ein Arrayname ist, während 3 und 4 die jew. Indices seiner Dimensionen sind. Beim Hinzufügen von Objekten zu beobachteten Ausdrücken können Sie die Liste ihrer Mitglieder anzeigen, indem wir am Ende einen Punkt angeben oder auf Strg+Leertaste klicken:

Um den Inhalt eines Arrays oder Objekts anzuzeigen, machen Sie darauf einen Doppelklick im Beobachtungsfenster.

Standardmäßig werden ganze Zahlen im Beobachtungsfenster in dezimaler Form angezeigt. Um den Wert in binärer oder hexadezimaler Form anzuzeigen, geben Sie den kommagetrennten b- oder x-Modifikator entsprechend im Feld Ausdruck an.

Anzeigen eines Aufrufstapels #

Daten zur Rückgabe der Steuerung aus Unterprogrammen (geschachtelte Funktionen) an das Programm (Hauptereignisbehandlung OnInit, OnTick, etc.) werden im Aufrufstapel angegeben. Der Stack erlaubt es, die gesamte Sequenz eines Ereignisses in der Handelsplattform bis zum Aufruf einer bestimmten Funktion zu verfolgen.

Zu jeder Funktion werden folgende Daten angezeigt:

• Dateiname, von dem aus die Funktion aufgerufen wird.
• Name der Funktion.
• Zeilennummer in der Datei, in der die Funktion aufgerufen wird.

Debuggen Schritt-für-Schritt

Debug Menü oder Standard Toolbar-Befehle werden für das schrittweise Debugging mit der Möglichkeit, den Aufrufstapel anzuzeigen, verwendet:

• Gehe zu – bewegt die Programmausführung in die aufgerufene Funktion. Die gleiche Aktion wird durch Drücken von F11. ausgeführt.
• Überspringe – überspringt die Präsentation der Funktion im Debugger bei der Programmausführung. Die gleiche Aktion wird durch Drücken von F10. erreicht.
• Trete aus – führt einen einzelnen Schritt eines Programms eine Ebene höher aus. Die gleiche Aktion wird durch Drücken von Shift+F11 erreicht.

Die Befehle für eine Schritt-für-Schritt Debugging können nur verwendet werden, nachdem das Programm im Debug-Modus angehalten wurde:

• Nachdem ein Haltepunkt ausgelöst wurde.
• Nachdem ein Programm manuell angehalten wurde durch einen Pause-Befehl im Menü Debug oder durch das Drücken von Break.

Pausieren, Fortsetzen und Beenden des Debuggens #

Das Programm wird während des Debuggens automatisch gestoppt, sobald die Ausführung einen Zeichenkette mit installiertem Haltepunkt erreicht. Das Debugging kann auch manuell gesteuert werden:

• Anhalten
  Programmausführung während des Debuggens kann manuell gestoppt werden mit dem Pause-Befehl im Debug-Menü oder Sie drücken Break. Nach dem Anhalten können Sie die Debugging-Befehle Schritt für Schritt anwenden.
• Fortsetzen
  Um die Programmausführung nach einer Pause fortzusetzen, klicken Sie auf Fortsetzen im Debug-Menü oder drücken Sie F5.
• Debugging beenden
  Um das Debugging zu beenden, klicken Sie auf Beenden im Debug-Menü oder drücken Sie Shift+F5. Das Programm wird aus dem speziellen Chart entfernt, auf dem es zum Debuggen gestartet wurde, und dann wird das Chart selbst geschlossen.

Fehlersuche in der Historie #

Neben Echtzeit-Kursdaten kann auch das Debugging von Handelsrobotern und technischen Indikatoren in der Historie durchgeführt werden. Jedes Programm kann mit den erforderlichen historischen Daten getestet werden, ohne auf bestimmte Handelsereignisse in Echtzeit warten zu müssen.

Das Debugging mit historischen Daten läuft im visuellen Testmodus im Strategietester. Eine Anwendung wird in einem Chart ausgeführt, das auf einer emulierten Sequenz von Ticks im Tester oder akkumulierten historischen Ticks (von einem Broker erhalten) basiert.

Um das Debugging mit der Historie zu starten, setzen Sie die Testparameter in MetaEditor Einstellungen.

Setzen Sie die Haltepunkte im Code und starten Sie das Debugging mit historischen Preisen.

Dadurch wird der visuelle Test und der Debugging-Prozess eingeleitet.