Developing a Replay System (Part 37): Paving the Path (I)

Einführung

In diesem Artikel werden wir ein sehr wichtiges Thema ansprechen. Ich schlage vor, dass Sie sich so weit wie möglich auf das Verständnis des Inhalts dieses Artikels konzentrieren. Ich meine nicht nur das Lesen. Ich möchte betonen, dass Sie, wenn Sie diesen Artikel nicht verstehen, die Hoffnung, den Inhalt der folgenden Artikel zu verstehen, völlig aufgeben können.

Alles, was ich in diesem Artikel zeige, erkläre und erzähle, ist wichtig, damit Sie die folgenden Artikel zumindest ansatzweise verstehen.

Das ist kein Scherz. Denn ich glaube, viele Leute wissen gar nicht, wozu wir fähig sind. Wir verwenden rein MQL5, um verschiedene Elemente zu zwingen, sich in MetaTrader 5 auf eine bestimmte Weise zu verhalten.

Die ganze Zeit über habe ich Artikel geschrieben, um Ihnen, lieber Leser, zu erklären, wie man bestimmte Dinge in MetaTrader 5 macht. Ich habe es vor mir hergeschoben, über ein bestimmtes Thema zu sprechen, habe um den heißen Brei herumgeredet und versucht, über das zu sprechen, was ich schon lange in meinen Programmen mache.

Diese Dinge erlauben es mir, mein System so zu modulieren, dass ich oft mehr mit der Modifizierung des Quellcodes als mit der Darstellung nur mit MQL5 arbeiten muss.

Alle Codes, die Sie die ganze Zeit gesehen haben, sind eigentlich modifizierte Codes. Sie sind ganz anders als die, die ich ursprünglich verwendet habe, aber jetzt stehe ich am Scheideweg und weiß nicht, was ich sonst tun soll. Entweder zeige ich den Originalcode oder den Code, der dem, den ich tatsächlich verwende, sehr nahe kommt, oder ich kann mit dem Projekt des Wiedergabe-/Simulationssystems nicht weitermachen.

Das Problem ist nicht einmal das Schreiben des Codes selbst. Meiner Meinung nach ist dies recht einfach zu bewerkstelligen. Das Problem ist, dass ich Ihnen das notwendige Wissen vermitteln möchte, damit Sie das System nicht nur nutzen, sondern auch verändern können. Dies ist notwendig, damit Sie das System so einstellen können, wie es für Sie wünschenswert ist, und damit Sie Ihre eigene Analyse durchführen können.

Ich möchte, dass jeder lernt, selbstständig und ohne fremde Hilfe zu arbeiten. Ich hoffe, das ist klar.

In diesem Artikel werden wir zeigen, wie wir mit Hilfe von Indikatoren und einigen Expert Advisors ein sehr spezifisches Verhalten und eine sehr modulare Programmierung erreichen können, bis hin zur Schaffung eines komplexen Systems. Aber hier ist das Problem: Wir werden so wenig wie möglich kompilieren.

Das Replay-/Simulationssystem enthält derzeit 3 ausführbare Dateien: einen Expert Advisor, einen Service und einen Indikator. Und doch können wir so das Auftragssystem entwickeln. Denken Sie daran, dass ein solches System den Handelsserver ersetzen wird, sodass wir die Analyse durch den Handel auf einem Demo- oder Live-Konto durchführen können.

Wir müssen noch einige Dinge aus der Vergangenheit in das Wiederholungs-/Modellierungssystem einbringen. Dies gilt zum Beispiel für den Chart Trader. Deshalb brauchen wir eine Art von System, das aber stabil und einfach zu bedienen sein muss. Obwohl wir dies in dem Artikel „Entwicklung eines Trading Expert Advisors von Grund auf (Teil 30): CHART TRADE als Indikator?!“ getan haben, ist er nicht wirklich geeignet.

Wir brauchen eine viel transparentere Vorgehensweise, die uns keine Unannehmlichkeiten bereitet.

