Von der Grundstufe bis zur Mittelstufe: Indikator (I)

Im vorherigen Artikel „Von der Grundstufe zur Mittelstufe: Ereignisse (II)“ haben wir uns damit beschäftigt, wie man Informationen mehr oder weniger dauerhaft zwischen verschiedenen Sitzungen der MetaTrader 5 Plattform speichern kann. Ich weiß, dass einige denken könnten, dass solches Material unnötig ist. Aber wenn Sie Informationen zwischen den Sitzungen aufbewahren müssen, werden Sie sich daran erinnern und sagen: „Mein Freund, ich danke Ihnen für diesen Rat. Ich danke Ihnen vielmals.“ Auf jeden Fall,

wir stehen erst am Anfang unserer Erkundung. Da wir bereits die grundlegenden Konzepte kennen, die es uns ermöglichen, kleine Programme zu erstellen, und wir bereits gesehen haben, wie die ereignisgesteuerte Programmierung funktioniert, ist es an der Zeit, einige grundlegende Konzepte zu verstehen, die viele Leute versuchen, selbst zu implementieren, obwohl sie bereits entworfen sind und standardmäßig nicht implementiert werden müssen, sondern einfach nach Bedarf verwendet werden.

In diesem Fall beziehe ich mich auf die Registerkarten, die standardmäßig in fast allen Anwendungen von MetaTrader 5 vorhanden sind, obwohl wir mehr oder weniger davon haben können. Wenn Sie als Programmierer jedoch lernen, diese Registerkarten zu verwenden, werden Sie zu aufmerksamen und anspruchsvollen Nutzern der Schnittstellen, die Ihnen andere Programmierer zur Verfügung stellen.

Lassen Sie uns also heute ein neues Thema beginnen.

Standard-Registerkarten

Jeder vollständig in MQL5 geschriebene Code kann ein grundlegendes Einstellungsfenster haben. Dieses Fenster ist nicht in allen Anwendungen vorhanden; in Anwendungen wie Skripten und Diensten kann es vorhanden sein oder auch nicht. Bei Indikatoren und Expertenberatern werden uns jedoch immer einige Elemente oder besser gesagt Standardregisterkarten präsentiert. Sie werden nicht vom Programmierer erstellt, sondern sind in der MetaTrader 5-Umgebung definiert, d.h. wir haben einen Standard für die Konfiguration jedes Indikators oder Expertenberaters.

Aber aus verschiedenen Gründen fügen viele Programmierer oft Konfigurationselemente hinzu, die nicht notwendig sind. Das liegt daran, dass solche Elemente bereits in die Registerkarten passen, die dem Nutzer standardmäßig angezeigt werden. Die Frage ist, ob Sie wissen, wie Sie auf die in den Standard-Registerkarten definierten Elemente zugreifen können. Ich frage das als Programmierer, nicht als Nutzer.

Wenn ich von Standard-Registerkarten spreche, meine ich das, was wir in der nachstehenden Bildfolge sehen:

Abbildung 01

Abbildung 02

Abbildung 03

Abbildung 04

Dies sind die Standardregisterkarten für Indikatoren. Da wir uns gegenwärtig darauf konzentrieren, zu lernen, wie Ereignisse in einem Indikator funktionieren, gerade weil er einfacher ist, sollten wir so viel wie möglich darüber lernen, bevor wir uns komplexeren Dingen zuwenden. Nichtsdestotrotz ist dieses Standard-Registerkartensystem recht interessant und gut durchdacht, da es für eine Vielzahl von Fällen perfekt geeignet ist. In den meisten Fällen ist es nicht notwendig, zusätzliche Eingabeparameter zu implementieren. Aber warum erstellen dann viele Programmierer zusätzliche Eingabeparameter? Der Grund dafür ist, dass dies notwendig wird, wenn das Standardschema von MetaTrader 5 unseren Anforderungen nicht gerecht wird. Bevor wir jedoch anfangen, alle möglichen unnötigen Elemente hinzuzufügen, ist es besser, zunächst zu verstehen, wie diese Registerkarten verwendet werden, damit unsere Anwendung nicht vom MetaTrader 5-Standard abweicht.

