Marktsimulation: Positionsansicht (VIII)
Einleitung
Hallo, liebe Freunde! Herzlich willkommen zu einem weiteren Artikel unserer Reihe über Replikations- und Simulationssysteme.
Im vorherigen Artikel „Marktmodellierung: Positionsansicht (VII)“ haben wir untersucht, wie man einen Positionsindikator implementiert, mit dem man eine offene Position direkt aus dem Chart heraus schließen kann, indem man mit einem im Chart verfügbaren Objekt interagiert. Nachdem wir den ersten Mechanismus fertiggestellt und getestet hatten, begannen wir mit den Änderungen, die nötig waren, um Take-Profit- und Stop-Loss-Niveaus einer offenen Position entfernen zu können. Da die erforderlichen Änderungen jedoch ausführliche Erläuterungen erforderten, habe ich in demselben Artikel nur die Änderungen am Expert Advisor gezeigt; die nötigen Änderungen am Positionsindikator musste ich noch erläutern.
Die Änderungen am Code selbst sind relativ geringfügig. Als ich mir jedoch das Publikum ansah, das Interesse an diesem Replikations-/Simulationssystem gezeigt hatte, fiel mir auf, dass viele – wenn nicht sogar die überwiegende Mehrheit – nicht viel Erfahrung mit dem Programmieren hatten, geschweige denn mit der Art von Programmierung, die ich unterrichte und verwende. Daher ist meiner Meinung nach eine etwas ausführlichere Erklärung erforderlich, damit jeder den Code verstehen und ihn, falls gewünscht, zur Lösung spezifischer Probleme anpassen kann. Der gesamte hier vorgestellte Code dient ausschließlich zu Bildungszwecken. Versuchen Sie also, sowohl den Code selbst als auch die Erläuterungen, die ich dazu geben werde, genau zu prüfen, denn jetzt geht es richtig zur Sache.
Anpassung des Positionsindikators
Da ich in diesem Artikel noch etwas mehr behandeln möchte, schauen wir uns zunächst noch einmal an, was im vorherigen Beitrag offen geblieben ist. Wir fahren also direkt mit der Klasse „C_IndicatorPosition“ fort, deren neuer Code im Folgenden dargestellt ist.
01. //+------------------------------------------------------------------+ 02. #property copyright "Daniel Jose" 03. //+------------------------------------------------------------------+ 04. #include "C_ElementsTrade.mqh" 05. //+------------------------------------------------------------------+ 06. class C_IndicatorPosition 07. { 08. private : 09. struct st00 10. { 11. ulong ticket; 12. color corPrice, corTake, corStop; 13. string szShortName; 14. }m_Infos; 15. C_ElementsTrade *Open, 16. *Stop, 17. *Take; 18. //+------------------------------------------------------------------+ 19. public : 20. //+------------------------------------------------------------------+ 21. C_IndicatorPosition(color corPrice, color corTake, color corStop) 22. { 23. ZeroMemory(m_Infos); 24. m_Infos.corPrice = corPrice; 25. m_Infos.corTake = corTake; 26. m_Infos.corStop = corStop; 27. Open = Take = Stop = NULL; 28. } 29. //+------------------------------------------------------------------+ 30. ~C_IndicatorPosition() 31. { 32. delete Open; 33. delete Take; 34. delete Stop; 35. } 36. //+------------------------------------------------------------------+ 37. bool CheckCatch(ulong ticket) 38. { 39. m_Infos.szShortName = StringFormat("%I64u", m_Infos.ticket = ticket); 40. if (!PositionSelectByTicket(m_Infos.ticket)) return false; 41. if (ObjectFind(0, m_Infos.szShortName) >= 0) 42. { 43. m_Infos.ticket = 0; 44. return false; 45. } 46. IndicatorSetString(INDICATOR_SHORTNAME, m_Infos.szShortName); 47. EventChartCustom(0, evUpdate_Position, ticket, 0, ""); 48. 49. return true; 50. } 51. //+------------------------------------------------------------------+ 52. void DispatchMessage(const int id, const long &lparam, const double &dparam, const string &sparam) 53. { 54. double value; 55. 56. if (Open != NULL) (*Open).DispatchMessage(id, lparam, dparam, sparam); 57. if (Take != NULL) (*Take).DispatchMessage(id, lparam, dparam, sparam); 58. if (Stop != NULL) (*Stop).DispatchMessage(id, lparam, dparam, sparam); 59. switch (id) 60. { 61. case CHARTEVENT_CUSTOM + evUpdate_Position: 62. if (lparam != m_Infos.ticket) return; 63. if (!PositionSelectByTicket(m_Infos.ticket)) 64. { 65. ChartIndicatorDelete(0, 0, m_Infos.szShortName); 66. return; 67. }; 68. if (Open == NULL) Open = new C_ElementsTrade(m_Infos.ticket, evMsgClosePositionEA, m_Infos.corPrice, ePriorityNull, "Position opening price."); 69. if (Take == NULL) Take = new C_ElementsTrade(m_Infos.ticket, evMsgCloseTakeProfit, m_Infos.corTake, ePriorityOrders, "Take Profit point."); 70. if (Stop == NULL) Stop = new C_ElementsTrade(m_Infos.ticket, evMsgCloseStopLoss, m_Infos.corStop, (EnumPriority)(ePriorityOrders + 1), "Stop Loss point."); 71. (*Open).UpdatePrice(PositionGetDouble(POSITION_PRICE_OPEN)); 72. if ((value = PositionGetDouble(POSITION_TP)) > 0) (*Take).UpdatePrice(value); else 73. { 74. delete Take; 75. Take = NULL; 76. } 77. if ((value = PositionGetDouble(POSITION_SL)) > 0) (*Stop).UpdatePrice(value); else 78. { 79. delete Stop; 80. Stop = NULL; 81. } 82. break; 83. } 84. ChartRedraw(); 85. } 86. //+------------------------------------------------------------------+ 87. }; 88. //+------------------------------------------------------------------+
C_IndicatorPosition.mqh
Nun, wahrscheinlich verstehen Sie überhaupt nicht, was hier passiert ist, denn der Code hat sich buchstäblich über Nacht ziemlich drastisch verändert. Diese Änderung wurde bewusst und zum richtigen Zeitpunkt vorgenommen. Der Grund dafür ist, dass wir beginnen müssen, Teile des Codes voneinander zu entkoppeln, damit wir später bei der Entwicklung des Moduls für Pending Orders nicht viel neuen Code schreiben müssen und der Code nicht so stark verflochten wird, dass sich wiederverwendbare Teile nur schwer herauslösen lassen. Also, lieber Leser, lassen Sie sich nicht beunruhigen oder verunsichern, wenn sich Veränderungen ergeben. Diese Änderungen erfolgen, während wir die Teile des Codes ausgliedern, die sich künftig wiederverwenden lassen.
Gut – wenn Sie sich den obigen Code ansehen, werden Sie in Zeile 04 sofort feststellen, dass wir eine neue Headerdatei eingebunden haben. Darauf werden wir gegen Ende dieses Artikels eingehen. Machen Sie sich darüber vorerst keine Gedanken. Konzentrieren wir uns auf diese Datei. Daher deklarieren wir in Zeile 15 drei Zeiger auf Instanzen der Klasse C_ElementsTrade. Diese Zeiger ermöglichen uns einen kontrollierten Zugriff auf Instanzen der Klasse C_ElementsTrade.
C_ElementsTrade. Beachten Sie Folgendes: Ich verwende drei Zeiger, da wir alle in der Klasse C_ElementsTrade erstellen, was für die korrekte Darstellung des Positionsindikators erforderlich ist. Da die angezeigten Indikatoren mehrere gemeinsame Komponenten haben werden – etwa die Schaltfläche zum Schließen, die Linie zur Anzeige des Kursniveaus und weitere Elemente, die wir später hinzufügen werden –, können wir zur Vereinfachung alles in einer einzigen Klasse zusammenfassen. Und wenn wir auf die Klasse verweisen, die diese grafischen Elemente erstellt, können wir dieselbe Struktur problemlos in verschiedenen Darstellungsvarianten wiederverwenden. Oder besser gesagt: Wir können dieselben visuellen Elemente sowohl für den Stop-Loss- als auch für den Take-Profit-Indikator wiederverwenden – vorausgesetzt natürlich, dass wir im Code eine klare Unterscheidung treffen, damit der Trader leicht erkennen kann, um welchen Indikator es sich jeweils handelt. Wir müssen also nicht eigens eine Klasse für das Festlegen eines Stop-Loss und eine weitere für das Festlegen eines Take-Profit programmieren. Ich bin mir nicht sicher, ob meine Erklärung verständlich war. Aber sobald Sie mehr vom Code sehen, werden Sie verstehen, was hier vor sich geht.
Nun initialisiert der Compiler Variablen in der Regel mit einem geeigneten Wert. Da wir uns dessen jedoch sicher sein wollen, initialisieren wir sie im Konstruktor. Dies geschieht in Zeile 27, wo wir festlegen, dass die Zeiger mit NULL initialisiert werden. Bitte achten Sie besonders auf dieses Detail, denn es ist wichtig, dass Sie es kennen. Beachten Sie außerdem, dass wir im Destruktor den Speicher freigeben, auf den die Zeiger verweisen, und ihn damit an das System zurückgeben. Dies geschieht zwischen den Zeilen 32 und 34. Aber an dieser Stelle fragen Sie sich vielleicht: „Warum den Befehl delete verwenden, wenn wir noch keinen Speicher mit dem Befehl new zugewiesen haben?“ „Das ergibt doch keinen Sinn.“ Tatsächlich ergibt es auf den ersten Blick keinen Sinn. Zeigervariablen sollten Sie jedoch nicht außer Acht lassen. Sehr oft tritt irgendwann während der Ausführung eines Programms ein Fehler auf. Das liegt daran, dass das Programm eine Operation durchgeführt hat, bei der Zeiger eine Rolle spielten. Und da unsere Zeiger in der Klasse C_IndicatorPosition deklariert werden, müssen wir sicherstellen, dass der Speicher korrekt freigegeben wird, wenn ein Objekt dieser Klasse zerstört wird.
In Ordnung. Das war eine einleitende Erklärung. Schauen wir uns nun an, an welchen Stellen weitere Änderungen am Quellcode vorgenommen wurden. Gehen wir also direkt zu Zeile 52 über, wo sich die Implementierung der Prozedur „DispatchMessage“ befindet. Wenn Sie an dieser Stelle nicht genau aufpassen, werden Sie verwirrt sein, denn genau hier kommt die Magie ins Spiel. Beachten Sie, dass der übrige Code praktisch unverändert bleibt. Die Prozedur in Zeile 52 enthält einige Elemente, die Sie, lieber Leser, möglicherweise verwirren könnten. Das Erste, was möglicherweise für große Verwirrung sorgen könnte, ist der Code, der zwischen den Zeilen 56 und 58 erscheint. Warum führe ich diese Prüfungen durch, bevor ich für jedes der Elemente, die wir dem Chart hinzufügen werden, die Prozedur DispatchMessage aufrufe? Der Grund dafür ist ganz einfach. Beim ersten Aufruf dieser Prozedur in Zeile 52 gilt: WIR HABEN KEINE ELEMENTE AUF DEM CHART. Wenn wir also nicht überprüfen, ob die Zeiger tatsächlich auf etwas Gültiges im Speicher verweisen, laufen wir Gefahr, ungültige Zeiger zu dereferenzieren. Da MQL5 jedoch offenbar über einen Sicherheitsmechanismus verfügt, führt der Versuch, „Schrottcode“ auszuführen, zu einem Fehler, wodurch der Indikator zwangsweise aus dem Chart entfernt wird. „Na gut, ich hab’s verstanden. Müssen wir diese Überprüfung nicht ständig durchführen?“ Das stimmt; sie muss jedes Mal durchgeführt werden, wenn die in Zeile 52 beschriebene Prozedur ausgeführt wird. Sie werden bald herausfinden, warum. Kommen wir nun zum nächsten Abschnitt, in dem wir uns mit der Behandlung des Ereignisses befassen, auf das diese Prozedur wartet. Die Verarbeitung dieses Ereignisses beginnt in Zeile 61. Passen Sie jetzt besonders gut auf, denn als Erstes prüfen wir in Zeile 62, ob der Wert des Parameters „lparam“ mit dem Ticket übereinstimmt, das der Indikator verfolgt. Wenn die Werte voneinander abweichen, brechen wir die Verarbeitung an dieser Stelle ab. Wenn sie übereinstimmen, prüfen wir in Zeile 63, ob diese Position auf dem Server vorhanden ist. Falls sie nicht mehr vorhanden ist, entfernen wir in Zeile 65 den Positionsindikator aus dem Chart und schließen in Zeile 66 die Verarbeitung der Nachricht ab. Sind diese ersten Prüfungen erfolgreich, wird in Zeile 68 geprüft, ob das Objekt, das den Eröffnungskurs darstellt, bereits angelegt wurde. Diese Prüfung ergibt nur beim ersten Aufruf „true“. In allen anderen Fällen ergibt sie „false“. Da dies der erste Aufruf ist, verwenden wir den new-Operator, um den Konstruktor aufzurufen. Es ist wichtig, dass Sie das verstehen. Der Grund dafür ist, dass man den Konstruktor anweisen kann, eine bestimmte Struktur für die Elemente zu erstellen. Daher können Sie mithilfe derselben Klasse einen Indikator für den Take-Profit, einen weiteren für den Stop-Loss und noch einen für den Eröffnungskurs erstellen. Genau das tun wir zwischen den Zeilen 68 und 70. Bitte beachten Sie, dass wir die Zeiger in jedem Fall initialisieren, mit Ausnahme derjenigen, die bereits initialisiert wurden. Wir können dieses System weiter verbessern, um unnötige Aufrufe zu vermeiden. Aber darauf kommen wir später noch zurück. Zunächst einmal ist es wichtig, dass Sie verstehen, wie das Ganze funktioniert.
Nachdem wir in den Zeilen 68 und 70 alle drei Zeiger initialisiert haben, weisen wir in Zeile 71 die Klasse „C_ElementsTrade“ – auf die der Zeiger „OPEN“ verweist – an, den Kurs zu aktualisieren. Du denkst vielleicht, dass das albern ist und wir das einfach direkt im Konstruktor machen könnten. Eigentlich könnten wir das schon. Natürlich nur, sofern wir sicher wären, dass es sich um ein Hedging-Konto handelt. Das liegt daran, dass bei Verwendung eines Netting-Kontos der Kurs abweichen kann, da der Server uns einen Wert liefert, der dem Durchschnittskurs der Position entspricht. Deshalb übergebe ich den Wert nicht direkt an den Konstruktor der Klasse C_ElementsTrade. In Zukunft werden wir das anders machen. Verliere nicht die Hoffnung, lieber Leser. Gehen wir es Schritt für Schritt an. Mache dich zunächst mit diesem einfacheren Code vertraut, damit du später den komplexeren Code verstehen kannst.
In Ordnung. Nun kommen wir zu einem wirklich interessanten Teil dieser „DispatchMessage“-Prozedur. Was ich hier erkläre, gilt auch für den Code in den Zeilen 77–81. Das ist nicht schwer. Passen Sie einfach gut auf, dann werden Sie ganz leicht verstehen, was hier vor sich geht. Zunächst rufen wir den benötigten Wert ab und weisen ihn der Variablen value zu. Als Nächstes prüfen wir, ob dieser Wert größer als null ist. Wenn das der Fall ist, gibt es ein Schutzniveau – sei es ein Take-Profit oder ein Stop-Loss. In jedem Fall werden wir den Wert, sofern er vorhanden ist, an das entsprechende C_ElementsTrade-Objekt übergeben. Mit anderen Worten: Wir werden etwas Ähnliches tun wie in Zeile 71. Allerdings gibt es bei der Aktualisierung des Eröffnungskurses einige Feinheiten zu beachten. Ist der zu prüfende Wert null, bedeutet dies, dass das entsprechende vorgesehene Niveau nicht festgelegt wurde. Daher sollten die Elemente, die den Kurs darstellen, aus dem Chart entfernt werden. Vielleicht hätten Sie erwartet, dies hier in der Klasse „C_IndicatorPosition“ zu finden. Bei näherer Betrachtung des Codes scheint es jedoch so, als gäbe es keine Stelle, an der Objekte aus dem Chart entfernt werden. Doch, diese Stelle gibt es hier tatsächlich. Das tun wir in Zeile 74, da wir dort den entsprechenden Destruktor aufrufen. Da die Ausführung des Befehls delete den Zeiger nicht auf NULL setzt, sondern lediglich den belegten Speicher freigibt, müssen wir ihn explizit auf NULL setzen und damit zu einem Nullzeiger machen. Dies geschieht in Zeile 75. Bitte beachten Sie dies. Die Adresse, auf die der Zeiger verweist, kann „Müll“ enthalten. Da der Code prüfen muss, ob der Wert des Zeigers null ist oder nicht, müssen wir ihn explizit auf null setzen. Nicht, weil man das immer so machen sollte, sondern weil die Ausführung des Codes an dieser Stelle noch nicht endet und der Zeiger bei den Prüfungen in den Zeilen 56 bis 58 möglicherweise auf „Müll“ zeigt. Dies führt zu einer Fehlfunktion des Codes, sobald Sie das entsprechende Schutzniveau auf dem Server entfernen, unabhängig davon, ob es sich um einen Stop-Loss- oder einen Take-Profit-Wert handelt.
Super. Bisher habe ich mich ausschließlich darauf konzentriert, den Teil des Codes zu erläutern, der sich auf die Klasse „C_IndicatorPosition“ bezieht. Die Erklärung ist erst vollständig, wenn wir uns die Klasse „C_ElementsTrade“ ansehen. Diese Klasse erledigt die ganze Arbeit für uns. Um für eine übersichtliche Gliederung zu sorgen, werden wir dieses Thema in einem neuen Abschnitt behandeln.
Einstieg in die Klasse „C_ElementsTrade“
Nun, alles, was wir bisher behandelt haben, mag vielen Menschen kompliziert und verwirrend erscheinen. Wenn das auf Sie zutrifft, verlieren Sie nicht die Hoffnung. Gehen Sie ein paar Artikel zurück und arbeiten Sie alles in einem gemächlicheren Tempo durch, da ich versuche, den Stoff so einfach und verständlich wie möglich darzustellen. Mir ist bewusst, dass vieles von dem, was ich hier zeige, äußerst kompliziert und schwer verständlich wirkt. Das liegt daran, dass Sie nicht damit gerechnet haben, dass das, was hier gezeigt wird, tatsächlich möglich ist, da praktisch noch niemand zuvor so etwas demonstriert hat.
Wie dem auch sei, machen wir weiter. Nun werden wir uns den neuen Code ansehen, mit dem wir noch ziemlich viel arbeiten werden. Von nun an werden Sie nicht mehr so oft Änderungen an dem Code sehen, über den wir zuvor gesprochen haben. Von nun an werden wir uns speziell auf diese Ebene konzentrieren. In Ordnung. Die neue Klasse, die wir erstellen werden, ist im Folgenden zusammen mit ihrem vollständigen Code dargestellt:
01. //+------------------------------------------------------------------+ 02. #property copyright "Daniel Jose" 03. //+------------------------------------------------------------------+ 04. #define def_NameHLine m_Info.szPrefixName + "#HLINE" 05. #define def_NameBtnClose m_Info.szPrefixName + "#CLOSE" 06. //+------------------------------------------------------------------+ 07. #define def_PathBtns "Images\\Market Replay\\Orders\\" 08. #define def_Btn_Close def_PathBtns + "Btn_Close.bmp" 09. #resource "\\" + def_Btn_Close; 10. //+------------------------------------------------------------------+ 11. #include "..\Auxiliar\C_Terminal.mqh" 12. //+------------------------------------------------------------------+ 13. class C_ElementsTrade : private C_Terminal 14. { 15. private : 16. //+------------------------------------------------------------------+ 17. struct st00 18. { 19. ulong ticket; 20. string szPrefixName; 21. EnumEvents ev; 22. double price; 23. }m_Info; 24. //+------------------------------------------------------------------+ 25. void UpdateViewPort(void) 26. { 27. int x, y; 28. 29. ChartTimePriceToXY(0, 0, 0, m_Info.price, x, y); 30. ObjectSetDouble(0, def_NameHLine, OBJPROP_PRICE, m_Info.price); 31. ObjectSetInteger(0, def_NameBtnClose, OBJPROP_XDISTANCE, 130); 32. ObjectSetInteger(0, def_NameBtnClose, OBJPROP_YDISTANCE, y); 33. } 34. //+------------------------------------------------------------------+ 35. public : 36. //+------------------------------------------------------------------+ 37. C_ElementsTrade(const ulong ticket, const EnumEvents ev, color _color, EnumPriority ePrio, string szDescr = "\n") 38. :C_Terminal() 39. { 40. string szObj; 41. 42. ZeroMemory(m_Info); 43. m_Info.szPrefixName = StringFormat("%I64u@%d", m_Info.ticket = ticket, (int)(m_Info.ev = ev)); 44. CreateObjectGraphics(szObj = def_NameHLine, OBJ_HLINE, _color, ePrio); 45. ObjectSetString(0, szObj, OBJPROP_TEXT, szDescr); 46. ObjectSetString(0, szObj, OBJPROP_TOOLTIP, szDescr); 47. ObjectSetInteger(0, szObj, OBJPROP_SELECTABLE, ePrio != ePriorityNull); 48. CreateObjectGraphics(szObj = def_NameBtnClose, OBJ_BITMAP_LABEL, clrNONE, (EnumPriority)(ePriorityOrders + 1)); 49. ObjectSetString(0, szObj, OBJPROP_BMPFILE, 0, "::" + def_Btn_Close); 50. ObjectSetInteger(0, szObj, OBJPROP_ANCHOR, ANCHOR_CENTER); 51. } 52. //+------------------------------------------------------------------+ 53. ~C_ElementsTrade() 54. { 55. if (m_Info.szPrefixName != "") 56. ObjectsDeleteAll(0, m_Info.szPrefixName); 57. } 58. //+------------------------------------------------------------------+ 59. inline void UpdatePrice(const double price) 60. { 61. m_Info.price = price; 62. UpdateViewPort(); 63. } 64. //+------------------------------------------------------------------+ 65. void DispatchMessage(const int id, const long &lparam, const double &dparam, const string &sparam) 66. { 67. switch (id) 68. { 69. case CHARTEVENT_OBJECT_CLICK: 70. if (sparam == def_NameBtnClose) 71. { 72. if (PositionSelectByTicket(m_Info.ticket)) switch (m_Info.ev) 73. { 74. case evMsgClosePositionEA: 75. EventChartCustom(0, evMsgClosePositionEA, m_Info.ticket, 0, ""); 76. break; 77. case evMsgCloseTakeProfit: 78. EventChartCustom(0, evMsgCloseTakeProfit, m_Info.ticket, PositionGetDouble(POSITION_SL), PositionGetString(POSITION_SYMBOL)); 79. break; 80. case evMsgCloseStopLoss: 81. EventChartCustom(0, evMsgCloseStopLoss, m_Info.ticket, PositionGetDouble(POSITION_TP), PositionGetString(POSITION_SYMBOL)); 82. break; 83. }; 84. } 85. break; 86. case CHARTEVENT_CHART_CHANGE: 87. UpdateViewPort(); 88. break; 89. } 90. } 91. //+------------------------------------------------------------------+ 92. }; 93. //+------------------------------------------------------------------+ 94. #undef def_Btn_Close 95. #undef def_PathBtns 96. //+------------------------------------------------------------------+ 97. #undef def_NameBtnClose 98. #undef def_NameHLine 99. //+------------------------------------------------------------------+
C_ElementsTrade.mqh
Nun ist das Thema wirklich komplizierter geworden, da viele vielleicht einen wesentlich umfangreicheren Code erwartet hätten, der viel mehr Informationen oder eine größere Anzahl von funktionsfähigen Elementen enthält. Wenn man sich den obigen Code ansieht, wird deutlich, dass der Vorgang ganz anders abläuft, als viele erwartet hatten. Schauen wir mal, was hier los ist. Und zuallererst: Schauen wir uns einmal an, warum dieser Code das leisten kann, was er verspricht – nämlich einem Trader zu ermöglichen, mithilfe eines grafischen Elements in Form einer Schaltfläche auf der Kurslinie eine Position zu schließen oder das entsprechende Niveau zu entfernen. In diesem Fall geht es um Stop-Loss- und Take-Profit-Niveaus. Gleichzeitig können wir dadurch eine offene Position schließen. All dies wird auf recht einfache und elegante Weise dargestellt.
Nun, wenn Sie bis hierher gelesen haben, bedeutet das, dass Sie wirklich neugierig sind und verstehen möchten, wie dieser Mechanismus funktioniert. Fangen wir also damit an: Vergessen Sie all die Verwirrung rund um die endlose Vergabe von Namen für grafische Objekte. Das macht unsere Arbeit nur unnötig kompliziert. Versuchen Sie, stets eine einfache und effektive Namenskonvention zu verwenden. Zweitens: Versuchen Sie nicht, das, was sich auf dem Chart befindet, zu kontrollieren oder zu manipulieren. Überlassen Sie das doch einfach MetaTrader 5. In dieser Implementierung werden wir keine Listen von Objekten oder Strukturen dieser Art verwenden. Wir werden die Objekte einfach ordnungsgemäß erstellen und MetaTrader 5 sie so gut wie möglich verwalten lassen, wobei die Liste der Objekte im Chart unter der Kontrolle des MetaTrader-5-Terminals selbst bleibt.
Nur eine kurze Anmerkung zu dem, was ich gerade gesagt habe: MetaTrader 5 ist kein Wundermittel. Bei unsachgemäßer Verwendung funktioniert es nicht ordnungsgemäß. Sie müssen MetaTrader 5 verstehen, um alle seine Funktionen wirklich nutzen zu können. Das Erste, was uns also im vorstehenden Code auffällt, sind tatsächlich mehrere Makrodefinitionen. Bitte beachten Sie, dass die Zeilen 04 und 05 zwei Definitionen enthalten, die ausschließlich in dieser Headerdatei verwendet werden. Ich sage „nur“, weil wir in den Zeilen 97 und 98 genau diese Definitionen entfernt haben. Wenn Sie versuchen, sie außerhalb dieser Datei zu verwenden, gibt der Compiler Fehlermeldungen aus, und der Code lässt sich nicht kompilieren. Gut, schauen wir uns einmal an, was in diesen beiden Definitionen steht. Wir haben eine Variable, auf die wir später noch eingehen werden, und eine Zeichenkette. Das ist alles – mehr nicht. Das reicht MetaTrader 5 völlig aus, um diese Daten für uns zu verarbeiten und die Objekte, die wir in diesem Code erstellt haben, in einer internen Liste zu speichern. Wir brauchen dafür keine separate Liste; MetaTrader 5 soll die Liste der Objekte selbst verwalten.
Die Zeilen 7 bis 9 wurden bereits behandelt und bedürfen keiner gesonderten Erwähnung. Als Nächstes können wir uns den Klassencode ansehen und feststellen, dass es hier nur wenige Prozeduren und Funktionen gibt. Wir fangen gerade erst damit an, diesen Code zu schreiben. Überstürzen wir nichts. Wenn man eine Klasse untersucht, sollte man sich als Erstes die Prozeduren zum Erzeugen und Zerstören ihrer Instanzen ansehen. Das sind der Konstruktor und der Destruktor. In Zeile 37 finden wir also die Deklaration des Klassenkonstruktors. Nun möchte ich, dass Sie zum vorherigen Thema zurückkehren und sich ansehen, was jeder dieser Parameter im Zusammenhang mit dem zuvor Erläuterten bedeutet. Beachten Sie, dass der Code für diesen Konstruktor recht einfach ist. Wir erstellen lediglich Objekte, die im Chart angezeigt werden. Im Grunde nehme ich den Code, der zuvor in der Klasse „C_IndicatorPosition“ vorhanden war, und kopiere ihn hierher. Das ist ganz einfach. Im Gegensatz zum vorherigen Beispiel, bei dem nur eine horizontale Linie erstellt wurde, haben wir in diesem Fall zwei Objekte erstellt. Eines davon ist die in Zeile 44 des Codes erstellte Linie. Das zweite ist die Interaktionsschaltfläche. Sie wird in Zeile 48 des Codes erstellt. Nun sind wir an dem Punkt angelangt, an dem die Definitionen in den Zeilen 04 und 05 Sinn ergeben. Bitte beachten Sie, dass ich in Zeile 43 derselben Variablen, die bereits in den Definitionen verwendet wurde, einen Wert zuweise. Mit anderen Worten: Wir verwenden diese Definitionen, um MetaTrader 5 mitzuteilen: Ich möchte etwas an einem bestimmten Objekt ändern, oder ich möchte, dass du mich benachrichtigst, wenn dieses Objekt ein Ereignis erhalten hat. MetaTrader 5 wird unsere Anfrage verstehen und entsprechend reagieren, indem es genau die gewünschte Aktion ausführt. Daher benötigen wir keine zusätzliche Liste von Objekten. MetaTrader 5 wird die Verwaltung dieser Struktur übernehmen. Und das ist großartig, denn so müssen wir einen Großteil der Arbeit nicht von Hand erledigen. Bevor wir jedoch zum Destruktor übergehen, möchte ich Sie auf ein Detail hinweisen. Erinnern Sie sich noch daran, dass wir beim Positionieren der Interaktionsschaltfläche deren Lage anpassen mussten, indem wir einen bestimmten Wert abgezogen haben? Nun, wie ich damals schon gesagt habe: Wir haben eine bessere Lösung. Richtig ist es, Zeile 50 zu verwenden. Aber es gibt einen Haken: Mit dieser Codezeile wird die Schaltfläche an der von uns festgelegten Stelle positioniert. Wir werden dieses Thema in Zukunft noch ausführlicher erörtern. Bitte beachten Sie vorerst, dass wir diese Anpassung nicht mehr vornehmen müssen.
In Ordnung. So wie der Konstruktor dem bisherigen Stand entspricht, gilt dies auch für den Destruktor in Zeile 53. Ich werde das nicht besonders hervorheben; ich erwähne es nur.
Beachten Sie, dass wir zusätzlich zu den bereits besprochenen noch drei weitere Prozeduren haben. Dabei würden auch zwei davon ausreichen. Aus praktischen Gründen habe ich beschlossen, die Implementierung in drei Prozeduren aufzuteilen. Die Prozedur in Zeile 59 ist eine einfache Prozedur; sie übergibt die Ausführung lediglich an die Prozedur in Zeile 25. Auch diese Prozedur ist recht einfach. Ihr einziger Zweck besteht darin, Objekte im Chart an den richtigen Stellen darzustellen. Dies bedarf keiner gesonderten Erwähnung, da wir bereits seit geraumer Zeit über diese Objekte sprechen. Allerdings verdient die Prozedur in Zeile 65 wirklich eine besondere Erwähnung, denn ohne sie würde nichts von dem, was Sie im Chart sehen, tatsächlich passieren. Nehmen wir uns einen Moment Zeit, um diese Prozedur in Ruhe durchzugehen.
In der Methode DispatchMessage – dem Kern dieser Klasse – behandeln wir gleich zu Beginn zwei Ereignisse. Zum einen handelt es sich um einen Klick auf Objekte, zum anderen um ein Ereignis zur Aktualisierung eines Charts. Nun, das Aktualisierungsereignis in Zeile 86 ist einfach und unkompliziert. Es positioniert lediglich Elemente oder Objekte im Chart – etwas, das wir bereits zuvor getan haben. Die Behandlung eines Klick-Ereignisses ist jedoch etwas komplizierter als in der vorherigen Version. Keine Sorge – es ist nur ein bisschen komplizierter, aber das ist nichts Ungewöhnliches.
Beachten Sie, dass wir bei der Ausführung von Zeile 69 zunächst prüfen, ob das von MetaTrader 5 übergebene Objekt mit dem Objekt übereinstimmt, das wir verarbeiten möchten. Mit anderen Worten: ein Objekt vom Typ CLOSE. Noch einmal: Denken Sie nicht in starren Mustern. Jede Instanz der Klasse „C_ElementsTrade“ entspricht genau einem der Datenelemente, die wir anzeigen müssen. Mit anderen Worten: Wir müssen nicht wissen, ob das CLOSE-Objekt dem Take-Profit-Niveau, dem Stop-Loss-Niveau oder dem Eröffnungskurs entspricht. Das spielt eigentlich keine Rolle. Das Wichtigste ist, dass das Objekt vom Typ CLOSE ist. Das ist alles; worauf sich dieses Objekt genau bezieht, klären wir später.
Wenn also die Prüfung des Objekts positiv ausfällt, führen wir in Zeile 72 eine weitere Prüfung durch. Bei dieser Überprüfung stellen wir fest, ob das in der Klasse gespeicherte Ticket einer bestehenden Position entspricht. Diese Überprüfung ist wichtig, damit wir zwischen Orders und Positionen unterscheiden können. Auch wenn wir uns noch nicht mit Orders befasst haben, legen wir bereits jetzt die Grundlagen, damit wir bei deren Implementierung keine größeren Änderungen am Code vornehmen müssen. Wenn auch diese weitere Prüfung positiv ausfällt, gelangen wir zu einem kleinen Mechanismus. Er wird das tun, was viele am Anfang des Codes erwarten würden.
Hier prüfen wir, welches konkrete Element das Klickereignis empfangen hat. Wie ist das möglich? Wird uns MetaTrader 5 darüber nicht informieren? In gewisser Weise zeigt MetaTrader 5 dies korrekt an. Da ich auf einfache Weise erklären möchte, wie das funktioniert, verfolgen wir einen anderen Ansatz. Auf diese Weise werden Sie später herausfinden können, wie Sie Ihre Arbeit viel durchdachter gestalten können. Auf jeden Fall ist der Grundgedanke derselbe. Die aktuelle Klasse enthält einen Wert, der bei der Erstellung des Objekts festgelegt wird. Mit anderen Worten: Schauen Sie sich den Code des Konstruktors noch einmal an und beachten Sie, dass wir in Zeile 43 denselben Wert speichern, der hier zwischen den Zeilen 73 und 83 überprüft wird.
Hier kommt der spannende Teil. Wenn Sie in der Klasse C_IndicatorPosition festlegen, dass die Klasse C_ElementsTrade Elemente oder grafische Objekte zur Darstellung von Take-Profit-Niveaus erstellen soll, unterscheiden Sie damit zwischen den Objektgruppen, die erstellt werden. Diese Unterteilung wird in Zeile 43 festgelegt, jedoch nur zwischen den Zeilen 73 und 83 verwendet.
Bitte beachten Sie Folgendes: Wenn sich die in der Klasse C_IndicatorPosition neu erstellte Objektgruppe auf einen Stop-Loss bezieht, wird beim Klicken auf die Stop-Loss-Interaktionsschaltfläche tatsächlich der Code in Zeile 81 ausgeführt. Dabei wird eine Nachricht an den Expert Advisor gesendet, die ihm Folgendes mitteilt: „Hör mal, Expert Advisor, ich möchte, dass der Stop-Loss-Wert entfernt wird.“ Der Expert Advisor sendet daraufhin eine Anfrage an den Server, um diese Aufgabe auszuführen. Sobald der Server antwortet und mitteilt, ob die Anfrage angenommen wurde oder nicht, sendet der Expert Advisor eine Nachricht an den Chart und informiert alle darüber, dass ein Ereignis eingetreten ist. Der Positionsindikator wartet auf dieses Ereignis. Und in der Klasse „C_IndicatorPosition“ wird die mit dem Stop-Loss verknüpfte Instanz von „C_ElementsTrade“ freigegeben. Somit werden alle mit dieser Instanz verknüpften Objekte gelöscht. Der Klassen-Destruktor weist MetaTrader 5 an, die Objekte, die mit diesem Namenspräfix verknüpft sind, aus dem Chart zu entfernen.
Deshalb habe ich zu Beginn dieses Artikels gesagt, dass man sich über bestimmte Implementierungsdetails keine Gedanken machen muss. Wenn Sie die richtigen Schritte befolgen, unterstützt Sie MetaTrader 5 bei der Erledigung der erforderlichen Aufgaben.
Abschließende Gedanken
In diesem Artikel haben wir begonnen, einige der Einzelheiten genauer unter die Lupe zu nehmen. Da ich alles erklären und den Stoff so verständlich wie möglich gestalten möchte, mag es vielen so vorkommen, als kämen wir nur langsam voran. Aber wenn ich wirklich das Tempo vorgeben würde, das ich für angemessen halte, würden am Ende nur sehr wenige Menschen verstehen, was eigentlich vor sich geht. Von diesen wenigen wären noch weniger in der Lage, den Code so anzupassen, dass er ihren spezifischen Zielen entspricht. Wenn Sie also bereits über fundierte Programmierkenntnisse verfügen, haben Sie bitte etwas Geduld mit denen, die gerade erst anfangen.
Für alle, die das System testen möchten, habe ich die erforderlichen Dateien als kompilierte Binärdateien im Anhang beigefügt. Um sicherzustellen, dass der gesamte Prozess ordnungsgemäß abläuft, ändern Sie bitte nicht die in der Anwendung vorgegebene Verzeichnisstruktur. Entpacken Sie einfach die Dateien und testen Sie das System. Verwenden Sie dazu den „Mouse Study“-Indikator, den „Chart Trade“-Indikator und den Expert Advisor. Sie müssen diese drei Anwendungen auf dem Chart platzieren. Der Positionsindikator wird bei Bedarf automatisch geladen.
Und noch eine letzte Sache. Selbst wenn Sie sich dafür entscheiden, nur den Expert Advisor und den Ein-Klick-Handel von MetaTrader 5 zu nutzen, erhalten Sie dasselbe Ergebnis wie bei drei auf dem Chart geladenen Komponenten. Dennoch empfehle ich Ihnen, sich schon einmal an die gemeinsame Nutzung aller drei Anwendungen zu gewöhnen. Wir werden das System weiter verbessern. Manches wird nicht funktionieren, wenn Sie das System anders nutzen.
| Datei | Beschreibung |
|---|---|
| Experts\Expert Advisor.mq5 | Veranschaulicht die Interaktion zwischen Chart Trade und dem Expert Advisor (für diese Interaktion ist „Mouse Study“ erforderlich). |
| Indicators\Chart Trade.mq5 | Erstellt ein Fenster zur Konfiguration der zu sendenden Order. (Für die Interaktion ist „Mouse Study“ erforderlich.) |
| Indicators\Market Replay.mq5 | Erstellt Steuerelemente für die Interaktion mit dem Dienst für Marktwiedergabe und Marktsimulation. (Für die Interaktion ist „Mouse Study“ erforderlich.) |
| Indicators\Mouse Study.mq5 | Erleichtert die Interaktion zwischen grafischen Bedienelementen und dem Benutzer (was sowohl für das System zur Marktwiedergabe und Marktsimulation als auch auf dem realen Markt erforderlich ist). |
| Indicators\Order Indicator.mq5 | Ist für die Anzeige von Marktorders zuständig und ermöglicht es den Benutzern, mit diesen zu interagieren und sie zu verwalten. |
| Indicators\Position View.mq5 | Zuständig für die Anzeige von Marktpositionen, die Interaktion mit diesen sowie deren Verwaltung. |
| Services\Market Replay.mq5 | Erstellt und pflegt den Replikations-/Simulationsdienst für den Markt (die Hauptdatei des gesamten Systems). |
Übersetzt aus dem Portugiesischen von MetaQuotes Ltd.
Originalartikel: https://www.mql5.com/pt/articles/13257
Warnung: Alle Rechte sind von MetaQuotes Ltd. vorbehalten. Kopieren oder Vervielfältigen untersagt.
Dieser Artikel wurde von einem Nutzer der Website verfasst und gibt dessen persönliche Meinung wieder. MetaQuotes Ltd übernimmt keine Verantwortung für die Richtigkeit der dargestellten Informationen oder für Folgen, die sich aus der Anwendung der beschriebenen Lösungen, Strategien oder Empfehlungen ergeben.