Wir können das viel besser machen und mit einem einfacheren Beispiel zeigen. Wenn wir direkt zur gewünschten Anwendung übergehen, bin ich mir fast sicher, dass nur wenige, wenn überhaupt, in der Lage sein werden, mit dem Schritt zu halten, was wir hier diskutieren. Aber ich will nicht, dass das passiert. Lassen Sie uns nun sehen, wie wir vorgehen können. Machen Sie sich bereit, mein UNIVERSUM zu betreten.

Beginn der Erstellung des Indikators

Was wir tun werden, ist sehr schwierig aus der Sicht einer Person, die nicht weiß, wie MetaTrader 5 funktioniert. Ich werde am Ende keine Anhänge hinzufügen. Ich möchte, dass Sie den Erklärungen folgen, damit Sie wissen, dass Sie erleben können, was Sie hier sehen, und im Detail lernen, wie alles funktioniert.

Beginnen wir mit der Erstellung eines Indikators. Dafür sollten Sie MetaEditor öffnen und folgendes tun:

Abbildung 01 - Wählen Sie aus, was Sie erstellen möchten.

Abbildung 02 - Erstellen Sie ein Verzeichnis.

Abbildung 03 - Benennen Sie den Indikator.

Abbildung 04 - Die Dinge einfach halten.

Wie Sie in Abbildung 04 sehen können, erstellen wir für jede Art von Indikator, den wir erstellen wollen, immer dasselbe. An dieser Stelle in Abbildung 04 können wir manchmal das eine oder das andere haben, aber in jedem Fall können wir die Ereignisverwaltungsfunktionen später bei Bedarf hinzufügen oder ändern. Machen Sie sich also keine Sorgen, Sie können mit der Erstellung des Indikators wie gewohnt fortfahren.

Abbildung 05 - Klicken Sie auf „Fertigstellen“.

Als Ergebnis sehen Sie etwas wie in Abbildung 05. An diesem Punkt müssen wir nur noch auf die Schaltfläche „Fertig stellen“ klicken.

Die Idee ist, einen Indikator zu erstellen, der im Fenster ZERO platziert wird. Das gleiche Konzept kann jedoch auch verwendet werden, um einen Indikator in einem beliebigen Fenster zu platzieren. Aber auch hier gilt: Keine Sorge. Achten Sie auf den Hauptgedanken des Artikels.

Am Ende dieses Prozesses sehen Sie im MetaEditor-Fenster den folgenden Code:

#property copyright "Daniel Jose"
#property link      ""
#property version   "1.00"
#property indicator_chart_window
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- indicator buffers mapping
   
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const int begin,
                const double &price[])
  {
//---
   
//--- return value of prev_calculated for next call
   return(rates_total);
  }
//+------------------------------------------------------------------+

Ich weiß, dass viele Leute es vorziehen, die native Formatierung von MetaEditor zu verwenden. Das ist verständlich, aber für mich ist dieses Format weniger angenehm zu nutzen. Aber das ist die persönliche Angelegenheit eines jeden. Wirklich wichtig ist, dass wir unseren Code leicht lesen und verstehen können.

Beginnen wir also damit, diesen Standardcode in das zu ändern, was wir brauchen.

Wenn Sie versuchen, diesen Standardcode zu kompilieren, erhalten Sie eine Warnung.

Abbildung 06 - Compiler-Ausgabe.

Obwohl Abbildung 06 zeigt, dass der Code kompiliert wurde, wurde er nicht genau in der richtigen Weise erzeugt. Viele Programmierer ignorieren die Tatsache, dass der Compiler sie vor Fehlern warnt. Dies ist an dem roten Pfeil zu erkennen.

Schon das Auftreten eines Fehlers, selbst eines scheinbar unkritischen, kann Ihren Code gefährden. Daher sollten Sie unter keinen Umständen Code verwenden, der vom Compiler als fehlerhaft gemeldet wurde. Tun Sie das NIEMALS.

Um dieses Problem zu lösen, müssen wir etwas sehr Einfaches tun: dem Compiler mitteilen, dass wir wissen, was die Verwendung des Indikators bewirken wird.

#property copyright "Daniel Jose"
#property link      ""
#property version   "1.00"
#property indicator_chart_window
#property indicator_plots 0
//+------------------------------------------------------------------+
int OnInit()
{
        return INIT_SUCCEEDED;
}
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
{
        return rates_total;
}
//+------------------------------------------------------------------+