Im Grunde genommen ist die einzige Registerkarte, die verwaltet werden muss, wenn wir es für notwendig halten, die Registerkarte von Bild 01. Der Grund dafür ist, dass wir auf dieser Registerkarte Elemente hinzufügen können, um den Zweck dieser Anwendung anschaulicher zu gestalten. Und das ist ganz einfach. Da wir uns hier jedoch weiterhin nur auf den Bildungsaspekt konzentrieren wollen, werden wir dieser Registerkarte keine Elemente hinzufügen. Auf jeden Fall sollten Sie darüber nachdenken, wie Sie diese erste Registerkarte bearbeiten, insbesondere wenn Sie Ihre Anwendungen zugänglich machen wollen.

Um die in Abbildung 01 gezeigte Registerkarte hinzuzufügen oder zu ändern, müssen wir dem Compiler mitteilen, was er dort einfügen soll. Dazu werden wir eine Compiler-Direktive verwenden. Diese Direktive lautet #property. Mit dieser Direktive können wir viele Dinge definieren, von der Anwendungsversion bis hin zu einem Link zu einem bestimmten Ort im Internet. Ausführlichere Informationen finden Sie in der Dokumentation. Sie haben wahrscheinlich schon gesehen, wie diese Direktive in allen meinen Artikelcodes angewendet wird. Das einzige, was ich standardmäßig definiere, ist das Urheberrecht. Schauen wir uns an, wie wir einen weiteren definieren können, um Ihnen eine Vorstellung davon zu geben, was wir tun können. Hierfür verwenden wir den unten stehenden Code.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. #property version "1.0"
04. #property icon "Example.ico"
05. #property description "This is a demonstration application whose purpose is only didactic.\nIt is part of a sequence of articles published in the MQL5 community."
06. #property link "https://www.mql5.com/pt/articles/15794"
07. //+------------------------------------------------------------------+
08. int OnInit()
09. {
10.    return INIT_SUCCEEDED;
11. };
12. //+------------------------------------------------------------------+
13. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
14. {
15.    return rates_total;
16. };
17. //+------------------------------------------------------------------+

Code 01

Wenn wir also den Code 01 ausführen, wird das Bild 01 anders dargestellt. Diese Veränderung ist unten zu sehen:

Abbildung 05

Bitte bedenken Sie, dass wir jetzt ein Symbol haben, das sich von dem Standard-Symbol unterscheidet, sowie eine Beschreibung des Zwecks der Anwendung. All dies wird zwischen den Zeilen 02 und 05 definiert. Beachten Sie, dass wir das Verzeichnis und die Bilddatei angeben müssen, die als Symbol verwendet werden soll. Im Anhang habe ich alles vorbereitet, damit Sie experimentieren und verstehen können, wie Sie das gewünschte Symbol platzieren können. Zu diesem Zeitpunkt sollte sich die Symboldatei, wie in Code 01 zu sehen, in dem Ordner befinden, in dem sich der Indikatorcode befindet. Sie kann jedoch auch an anderer Stelle platziert werden; geben Sie einfach den Speicherort an, und der Compiler wird die erforderliche Datei finden können.

„Aber, einen Moment. Hier fehlt eine Information: die, die wir in Zeile 06 von Code 01 deklariert haben. Wo ist sie hin?“ Diese Informationen, die zuvor auf der Registerkarte sichtbar waren, sind nun mit anderen Informationen verknüpft. Wenn Sie zum Beispiel den Mauszeiger über die Copyright-Informationen bewegen, sehen Sie die nachstehende Abbildung:

Abbildung 06

So können wir bestätigen, dass alle Informationen vorhanden sind, wie in Abbildung 06 zu sehen ist. Wenn wir auf den Punkt klicken, an dem der Link entstanden ist, öffnet sich ein Browser, der uns zu der in Zeile 06 von Code 01 angegebenen Stelle führt. Da Sie in den meisten Fällen, wie ich annehme, etwas für den persönlichen Gebrauch erstellen, können Sie diese Dinge ignorieren, da sie nicht implementiert werden müssen. Obwohl es Situationen gibt, in denen wir den Compiler anweisen müssen, wie der Code generiert werden soll, oder besser gesagt (da diese Formulierung vielleicht verwirrend war) – es gibt besondere Umstände, unter denen wir diese Kompilierungseigenschaften festlegen müssen, selbst wenn wir Code für persönliche Zwecke verwenden.