Indem wir eine hervorgehobene Zeile hinzufügen, zeigen wir dem Compiler, dass wir wissen, was wir tun. Das Ergebnis ist in Abbildung 07 dargestellt.

Abbildung 07 - Ergebnis der idealen Zusammenstellung.

Achten Sie bei der Kompilierung von Code auf die Fälle, in denen der Compiler Ihnen dasselbe sagt wie in Abbildung 07. Dies ist die einzige Möglichkeit, perfekt kompilierten Code ohne kritische Probleme zu erhalten.

Sie denken vielleicht, dass Sie das alles schon wissen. Okay, aber ich möchte mich klar ausdrücken. Ich möchte nicht, dass sich jemand darüber beschwert, dass das System nicht oder falsch funktioniert, weil es geändert wurde. Ich möchte jeden dazu ermutigen, das System zu verändern und an seine eigenen Bedürfnisse anzupassen. Und um dies zu erreichen, müssen Sie zunächst die Grundlagen kennen, ein solides und wohlgeformtes Fundament an Wissen und Ideen haben.

Nachdem wir nun einen Basisindikator haben, können wir einen einfachen Expert Advisor erstellen.

Beginn der Erstellung des Expert Advisors

Wir werden einen EA erstellen, um das zu implementieren, was wir brauchen. Lassen Sie uns Schritt für Schritt vorgehen.

Abbildung 08 - Was wir bauen werden.

Abbildung 09 - Bestimmen Sie das zu verwendende Verzeichnis.

Abbildung 10 - Bestimmen Sie den Namen der ausführbaren Datei.

Wie Sie sehen, folgen wir denselben Schritten wie in der Indikatorphase, der einzige Unterschied ist die Wahl, die wir zu Beginn der Erstellung getroffen haben.

Abbildung 11 - Standardeinstellungen belassen.

Abbildung 12 - Klicken Sie auf Fertigstellen.

Nachdem wir alle diese Schritte durchgeführt haben, erscheint eine Datei im MetaEditor, wie unten zu sehen ist:

#property copyright "Daniel Jose"
#property link      ""
#property version   "1.00"
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
   
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
   
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//---
   
  }
//+------------------------------------------------------------------+

Wie bei dem Indikator werde ich auch hier einige Formatierungsänderungen vornehmen. Aber im Gegensatz zum Indikator erhalten wir, wenn wir MetaEditor bitten, diesen Code zu kompilieren, die folgenden Informationen vom Compiler.

Abbildung 13 - Ergebnis der Kompilierungsanfrage.

Was bewirkt es? Beruhigen Sie sich, lieber Leser. Machen Sie sich keine Sorgen. Sie werden bald verstehen, was wir tun werden.

Nun, da wir ein grundlegendes System für den Indikator und den Expert Advisor haben, können wir das tun, wofür wir diesen Artikel begonnen haben: sie miteinander verbinden.

Es ist wichtig zu wissen, wie man einen Indikator oder einen Expert Advisor erstellt, und auch zu verstehen, wie sie interagieren und zusammenarbeiten können. Viele kennen die Grundlagen, die es ermöglichen, den Indikator zu verwenden, damit der Expert Advisor die vom Indikator berechneten Daten nutzen kann. 

Wenn Sie nicht wissen, wie man das macht, empfehle ich Ihnen, es zuerst zu lernen. Ein guter Ausgangspunkt ist dieser Artikel: „Entwicklung eines Expert Advisors für den Handel von Grund auf (Teil 10): Zugriff auf nutzerdefinierte Indikatoren“. Hier wird sehr einfach erklärt, wie man auf die vom Indikator berechneten Werte zugreifen kann. Gleichzeitig werden wir uns ansehen, wie wir den Indikator auf sehr einfache Weise initialisieren können, noch bevor wir auf Informationen zugreifen können, die in Abhängigkeit von dem, was wir tun werden, berechnet wurden.

All dies ist sehr schön und einfach, denn mit der Idee in Abbildung 14 können Sie den Inhalt des Indikators lesen. Anhand von Abbildung 15 können Sie nun einen Indikator erstellen, der einen Expert Advisor für diese Aufgabe verwendet.

Abbildung 14 - EA liest die Indikatordaten.

Abbildung 15 - Erstellen eines Indikators durch einen EA.

Trotzdem funktioniert diese Methode nicht, wenn wir etwas tun müssen, was wir mit Chart Trader gemacht haben. Als wir den Chart Trader in einen Indikator verwandelt haben, mussten wir einen anderen Weg wählen. Schon damals habe ich erwähnt, dass sich dies in Zukunft ändern würde. In diesem Artikel haben wir das in Abbildung 16 dargestellte Schema verwendet.

Abbildung 16 - Bidirektionale Kommunikation.

Wenn es notwendig ist, Informationen zwischen verschiedenen Parteien oder vielmehr zwischen verschiedenen Prozessen zu übertragen, benötigen wir dafür bestimmte Mittel. Im MetaTrader 5 können wir globale Terminalvariablen verwenden. Dasselbe Konzept wird schon seit langem im Replay-/Simulationssystem verwendet. Dadurch wird sichergestellt, dass der Dienst irgendwie mit dem Indikator interagieren kann.

Es gibt andere Möglichkeiten, die gleiche Kommunikation zu fördern, aber ich möchte keine Techniken verwenden, die es mir nicht erlauben, alle Vorteile von MQL5 und MetaTrader 5 voll auszuschöpfen. Wenn wir die Plattform und ihre Sprache in vollem Umfang nutzen, können wir von künftigen Verbesserungen profitieren. Wenn wir anfangen, Lösungen zu erfinden, die die angebotenen Funktionen nicht voll ausnutzen, wie können wir dann von einer Verbesserung von MQL5 oder sogar MetaTrader 5 profitieren?

Obwohl das in Abbildung 16 dargestellte System für viele Situationen sehr gut geeignet ist, bietet es keinen großen Nutzen.

Um dies zu verstehen, sollten wir versuchen, die folgende Tatsache zu begreifen: Wie viele Indikatoren sollten wir in ein Chart einfügen, um eine gute Erfahrung mit dem Replay-/Simulationssystem zu machen? Einen? Zwei? Fünf? Die Wahrheit ist, dass es nicht möglich ist, dies wirklich zu wissen. Aber das wissen wir bereits: Wir brauchen mindestens zwei Indikatoren, und zwar jetzt, nicht später. Wir brauchen sie jetzt. Wir brauchen mindestens zwei Indikatoren im Replay/Simulationssystem.

Sie fragen sich vielleicht, warum zwei. Der erste Indikator wird zur Steuerung der Wiedergabe/Simulation verwendet. Wir haben diesen Indikator bereits. Jetzt brauchen wir einen weiteren: den Chart Trader. So können wir direkt Aufträge erteilen. Wir brauchen den Chart Trader, weil wir im Gegensatz zum physischen Markt in der Wiedergabe/Simulation die Schaltflächen in der oberen Ecke nicht brauchen (Abb. 17).

Abbildung 17 - Quick Trader-Schaltflächen.

Wir brauchen eine Möglichkeit, Aufträge zu erteilen, aber es sollte dasselbe sein, egal, ob wir ein DEMO- oder ein REAL-Konto verwenden. Wir sollten die gleiche Methode für die Interaktion mit der Plattform haben.

Obwohl Abbildung 16 eine Interaktion zwischen dem EA und dem Indikator zum Senden von Aufträgen ermöglicht, ist dies nicht der beste Weg. Denn in diesem Fall müssen wir globale Variablen behalten, die besser für andere Zwecke verwendet werden könnten. Wir können einen völlig anderen Weg einschlagen, um genau die Kommunikation herzustellen, die wir brauchen.

Auf dieser Grundlage begannen wir mit der Anwendung eines neuen Ansatzes, wie in Abbildung 18 zu sehen ist.

Abbildung 18 - Neues Kommunikationsprotokoll.