Ein solcher Fall ist die Erstellung eines Indikators, dessen Ziel es ist, etwas auf dem Chart zu zeichnen. Sie können jedoch die Erläuterung der anderen Registerkarten, die am Anfang dieses Themas erwähnt wurden, überspringen. Ich bitte Sie, ruhig und geduldig zu bleiben. Wir werden in Kürze auf sie zurückkommen. Aber jetzt müssen wir etwas anderes tun, um diesen Registerkarten eine Bedeutung zu geben.

Basisindikator

Bisher haben wir nur eine Menge Informationen generiert und sie auf dem Terminal ausgedruckt, damit sie angezeigt werden können. Endlich ist der Moment gekommen, etwas auf dem Chart zu sehen. Um es angenehmer und verständlicher zu machen, werden wir den Chart im Standard-MetaTrader-5-Stil verwenden. Ich werde dies nur zu Demonstrationszwecken tun, aber Sie können Grafiken mit der Konfiguration verwenden, die Ihnen am besten gefällt oder die Sie am meisten bevorzugen.

Na gut. In den beiden vorangegangenen Artikeln haben wir erklärt, wie die beiden wichtigsten vom MetaTrader 5 generierten Ereignisse funktionieren: Deinit und Init. Beide sollen unserer Anwendung vorschreiben, wie sie sich zu verhalten hat. Alle Indikatoren benötigen jedoch zwei Ereignisse: das bereits erwähnte Init-Ereignis und das Calculate-Ereignis.

Passen Sie gut auf, liebe Leser, denn dies ist sehr wichtig. Die Funktion OnCalculate muss das Ereignis Calculate erfassen, das im Code des Indikators vorhanden sein muss. Wir haben jedoch zwei Versionen der gleichen Funktion, d. h. MQL5 bietet standardmäßig die Möglichkeit, überladene Funktionen zu verwenden. Zunächst ist die eine Version aufgeführt, die andere danach.

int  OnCalculate(
   const int        rates_total,       // price[] array size
   const int        prev_calculated,   // number of handled bars at the previous call
   const int        begin,             // index number in the price[] array meaningful data starts from
   const double&    price[]            // array of values for calculation
   );

int  OnCalculate(
   const int        rates_total,       // size of input time series
   const int        prev_calculated,   // number of handled bars at the previous call
   const datetime&  time[],            // Time array
   const double&    open[],            // Open array
   const double&    high[],            // High array
   const double&    low[],             // Low array
   const double&    close[],           // Close array
   const long&      tick_volume[],     // Tick Volume array
   const long&      volume[],          // Real Volume array
   const int&       spread[]           // Spread array
   );

Aber warum haben die MQL5-Entwickler das getan? Ich denke, der Hauptgrund ist, den Betrieb des Indikators effizienter und stabiler zu machen. Es gibt nämlich mehrere Berechnungsmethoden, vor allem wenn man bedenkt, dass die Indikatoren meistens einen Durchschnittswert berechnen. Daher haben die Entwickler festgestellt, dass sie die Leistung der MetaTrader 5-Plattform verbessern können, und beschlossen, dem Indikator zu erlauben, einige dieser Berechnungen zu überspringen, da die Plattform selbst uns das Ergebnis im Voraus liefern kann. Das mag für Sie jetzt noch nicht viel Sinn ergeben, aber ich versichere Ihnen, dass Sie mit zunehmender Übung und Erfahrung verstehen werden, dass dies von großem Wert ist.

Welche überladene Version sollte ich also verwenden? Die Antwort: Das hängt ganz von der jeweiligen Situation ab. Es geht nicht darum, die eine Version auf Kosten der anderen zu verwenden. Beide Versionen tun im Wesentlichen das Gleiche – sie empfangen das Ereignis „Rechne“. Das war's. Wie es weitergeht, hängt davon ab, was wir planen und was wir tun müssen.