Wenn man sich diese Bild ansieht, könnte man meinen, ich sei verrückt geworden. Wie können wir den EA und den Indikator direkt miteinander kommunizieren lassen? Wo ist der Haken an dieser Geschichte? Nein, das ist kein Scherz, und nein, ich bin nicht verrückt. Tatsache ist, dass es Mittel und Wege gibt, diese Kommunikation direkt vorzunehmen. Dies ist in den Abbildungen 14 und 15 zu sehen. Aber zusätzlich zu diesen Mitteln steht uns noch ein weiteres zur Verfügung. Was wir wirklich brauchen, ist ein Verständnis dafür, wie wir diese Mittel am besten einsetzen können.

Bevor ich fortfahre, möchte ich Sie etwas fragen: Haben Sie schon einmal versucht, den MetaTrader 5 auf eine andere Art und Weise zu nutzen als alle anderen? Haben Sie mit MQL5 so weit experimentiert, dass Sie sagen, dass bestimmte Dinge auf diese Weise erledigt werden können? Wenn die Antwort auf eine dieser beiden Fragen NEIN lautet, schlage ich vor, dass Sie einen Blick darauf werfen und sehen, wie weit das Kaninchenloch reicht.

Kommunikation zwischen Prozessen initiieren

Wie Sie aus den vorangegangenen Themen ersehen konnten, werden wir hier einen Weg der Kommunikation zwischen dem Indikator und dem Expert Advisor aufbauen, um keine globalen Terminalvariablen zu verwenden, außer in speziellen Fällen. Dies wird einen effizienten Informationsaustausch ermöglichen.

Die Idee ist einfach, und das Konzept ist noch einfacher. Ohne einige Details zu verstehen, werden Sie jedoch NICHT erfolgreich sein. Es ist sehr wichtig, dass Sie richtig verstehen, was ich Ihnen jetzt erklären werde. Denken Sie nicht, dass Sie bereits wissen, wie man in MQL5 programmiert und dass das ausreicht. Was ich jetzt erkläre, geht über die normale und vertraute Verwendung von MetaTrader 5 und der Sprache MQL5 hinaus.

Wir sollten mit bestimmten Dingen beginnen - es wird wie die Erstellung eines Protokolls sein. Egal, was Sie darüber denken, folgen Sie dem Weg und die Ergebnisse werden sich einstellen. Wer abweicht, wird scheitern.

Im Code des Indikators fügen wir zunächst die ersten Zeilen wie unten gezeigt ein.

 1. #property copyright "Daniel Jose"
 2. #property link      ""
 3. #property version   "1.00"
 4. #property indicator_chart_window
 5. #property indicator_plots 0
 6. //+------------------------------------------------------------------+
 7. #define def_ShortName       "SWAP MSG"
 8. #define def_ShortNameTmp    def_ShortName + "_Tmp"
 9. //+------------------------------------------------------------------+
10. input double user00 = 0.0;
11. //+------------------------------------------------------------------+
12. long m_id;
13. //+------------------------------------------------------------------+
14. int OnInit()
15. {
16.     m_id = ChartID();
17.     IndicatorSetString(INDICATOR_SHORTNAME, def_ShortNameTmp);
18.     if (ChartWindowFind(m_id, def_ShortName) != -1)
19.     {
20.              ChartIndicatorDelete(m_id, 0, def_ShortNameTmp);
21.             Print("Only one instance is allowed...");
22.             return INIT_FAILED;
23.     }
24.     IndicatorSetString(INDICATOR_SHORTNAME, def_ShortName);
25.     
26.     return INIT_SUCCEEDED;
27. }
28. //+------------------------------------------------------------------+
29. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
30. {
31.     return rates_total;
32. }
33. //+------------------------------------------------------------------+

Sieht nach Chaos aus? Aber hier gibt es keine Verwirrung. An diesem Punkt zwinge ich MetaTrader 5 dazu, sicherzustellen, dass nur ein Indikator im Chart vorhanden ist. Wie kann ich das tun? Vereinfacht ausgedrückt, prüfe ich, ob der Indikator im Chart angezeigt wird oder nicht.

Wenn Sie möchten, können Sie MetaTrader 5 mit dem obigen Code zwingen, nur einen Indikator auf dem Chart zu behalten. Aber um zu verstehen, wie es funktioniert, muss man es aufschlüsseln, indem man die wichtigsten Zeilen auflistet und erklärt, um es einfacher zu machen, der gesamten Erklärung zu folgen.

In Zeile 7 legen wir fest, welchen Namen unser Indikator haben soll. Dieser Name wird in MetaTrader 5 gespeichert, solange der Indikator im Chart angezeigt wird.

Um diesen Namen zu ermitteln, verwenden wir die Methode in Zeile 24. Hier legen wir den Namen fest, den der Indikator verwenden soll. Der Grund für die Definition von Zeile 8 liegt in der Funktionsweise des MetaTrader 5.

MetaTrader 5 ist eine ereignisbasierte Plattform. Das bedeutet, dass MetaTrader 5 bei jedem Ereignis, sei es eine Kursbewegung, eine Zeitänderung im Chart, eine Mausbewegung, ein Tastendruck oder das Hinzufügen oder Entfernen von etwas aus dem Chart, eine Art von Ereignis auslöst. Jede Art von Ereignis hat einen Zweck und eine Konsequenz.

Wenn MetaTrader 5 ein Update-Ereignis auslöst, müssen alle Objekte, Indikatoren, Expert Advisors und andere Elemente, die im Chart vorhanden sind, auf irgendeine Weise aktualisiert werden. Im Falle von Skripten werden sie einfach aus dem Chart zurückgesetzt, und im Falle von Indikatoren und EAs haben sie einen neuen Aufruf der OnInit-Funktion. Wenn etwas passiert und der Indikator von Grund auf aktualisiert werden muss, erzwingt MetaTrader 5 den Aufruf von Zeile 14. Wo liegt das Problem? Das Problem besteht darin, dass der Indikator einen Kurznamen haben muss, der von MetaTrader 5 erkannt wird, da wir sonst die in Zeile 18 gezeigte Prüfung nicht durchführen können.

Man könnte meinen, dass wir die Zeile 24 einfach vor die Zeile 18 verschieben könnten, aber genau hier liegt das Problem. Wenn wir Zeile 24 vor Zeile 18 einfügen, wenn der in Zeile 18 markierte Indikator bereits im Chart vorhanden ist, erhalten wir ein positives Ergebnis. Dies führt dazu, dass MetaTrader 5 den Indikator aus dem Chart zurücksetzt, obwohl wir eigentlich wollen, dass er erhalten bleibt, wenn Zeile 20 ausgeführt wird. Wir wollen aber, dass nur eine Instanz davon vorhanden ist.

Ich hoffe, Sie können die Erklärung nachvollziehen. Aus dem oben beschriebenen Grund benötigen wir einen temporären Namen, der in Zeile 8 definiert wird, wo wir eine kleine Änderung am Kurznamen des Indikators vornehmen, bevor wir in Zeile 18 prüfen, ob der Indikator bereits im Chart vorhanden ist. In Zeile 17 legen wir den vorläufigen Namen des Indikators fest. HINWEIS: Dieser Name muss eindeutig sein, sonst gibt es Probleme.

Wenn der Indikator bereits auf dem Chart vorhanden ist, ermöglicht Zeile 18 die Ausführung von Zeile 20, wodurch der Indikator, der versucht, auf das Chart zu gelangen, entfernt wird. Um den Nutzer über den Fehler zu informieren, gibt es die Zeile 21, die eine Meldung im MetaTrader 5-Nachrichtenfeld anzeigt. Der Indikator kehrt in Zeile 22 zurück und zeigt an, dass es nicht möglich war, ihn im Chart anzuzeigen.

Wenn der Indikator in das Chart gelangt, wird der Name des Indikators in Zeile 24 korrigiert, sodass es praktisch unmöglich ist, einen neuen Indikator im Chart zu platzieren. Es gibt jedoch ein „Schlupfloch“, das eigentlich keine MetaTrader 5-Lücke ist. Glücklicherweise kann MetaTrader 5 zwischen diesen Dingen unterscheiden, wenn wir einen neuen Indikator zum Chart hinzufügen. Um dies zu verstehen, gibt es den Code in Zeile 10.