Es gibt jedoch einen interessanten Punkt, der als erfolgreiche Weiterentwicklung der Plattformentwickler anerkannt werden muss. Je nachdem, welche Version von OnCalculate der Nutzer verwendet, hat er entweder Zugriff auf die in Abbildung 02 gezeigte Registerkarte oder nicht. Wenn Sie nach Artikeln mit Bildern, Animationen oder Videos von älteren Versionen von MetaTrader 5 in Aktion suchen, werden Sie feststellen, dass die Registerkarte in Bild 02 fast immer erscheint, auch wenn sie völlig unnötig ist.

Aber irgendwann ist das alles verschwunden. Wenn Sie die Version mit weniger Argumenten verwenden, ist die in Abbildung 02 dargestellte Registerkarte zugänglich. Wenn Sie die Version mit mehreren Argumenten verwenden, ist diese Registerkarte nicht verfügbar. Genau aus diesem Grund habe ich gesagt, dass alles zu gegebener Zeit erklärt werden würde. Wäre es früher erwähnt worden, hätte es keinen Sinn gemacht. Aber jetzt wird es Sinn machen, und noch mehr, wenn wir einen Indikator einführen.

Zu Beginn werden wir eine sehr einfache Version erstellen, bei der fast alles von MetaTrader 5 erledigt und gehandhabt wird. Wir, die Programmierer, werden nur das Nötigste tun, damit es funktioniert und so lehrreich wie möglich ist. Und wir werden dies Schritt für Schritt tun. Obwohl der Code selbst sehr einfach zu verstehen und auszuführen ist, kann jeder, auch ein Anfänger mit Grundkenntnissen, in kleinen Schritten folgen, wenn er diese Artikel studiert.

Unser Code beginnt wie folgt:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. int OnInit()
05. {
06.    return INIT_SUCCEEDED;
07. };
08. //+------------------------------------------------------------------+
09. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
10. {
11.    return rates_total;
12. };
13. //+------------------------------------------------------------------+

Code 02

Bitte beachten Sie, dass noch nichts umgesetzt wurde. Der Code enthält nur die Grundlagen, damit der Compiler weiß, wie die gewünschte Anwendung zu erstellen ist – ein Indikator, der alle Registerkarten anzeigt, wie zu Beginn dieses Artikels erläutert. Als Nächstes werden wir unseren Indikator beschreiben. Dazu müssen wir dem Compiler mitteilen, was erstellt werden soll. Dies kann auf zwei Arten geschehen: dynamisch (was sehr viel komplexer ist und zu einem anderen Zeitpunkt erklärt wird) und statisch (was wesentlich einfacher und unkomplizierter ist). Letzteres ist ideal für kleine Codes und richtet sich an diejenigen, die gerade erst anfangen oder einfach nur einen einfachen und schnellen Indikator erstellen wollen. Zu diesem Zweck werden wir den Code 02 ändern, um diese Version zu erhalten:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. #property indicator_type1           DRAW_LINE
05. #property indicator_color1          clrBlack
06. //+------------------------------------------------------------------+
07. int OnInit()
08. {
09.    return INIT_SUCCEEDED;
10. };
11. //+------------------------------------------------------------------+
12. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
13. {
14.    return rates_total;
15. };
16. //+------------------------------------------------------------------+

Code 03

Dies ist der zweite Schritt, den wir unternehmen müssen. Die Anweisung in Zeile 05 bezieht sich auf einen kleinen Fehler, der bei der Verwendung des MetaTrader 5-Standardsystems immer noch auftritt. Ohne diese Zeile LÄSST SICH DIE FARBE DES INDIKATORS NICHT ÄNDERN, auch wenn es sich um einen sehr einfachen Indikator handelt. Die wichtigste Aussage findet sich jedoch in Zeile 04. In dieser Zeile geben wir genau an, was wir im Chart anzeigen wollen. Hier wird es eine Preislinie sein, aber welcher konkrete Preis? Wie werden die Definitionen und Eigenschaften der zu zeichnenden Linie aussehen? Keine Sorge, wir werden das schon schaffen, bitte nur etwas Geduld.

Nachdem wir den Typ des zu erstellenden Indikators definiert haben, müssen wir noch einige seiner Merkmale festlegen. Dazu müssen wir die MQL5-Dokumentation zu Rate ziehen, um zu erfahren, wie man die folgenden Elemente deklariert. Dann kehren wir zur Dokumentation zurück und suchen nach dem Begriff #property, um Informationen zu finden, die sich auf das beziehen, was in Zeile 04 deklariert wurde, d. h. den Indikatortyp. Wenn wir nach diesen Informationen suchen, sehen wir etwas, das in der folgenden Abbildung hervorsticht:

Abbildung 07

Der in Abbildung 07 gezeigte Punkt ist für uns sehr wichtig, denn ohne ihn können wir MetaTrader 5 nicht vorgeben, wie der Indikator angezeigt werden soll. Daher suchen wir nach der Enumeration ENUM_DRAW_TYPE. Wenn wir dies in der Dokumentation nachschlagen, sehen wir eine ähnliche Tabelle wie die folgende:

Abbildung 08

Die Informationen, die wir benötigen, sind genau das, was in Abbildung 08 grün hervorgehoben ist, d. h. wir benötigen einen Datenpuffer. Verschiedene Arten von Indikatoren erfordern unterschiedliche Dinge. Da das Programm, das wir erstellen, sehr einfach ist, benötigen wir nur einen Puffer. Mit diesen Informationen können wir zu Code 03 zurückkehren und ihm einige weitere Elemente hinzufügen. Wir benötigen jedoch zunächst zusätzliche Informationen. Dies betrifft die Anzahl der Elemente, die der Indikator auf dem Bildschirm zeichnen muss. Um die genannten Informationen zu finden, müssen wir uns die #Eigenschaft ansehen. Es ist unten dargestellt:

Abbildung 09

Um die zweite Information zu erhalten, greifen wir auf die gleiche Tabelle zurück. Nun müssen wir einen Wert verwenden, der der Summe dieser beiden Werte aus Bild 10 entspricht:

Abbildung 10

Nachdem wir alle Informationen gesammelt haben, können wir zu Code 03 zurückkehren und einige weitere Elemente hinzufügen. Der Code sieht wie folgt aus:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. #property indicator_type1           DRAW_LINE
05. #property indicator_color1          clrBlack
06. //+----------------+
07. #property indicator_buffers         1
08. #property indicator_plots           1
09. //+------------------------------------------------------------------+
10. int OnInit()
11. {
12.    return INIT_SUCCEEDED;
13. };
14. //+------------------------------------------------------------------+
15. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
16. {
17.    return rates_total;
18. };
19. //+------------------------------------------------------------------+

Code 04

In Code 04 sehen wir in Zeile 07 die gesuchte Erklärung, die wir in Abbildung 08 gefunden haben. Zeile 08 gibt eine weitere Information an, die der Summe der Werte in Bild 10 entspricht. Jetzt können wir den Indikator funktionsfähig machen. Der letzte Schritt ist unten dargestellt:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. #property indicator_type1           DRAW_LINE
05. #property indicator_color1          clrBlack
06. //+----------------+
07. #property indicator_buffers         1
08. #property indicator_plots           1
09. //+----------------+
10. double   gl_buffer[];
11. //+------------------------------------------------------------------+
12. int OnInit()
13. {
14.    SetIndexBuffer(0, gl_buffer, INDICATOR_DATA);
15. 
16.    return INIT_SUCCEEDED;
17. };
18. //+------------------------------------------------------------------+
19. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
20. {
21.    for (int c = prev_calculated; c < rates_total; c++)
22.       gl_buffer[c] = price[c];
23. 
24.    return rates_total;
25. };
26. //+------------------------------------------------------------------+

Code 05

Und hier vor Ihnen steht ein vollständiger und voll funktionsfähiger Indikator. Wir können ihn bitten, alle Informationen anzuzeigen, die uns der MetaTrader 5 zur Verfügung stellen kann, und er wird dies einwandfrei tun. „Aber wie ist das möglich? Ich habe bereits Codes von anderen Indikatoren gesehen, und sie sind viel umfangreicher. Das kann nicht sein. Ich habe bereits versucht, mehrere Indikatoren zu erstellen, und alle haben viel mehr Code als das, was Sie präsentieren. Ich glaube nicht, dass das funktionieren kann; ich möchte die Funktion überprüfen“.