Wenn der Nutzer den Wert der Variable NICHT ändert, wenn er den Indikator auf dem Chart platziert (die Variable wird in Zeile 10 deklariert), geht MetaTrader 5 davon aus, dass der Indikator derselbe ist wie der, der sich bereits auf dem Chart befindet, falls dort bereits einer läuft. Wenn der Nutzer den Wert ändert, kann MetaTrader 5 zwei völlig unterschiedliche Entscheidungen treffen, je nachdem, ob es sich um denselben Indikator handelt oder ein neuer hinzugefügt wird.

• Im ersten Fall, wenn es keinen Indikator gibt, wird er auf dem Chart platziert.
• Der zweite Fall ist, dass der Indikator bereits existiert. Wenn in diesem Fall der in der Variable angegebene Wert von dem bereits auf dem Chart angezeigten Indikator abweicht, wird er von MetaTrader 5 als ein anderer Indikator wahrgenommen. Wenn der Wert identisch ist, erkennt MetaTrader 5 sie als denselben Indikator.

Auf diese Weise können Sie die Anzahl der Indikatoren mit demselben Namen auf dem Chart auf einen einzigen beschränken. Falls gewünscht, können Sie eine maximale Anzahl von Indikatoren mit demselben Namen zulassen. Sie müssen nur die Prüfung in Zeile 18 ändern. So ist es möglich, MetaTrader 5 so zu konfigurieren, dass er z.B. 3 Indikatoren mit demselben Namen akzeptiert. Wenn der Nutzer jedoch versucht, einen vierten Indikator mit demselben Namen zu platzieren, wird dies von MetaTrader 5 untersagt. Genauer gesagt wird dies durch den Indikatorcode geschehen, der den Versuch, einen vierten Indikator zu platzieren, verhindern wird.

Wie Sie sehen, können wir das System so weit anpassen und einschränken, dass wir keine Duplizierung von Indikatoren im Chart zulassen. Dies ist sehr wichtig und wird später in dieser Serie über das Replay-/Simulationssystem ausführlicher behandelt.

Es gibt mehrere Punkte im Code dieses Indikators, die ich später erklären werde, damit die Interaktion zwischen dem EA und dem Indikator klar ist, ohne globale Terminalvariablen zu verwenden. Ich spreche von den Zeilen 5 und 10. Es ist wichtig, die Logik hinter dieser Art der Programmierung zu verstehen.

Um zu verstehen, was tatsächlich passiert, können Sie den oben detailliert beschriebenen Code erstellen und ihn auf der MetaTrader 5-Plattform ausführen.

Schlussfolgerung

In diesem Artikel haben wir Ihnen gezeigt, wie Sie die Platzierung von mehr als einem Indikator auf einem Chart blockieren oder einschränken können, indem Sie den beschriebenen Code in der MetaTrader 5 Plattform erstellen und ausführen. Sie können dieses Wissen nutzen, um viele andere Aufgaben zu vereinfachen, was Ihr Leben als Händler und Nutzer der MetaTrader 5-Plattform erheblich erleichtert und Ihnen eine bessere Erfahrung mit ihr verschafft.

Auch wenn der Grund dafür in diesem Artikel nicht deutlich wird, können wir mit dem vorgestellten Wissen, wenn es richtig angewendet wird, viel mehr tun und eine Reihe von Problemen vermeiden, die mit dem Vorhandensein doppelter oder sogar unnötiger Indikatoren im Chart verbunden sind.

Es ist nicht ungewöhnlich, dass ein Nutzer, der wenig Erfahrung mit MetaTrader 5 hat, denselben Indikator mehrmals auf dem Chart platziert, was die Verwendung und Konfiguration dieser Indikatoren extrem frustrierend macht. Und all dies lässt sich mit einem recht einfachen Code vermeiden (wie Sie selbst gesehen haben). Es ist durchaus in der Lage, das zu tun, wofür es gedacht ist.

Ich hoffe, dass dieses Wissen für Sie nützlich sein wird. Im nächsten Artikel werden wir uns ansehen, wie wir den nächsten Schritt in Bezug auf die Schaffung einer direkten Kommunikation zwischen dem Expert Advisor und dem Indikator machen können, die notwendig ist, um unser Replay/Simulationssystem weiter zu implementieren.