Ich verstehe Ihre Überraschung, liebe Leser. Das liegt daran, dass jeder Indikatorcode, den Sie studiert haben, viel mehr Elemente enthält als das, was wir hier tun. Aber um Ihnen zu zeigen, dass dieser Code funktioniert, sehen wir uns die Animation an:

Animation 01

In Animation 01 zeige ich, wie man den Indikator platziert und dann seine Farbe ändert. Bitte beachten Sie, dass die Anwendung recht einfach und intuitiv ist.

Animation 02

In der Animation 02 zeigen wir, wie Sie den Stil der Indikatorlinie ändern können. Auch das ist sehr intuitiv.

Animation 03

In Animation 03 sehen Sie, wie Sie die Dicke der Linie, die der Indikator verwendet, ändern können. In diesem Fall wäre es schön, wenn der MetaTrader 5 Linienstile mit unterschiedlichen Stärken unterstützen würde. Bis die Entwickler diese Funktion implementieren, müssen wir uns an die aktuellen Gegebenheiten des MetaTrader 5 anpassen.

Animation 04

In der Animation 04 sehen Sie schließlich, wie Sie die Art der Berechnung für den Indikator ändern können. Wie Sie sehen, ist alles ganz einfach und unkompliziert und hat keinen Einfluss auf den Betrieb des Indikators. Man kann nur raten, wie die Registerkarte aus Bild 04 funktioniert, aber da solche Dinge sehr intuitiv und einfach sind, muss man nur neugierig sein und diese Registerkarte nutzen.

Ich sehe keine Notwendigkeit, dies hier und jetzt zu erklären, da diese Registerkarte nur zur Konfiguration der Betriebsumgebung verwendet wird. Anfänger werden nur selten versuchen, diese Registerkarte zu manipulieren. Aber Sie als Programmierer müssen verstehen, wie es funktioniert und wie es in Code umgesetzt werden kann. Ja, es ist möglich, die Funktionsweise des Indikators zu konfigurieren, ohne diese Registerkarte zu berühren – unter Verwendung von reinem MQL5 – aber wir werden das später zu einem geeigneteren Zeitpunkt besprechen.

Nachdem wir nun gesehen haben, wie der Code funktioniert, wollen wir uns ansehen, was im letzten Implementierungsschritt hinzugefügt wurde. Was hier erklärt wird, wird später in einer etwas fortgeschritteneren Form behandelt. Sie müssen jedoch von Anfang an verstehen, warum und wie wir die Zeilen benötigen, die im letzten Schritt, ab Zeile 10, implementiert werden.

Wie in den ersten Artikeln dieser Reihe erläutert, wird die Verwendung globaler Variablen im Allgemeinen nicht empfohlen. Die in Zeile 10 deklarierte Variable ist jedoch ein Sonderfall: Wir brauchen wirklich eine globale Variable, weil sie für die Implementierung mehrerer Punkte notwendig ist, die wir später noch untersuchen werden. Aber zunächst müssen Sie verstehen, dass diese Variable die Daten enthält, die im Chart dargestellt werden, wodurch der Indikator in den Animationen sichtbar wird.

Dazu müssen wir MetaTrader 5 mitteilen, WELCHE Variable verwendet werden soll, da im eigentlichen Code mehrere Variablen deklariert werden können. Diese Art von Information wird durch die Angaben in Zeile 14 geliefert. Im Prinzip ist das alles. Danach können wir mit der Erfassung des Calculate-Ereignisses beginnen und die vom MetaTrader 5 bereitgestellten Daten verwenden, um der in Zeile 10 deklarierten Variablen Werte zuzuweisen. 

Das ist überhaupt nicht schwierig; in den meisten Fällen ist es sogar recht einfach. Alles, was wir tun müssen, ist einen Wert zu berechnen und ihn einer bestimmten Position in dem in Zeile 10 deklarierten Array zuzuweisen. Also, aufgepasst. Bei der Erläuterung des Themas Arrays haben wir gesagt, dass es zwei Arten von Arrays gibt: dynamische und statische. Dennoch muss JEDES ARRAY, das zum Speichern von Daten für die Darstellung in einem Indikator verwendet wird, dynamisch sein. Wir MÜSSEN jedoch KEINEN Speicher dafür reservieren. Er wird bei Bedarf von MetaTrader 5 selbst zugewiesen. Daher können wir den Code in Zeile 22 verwenden. In Zeile 14 geben wir an, dass diese Variable zum Speichern von Indikatordaten verwendet werden soll, die im Chart dargestellt werden sollen. Danach übernimmt MetaTrader 5 die volle Kontrolle über die Speicherzuweisung.

Aber es gibt noch einen weiteren wichtigen Aspekt. Idealerweise sollte jede MetaTrader 5-Anwendung so effizient wie möglich sein. Dies ist notwendig, um einen zu hohen Zeitaufwand zu vermeiden und die Stabilität der Plattform zu erhalten. Beachten Sie daher, wie die Schleife in Zeile 21 erstellt wird. Man könnte den Eindruck gewinnen, dass jedes Mal, wenn das Calculate-Ereignis ausgelöst wird, alle Daten im Preis-Array von Anfang bis Ende gelesen werden. Aber genau das passiert nicht, oder zumindest sollte es nicht passieren.

Im Wesentlichen werden in MetaTrader 5 einige interne Werte gespeichert, um Aktionen der Anwendung zu verwalten. Bei der ersten Erfassung des Calculate-Ereignisses durch unseren Indikator zeigt der Wert rates_total auf die im Preis-Array vorhandene Datenmenge. Der Wert prev_calculated kann Null sein oder nicht, aber er verweist auf jeden Fall auf den ersten Datenpunkt in der Reihe. Dies kann geändert werden, wie wir später sehen werden. Im Moment müssen Sie nur verstehen, was erklärt wurde: Diese Bedingung wird nur beim ersten Mal erfüllt, wenn Ihr Code korrekt implementiert ist und die Regeln befolgt.

Beim nächsten Aufruf kann der Wert prev_calculated gleich rates_total sein oder auch nicht. Bleibt er gleich, bedeutet dies, dass keine wesentlichen Änderungen eingetreten sind. Wenn er kleiner ist, wird die Schleife ausgeführt, um den zu zeichnenden Wert zu aktualisieren.

Wenn wir den Code richtig implementieren, wird die erste Ausführung daher langsam sein. Bei allen nachfolgenden Erfassungen des Ereignisses Berechnen wird jedoch nur eine minimale Anzahl von Transaktionen durchgeführt, damit die Plattform schnell eine Analyse durchführen und das Ergebnis auf dem Bildschirm anzeigen kann.

„Gut, aber eines habe ich nicht verstanden: Wie kann ein Calculate-Ereignis auftreten, wenn die Werte prev_calculated und rates_total gleich sind? Wäre das nicht eine Zeitverschwendung, da die Schleife in Zeile 21 keine Aktion ausführt?“ Ja, das ist wahr. MetaTrader 5 löst das Ereignis Berechnen jedoch nicht willkürlich aus. Sie wird nur ausgelöst, wenn sich der Preis des Symbols ändert. In Zeiten hoher Marktvolatilität kommt es daher zu einer wahren Lawine von Ereignissen. Wenn Ihr Code schlecht optimiert ist, wird die Plattform mit der Zeit langsam, aber der Fehler liegt nicht bei ihr, sondern bei der schlecht optimierten Anwendung, die Zeit und Ressourcen verbraucht.

Abschließende Gedanken

In diesem Artikel werden wir unseren ersten voll funktionsfähigen und praktischen Indikator erstellen. Ziel ist es nicht, zu zeigen, wie man eine Anwendung erstellt, sondern dem Leser zu helfen, seine eigenen Ideen sicher, einfach und praktisch zu entwickeln, und Ihnen die Möglichkeit zu geben, sie sicher, einfach und praktisch anzuwenden.

Da dieses Thema gründlich verstanden und studiert werden sollte, werde ich es nicht über das Notwendige hinaus ausdehnen, denn das würde das Material viel dichter und komplexer machen und ein ruhiges Studium verhindern. Der Anhang enthält zwei der hier vorgestellten Codes. Mit ihnen können Sie die Schritt-für-Schritt-Anleitung in diesem Artikel befolgen.

Im nächsten Artikel werden wir das Thema von heute fortsetzen, da die zweite Form der Deklaration der OnCalculate-Funktion noch untersucht werden muss.