Von der Grundstufe bis zur Mittelstufe: Ereignisse (I)

Einführung

Im vorherigen Artikel, Von der Grundstufe zur Mittelstufe: Struct (II), haben wir grundlegende Strukturen besprochen und wie wir sie zur Übergabe von Werten an Funktionen und Prozeduren verwenden können. Auch wenn das Thema Strukturen noch nicht vertieft wurde, glaube ich, dass dies noch nicht der richtige Zeitpunkt ist, um auf bestimmte Aspekte einzugehen, die es gibt und die sich mit Strukturen umsetzen lassen. Das liegt daran, dass wir hier in MQL5, soweit ich das beobachten konnte, nicht wirklich eine Programmierung auf sehr hohem Niveau benötigen. Verstehen Sie mich bitte nicht falsch.

Was ich meine ist, dass Sie mit sehr wenig Wissen, aber mit einer gut entwickelten konzeptionellen Grundlage, fast jede Art von Anwendung für MetaTrader 5 erstellen und implementieren können. Und da Sie in 95 % der Fälle (wenn nicht sogar in einem noch größeren Prozentsatz) tatsächlich nur einfache Anwendungen entwickeln werden, sehe ich keinen Grund, im Moment auf einige der komplexeren Details einzugehen.

Daher werde ich bei den Erklärungen zu den grundlegenden Programmierkonzepten eine Pause einlegen. Wir werden stattdessen sehen, wie man eine Anwendung für MetaTrader 5 mit reinem MQL5 implementiert.

Da dieser Artikel darauf abzielt, die Grundlagen dieser Art der Code-Implementierung in MQL5 zu erläutern, beginnen wir mit der einfachsten aller Implementierungen. Aber vorher müssen wir noch ein anderes Thema besprechen.

Grundlegendes Konzept der Ereignisse

Ich werde hier nicht zu sehr ins Detail gehen, da die Erörterung dessen, worauf sich der Titel dieses Themas bezieht, leicht zu einem ganzen Buch über Programmierung führen könnte – und das meine ich ganz wörtlich. Dies ist ein sehr umfangreiches Thema, das viele Nuancen aufweist. Wir müssen jedoch unser Verständnis ein wenig angleichen, bevor wir über die Implementierung einer Anwendung sprechen, die in MetaTrader 5 verwendet werden soll.

Praktisch jede grafische Anwendung verwendet Ereignisse. Der Zeitpunkt, zu dem ein bestimmtes Ereignis erzeugt wird, hängt im Allgemeinen nicht davon ab, was wir implementieren. Es gibt spezielle Fälle, in denen wir Ereignisse aus unserer eigenen Anwendung heraus auslösen können. Da es sich hierbei jedoch um Sonderfälle handelt, sollten Sie sie keinesfalls als eine Möglichkeit zur Kontrolle Ihres Codes betrachten. In der Tat ist ein Programmierer, der eine Art von Code implementiert, der in einer bestimmten Umgebung ausgeführt werden soll, oft nicht wirklich ein „Programmierer“ im traditionellen Sinne. Sie legen fest, wie ihr Code auf jedes eintreffende Ereignis reagieren soll.

Einige Ereignisse können in einer Anwendung ignoriert werden, während sie in einer anderen Anwendung Vorrang vor allen anderen Aktivitäten haben können. Dies zu verstehen, ist für viele Anfänger sehr kompliziert und schwierig, denn bis zu diesem Punkt war der gesamte vorgestellte Code NICHT FÜR DIE HANDHABUNG VON EREIGNISSEN GEDACHT. Er hat einfach das ausgeführt, wozu er programmiert wurde.

Wenn wir jedoch einen Indikator oder sogar einen Expert Advisor für den MetaTrader 5 programmieren, geht es uns überhaupt nicht darum, Dinge geschehen zu lassen, so seltsam das auch klingen mag. Was uns eigentlich interessiert, ist die Definition, wie der Indikator oder Expert Advisor auf ein bestimmtes Ereignis reagieren soll.

Wenn Sie zum Beispiel ein Programm wie Gimp verwenden, mit dem Sie in einem Fenster zeichnen können, stellen Sie sich vielleicht vor, dass das Programm auf eine bestimmte Art und Weise funktioniert. Aber im Grunde reagiert es nur auf Ereignisse, die Sie selbst erzeugen, wie z. B. einen Mausklick, einen Tastendruck oder das Ziehen der Maus. All dies sind Ereignisse. Das Programm WEISS NICHT, was Sie tun und ist auch nicht daran interessiert, dies zu überwachen. Er wartet einfach auf ein Ereignis und reagiert darauf. Am Ende haben Sie ein manipuliertes und gezeichnetes Bild.

Das Gleiche geschieht mit MetaTrader 5. Dabei ist es egal, was der Nutzer gerade tut. Er wartet einfach darauf, dass ein bestimmtes Ereignis eintritt. Wenn das Ereignis eintritt, reagiert es in irgendeiner Weise darauf.

Aber warten Sie einen Moment. Wer ist dann für die Entstehung der Ereignisse verantwortlich? Nun, ohne zu sehr ins Detail zu gehen: Sie sind es. Die Verantwortung für die Entscheidung, welche grafische Anwendung welches Ereignis erhält, liegt jedoch beim Betriebssystem. Sie als Nutzer können dies nicht vorschreiben. Sie teilen dem Betriebssystem lediglich mit, dass eine bestimmte Anwendung eine bestimmte Aktion ausführen soll, z. B. minimiert oder maximiert werden soll oder was passieren soll, wenn Sie die Anwendung schließen möchten.

Im Gegensatz zu dem, was viele Leute denken, ist die Instanz, die tatsächlich entscheidet, wie eine Anwendung geschlossen wird, NICHT das Betriebssystem, sondern die Anwendung selbst. Deshalb fragt der Editor, wenn Sie Text eingeben und das Bearbeitungsfenster schließen möchten, ob Sie die Änderungen speichern möchten oder nicht. Müsste das Betriebssystem diese Aufgabe übernehmen, wäre die Sache weitaus komplizierter. Letztendlich ist es die Anwendung selbst, die entscheidet, wie sie auf ein Ereignis reagiert, und niemals das Betriebssystem. Aus diesem Grund ist die Behauptung, ein System sei besser als ein anderes, meines Erachtens ein Mangel an Verständnis dafür, wie die Dinge tatsächlich funktionieren.

Obwohl MetaTrader 5 auch auf anderen Betriebssystemen als Windows ausgeführt werden kann, gehen wir davon aus, dass er immer noch unter Windows läuft. Auch wenn Sie die WEB-Version des MetaTrader 5 Terminals verwenden, werden wir zur Vereinfachung der Erklärung Windows als Systembasis festlegen.

Warum wird dieses Konzept erstellt? Der Grund dafür ist, dass Sie, wenn Sie lernen möchten, wie man für MetaTrader 5 programmiert, verstehen müssen, dass jede Anwendung, die innerhalb von MetaTrader 5 läuft, nicht direkt auf Ereignisse reagiert, die von Windows kommen, sondern eher auf Ereignisse, die von MetaTrader 5 selbst kommen. Noch einmal: Es gibt bestimmte Situationen, in denen eine Anwendung, die in MetaTrader 5 läuft, tatsächlich direkt auf Windows reagiert. Dies ist jedoch sehr spezifisch und erfordert ein sehr fortgeschrittenes Niveau der Programmierung, das im Moment nicht gegeben ist.

Nun, da diese Punkte genannt wurden und wir ein gewisses Verständnis haben, können wir alles, was erwähnt wurde, in ein Bild setzen. Dies ergibt das unten gezeigte Bild.

Abbildung 01

Dieses Bild ist sehr aussagekräftig, denn es zeigt den Weg von einem Ereignis, das der Nutzer erzeugt, bis zu dem Moment, in dem eine in MetaTrader 5 laufende Anwendung das gleiche Ereignis empfängt. Beachten Sie, dass es sich bei einer Anwendung, die wir als Expert Advisor bezeichnen, eigentlich um jede Art von Anwendung handeln kann, die in MetaTrader 5 ausgeführt werden kann. Da der Expert Advisor jedoch auf die meisten Ereignisse reagiert, habe ich ihn als Möglichkeit genutzt, um zu zeigen, wo unsere Anwendung in diesem ganzen Szenario stehen würde.

Das war der einfache Teil, jetzt kommt der lustige Teil. Es gibt zwei Arten von Ereignissen: synchrone und asynchrone. Synchrone Ereignisse können von der Art sein, die alle x Zeitperioden auftreten und daher in irgendeiner Weise mit der Systemuhr verbunden sind. Ein Beispiel für diese Art von Ereignis ist das Erscheinen eines neuen Balkens im Chart. Das wird immer mal wieder vorkommen. Wir können jedoch auch synchrone Ereignisse haben, die von asynchronen Ereignissen ausgehen, was einige Dinge recht interessant macht. Bevor wir jedoch über synchrone Ereignisse sprechen, die aus asynchronen Ereignissen hervorgehen, müssen wir verstehen, was ein asynchrones Ereignis ist.

Ein asynchrones Ereignis ist ein zufällig erzeugtes Ereignis. Zum Beispiel ein Tastendruck, eine Mausbewegung oder sogar das Öffnen oder Schließen einer Position. In diesem speziellen Fall würde die Position eröffnet oder geschlossen werden, weil der Preis ein bestimmtes Niveau erreicht hat. Kurz gesagt, ein asynchrones Ereignis ist jedes Ereignis, dessen Zeitpunkt und Reihenfolge Sie nicht vorhersagen können.

Wie bereits erwähnt, können wir jedoch auch synchrone Ereignisse auf der Grundlage asynchroner Ereignisse haben. Ein Beispiel für diese Art von Situation wäre, wenn Sie etwas in einem MetaTrader 5-Chart auswählen und dann das Objekt ziehen oder löschen. Der genaue Zeitpunkt, zu dem die einzelnen Ereignisse eintraten, spielt keine Rolle, aber sie geschahen in einer bestimmten Reihenfolge oder Sequenz. Aus diesem Grund haben viele Menschen Schwierigkeiten, bestimmte Arten von Anwendungen zu programmieren. Es kann notwendig sein, auf synchrone Ereignisse zu reagieren, die von asynchronen Ereignissen herrühren. Auf jeden Fall brauchen Sie sich jetzt keine Sorgen zu machen. Im weiteren Verlauf der Artikel werden wir sehen, wie man mit dieser Art von Situation umgehen kann.

Erste Ereignisse in der Praxis

Dies ist ein Moment, der zugegebenermaßen eine gewisse Herausforderung darstellt. Der Grund dafür ist, dass ich Ihnen zeigen möchte, wie Ereignisse ablaufen. Gleichzeitig möchte ich nicht etwas schaffen, das nicht viel Sinn macht. Daher müssen wir auf einige Mittel zurückgreifen, die einfach zu verstehen und gleichzeitig selbsterklärend sind. Auf diese Weise werden wir nicht zu viel Zeit damit verbringen, zu erklären, wie Ereignisse passieren und wie sie gehandhabt werden. Diese Art von Thema ist für diejenigen, die sich mit Ereignissen auskennen, recht intuitiv, kann aber für diejenigen, die das nicht tun, sehr verwirrend sein. Lassen Sie uns also einen ersten Versuch unternehmen, Ereignisse in der Praxis zu erfassen und zu verarbeiten.

Bevor wir beginnen, müssen wir eine Sache verstehen, die in MQL5 besonders präsent ist: die Unterteilung zwischen verschiedenen Arten von Anwendungen. Grundsätzlich gibt es in MQL5 zwei Arten von Anwendungen: solche, die auf Nutzerereignisse reagieren können, und solche, die nicht auf Nutzerereignisse reagieren können, zumindest nicht direkt. Es ist ganz einfach. Zu denjenigen, die Ereignisse der Nutzerinteraktion erfassen und entsprechend darauf reagieren können, gehören Indikatoren und Expert Advisors. Diejenigen, die nicht auf Nutzerereignisse reagieren können, weil sie diese nicht erfassen können, sind Skripte und Dienste. Es ist sehr wichtig, dies zu wissen, damit Sie die beste Alternative zur Annahme wählen können.

Nun, bis zu diesem Punkt haben wir im Grunde nur mit Skripten gearbeitet. In ihnen gibt es einen einzigen Einstiegspunkt, nämlich die OnStart-Prozedur. Von da an muss alles von Ihnen, dem Programmierer, erstellt und kontrolliert werden. Aber im aktuellen Fall wollen wir Ereignisse erfassen, was auch immer sie sein mögen. Deshalb müssen wir verstehen, was jedes Modell, das im MetaTrader 5 erlaubt ist, uns bieten kann.

Wenn Sie diesen Artikel lesen, haben Sie sicherlich schon (zumindest teilweise) mit MetaTrader 5 experimentiert, indem Sie die Anwendungen verwendet haben, die standardmäßig mitgeliefert werden. In diesem Fall haben Sie sicher bemerkt, dass wir mehrere Indikatoren auf demselben Chart haben können. Es kann jedoch immer nur einen einzigen Expert Advisor geben. Je nach Zielsetzung können wir also Dinge entweder in einem Indikator oder in einem Expert Advisor implementieren.

Es gibt jedoch ein kleines Detail, das verstanden werden muss, bevor mit der Implementierung des Codes selbst begonnen wird. Dieses Detail bezieht sich auf die Einschränkungen, die bei Indikatoren und Expert Advisors bestehen. Und ja, es gibt Einschränkungen.

Zum Beispiel kann ein Indikator KEINEN Kontakt zu dem Auftragssystem herstellen. Dies gilt ausschließlich für den Expert Advisor. Andererseits kann ein Expert Advisor NICHT, zumindest nicht auf einfache Art und Weise, Linien zeichnen und Berechnungen durchführen, die darauf abzielen, etwas auf dem Chart anzuzeigen. Im Prinzip hat ein Expert Advisor KEINE MÖGLICHKEIT, auf MQL5-Bibliotheksfunktionen zuzugreifen, um auf dem Chart zu zeichnen. Diese sind exklusiv für Indikatoren. Aus diesem Grund ist es sehr wichtig zu wissen, wie man mit diesen Modellen arbeitet. Und das wird in den Artikeln immer wieder gezeigt.

Na gut, werden Sie jetzt vielleicht denken: „Aber dann gibt es keine Möglichkeit, etwas wirklich Nützliches zu schaffen, denn es gibt Einschränkungen, die uns daran hindern, eine wirklich einzigartige Anwendung zu entwickeln.“ In der Tat, lieber Leser, wurde MetaTrader 5 als sehr stabile und sichere Plattform konzipiert. Aus diesem Grund gibt es Mechanismen, die die Kommunikation zwischen verschiedenen Anwendungen ermöglichen, was uns die Möglichkeit gibt, etwas wirklich Interessantes zu schaffen, das auf lange Sicht leicht zu pflegen ist.

Nach dieser ersten kurzen Einführung in das Thema wollen wir uns zunächst ansehen, wie die Ereignisse erfasst werden. Vorerst werden wir uns nicht um ihre Handhabung kümmern, sondern nur um ihre Erfassung. Zu diesem Zweck werden wir einen Indikator verwenden. Er ist unten in seiner minimalen Codeform zu sehen.

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 01

Wir beginnen mit minimalem Code, um das Konzept eines Ereignisses leichter verständlich zu machen. Es hat keinen Sinn, Code einfach zu kopieren, ohne zu verstehen, warum er auf diese Weise implementiert werden muss.

In dem Moment, in dem dieser Indikator auf dem Chart platziert wird, werden einige Dinge in einer bestimmten logischen Reihenfolge geschehen. Dies zu verstehen ist sehr wichtig, wenn Sie mit der Erstellung Ihres eigenen Codes beginnen wollen. In diesem Code 01 werden zwei Ereignisse aufgezeichnet. Und die Art und Weise, wie MetaTrader 5 mit diesen Ereignissen zusammenarbeitet, bestimmt, wie wir sie behandeln sollten. Ich weiß, dass dies auf den ersten Blick etwas verwirrend sein mag. Wir können unsere Anwendung jedoch so gestalten, dass sie interagiert und Dinge tut, an die die Entwickler bei der Entwicklung von MetaTrader 5 nicht gedacht haben. Um dies zu erreichen, müssen wir wissen, wie und wann die einzelnen Ereignisse ausgelöst werden.

Da wir uns noch in einem frühen Stadium befinden und uns nur auf die Didaktik konzentrieren, werde ich natürlich nicht zeigen, wie Sie MetaTrader 5 zu Dingen „zwingen“ können, die viele für unmöglich halten. Aber wenn Sie viel lernen und üben, können Sie mit MetaTrader 5 praktisch alles mit MQL5 machen: zum Beispiel einen Video- oder Bildeditor. Dinge, für die MetaTrader 5 nicht gedacht war, da sein Hauptzweck darin besteht, den Kauf und Verkauf von Vermögenswerten zu ermöglichen, die auf einem elektronischen Markt gehandelt werden.

Sehr gut. Nun können wir die Abbildung 01 erweitern, um den Code 01 anzuzeigen, der ein Indikator ist. Daraus ergibt sich der folgende Nachrichtenfluss.

Abbildung 02

Abbildung 02 zeigt eine Fortsetzung von Abbildung 01. Was wir in Abbildung 02 sehen, ist das, was intern an der letzten Stelle, an der die Ereignisse verarbeitet werden, passieren würde. Da wir hier die Dinge in eine bestimmte Richtung lenken, könnte es für Sie interessant sein, etwas mehr über andere Arten von Ereignissen zu erfahren, die ich in diesen Artikeln nicht behandeln werde.

Dazu empfehle ich Ihnen, einen Blick in die MQL5-Dokumentation unter Ereignisbehandlungsfunktionen zu werfen. Dort erhalten Sie eine viel detailliertere Vorstellung davon, wie viele Ereignisse es gibt und die von MQL5 abgedeckt werden, jede mit ihrem eigenen Zweck und Ziel.

Aber zurück zu unserem Thema: Wir wollen verstehen, wann jedes der in Code 01 genannten Ereignisse ausgelöst wird. Um dies zu verstehen, müssen wir nur einen kleinen Befehl hinzufügen, den wir bereits in früheren Artikeln verwendet haben. Somit sieht derselbe Code 01 nun wie unten dargestellt aus:

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

Code 02

Gut, jetzt wissen wir, was hinter den Kulissen vor sich geht. Aber wenn Sie sich diesen Code 02 ansehen, werden Sie vielleicht denken: „Aber dieser Code ist absolut nicht nützlich. Warum so etwas schaffen?“ Nun, liebe Leserin, lieber Leser, in der Tat ist dieser Code äußerst nützlich für das, was wir tun wollen. Beachten Sie Folgendes: Das Einzige, was dieser Code bewirkt, ist die Ausgabe einer Meldung im Terminal, die angibt, welches Ereignis erfasst wird. Dies geschieht in den Zeilen 06 und 13. Schauen wir uns jedoch an, was passiert, wenn wir sie auf einem beliebigen Chart platzieren.

Animation 01

In dieser Animation 01 können wir sehen, wann MetaTrader 5 ein Ereignis ausgelöst hat, das von unserem Indikator in Code 02 erfasst wurde. Und das ist genau das, was Sie, liebe Leserin, lieber Leser, bemerken. Obwohl unser einfacher Code scheinbar völlig nutzlos war, konnte er uns zeigen, wie ein von MetaTrader 5 ausgelöstes Ereignis etwas bewirkte, das von uns programmiert wurde. In diesem Fall behandeln wir die erfassten Ereignisse, indem wir eine Meldung im Terminal ausgeben – etwas, das auf den ersten Blick nicht zu passieren scheint. Achten Sie auf die Reihenfolge der Auslöser. Beachten Sie auch, dass Zeile 13 zweimal vorkommt: das erste Mal, als der Indikator auf dem Chart platziert wurde, und das zweite Mal, als sich der Preis des Symbols änderte.

Dies zu verstehen ist äußerst wichtig und wird uns von großem Nutzen sein. Da wir es mit Ereignissen zu tun haben, die von MetaTrader 5 kommen, bedeutet dies, dass wir die Art und Weise der Code-Implementierung bei der Arbeit mit Indikatoren und Expert Advisors ändern müssen, die als einzige auf Ereignisse reagieren, die von MetaTrader 5 ausgelöst werden.

Ausgezeichnet. Nehmen wir nun eine weitere Änderung an Code 02 vor, um eine weitere Ereignisbehandlung hinzuzufügen. Der auszuführende Code ist unten zu sehen:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. int OnInit()
05. {
06.    Print(__FUNCTION__);
07. 
08.    return INIT_SUCCEEDED;
09. };
10. //+------------------------------------------------------------------+
11. int OnCalculate(const int rates_total, const int prev_calculated, const int begin, const double &price[])
12. {
13.    Print(__FUNCTION__);
14. 
15.    return rates_total;
16. };
17. //+------------------------------------------------------------------+
18. void OnDeinit(const int reason)
19. {
20.    Print(__FUNCTION__);
21. };
22. //+------------------------------------------------------------------+

Code 03

Wieder einmal haben wir ein sehr einfaches Stück Code, das offensichtlich nichts Nützliches tut. Wenn wir sie jedoch ausführen, sehen Sie sich an, was passiert.

Animation 02

Genau wie im ersten Fall, in dem wir versucht haben zu beobachten, wie unsere Anwendung auf Ereignisse reagiert, die vom MetaTrader 5 ausgelöst werden, haben wir hier eine andere Art der Erfassung. Ich möchte, dass Sie Folgendes verstehen: Der Indikator war auf dem Chart vorhanden, und das Chart verwendete einen bestimmten Zeitrahmen. Sobald wir den Zeitrahmen ändern, wird ein Ereignis ausgelöst, das wiederum von dem in Code 03 dargestellten Indikator erfasst wird.

Jetzt kommt der Teil, der uns interessiert. Wenn der Wechsel des Zeitrahmens eintrat, während der in Code 02 dargestellte Indikator im Chart vorhanden war, ging dieses Ereignis einfach verloren. Besser gesagt, wir haben die Tatsache ignoriert, dass MetaTrader 5 dies auslösen würde, und haben einfach Folgendes gesagt:

„Hören Sie, MetaTrader 5, tun Sie alles, was nötig ist, damit alles funktioniert, denn ich habe kein Problem damit.“

MetaTrader 5 hat also das Ereignis ausgelöst, aber Code 02 hat es ignoriert. Daher hatten wir den Eindruck, dass der Indikator einfach weiß, wie er sich in einer solchen Situation zu verhalten hat. Das ist jedoch nicht immer das, was wir eigentlich wollen. In solchen Situationen können wir eine Prozedur verwenden, die in Zeile 18 des Codes 03 gezeigt wird, um dieses Ereignis zu erfassen und die entsprechenden Maßnahmen zu ergreifen, damit keine weiteren unerwarteten Ereignisse eintreten können.

Ich weiß, dass viele von Ihnen, vor allem diejenigen, die bereits mit der MQL5-Programmierung vertraut sind, vielleicht denken, dass wir uns keine Gedanken über viele Ereignisse in einem Indikator machen müssen. Es gibt jedoch Situationen, in denen Sie, wenn Sie bestimmte Ereignisse einfach ignorieren, mit seltsamen Fehlern konfrontiert werden können, die von MetaTrader 5 gemeldet werden. Wenn Ihre Anwendung nicht die entsprechenden Maßnahmen ergreift, nimmt sich MetaTrader 5 die Freiheit, alles Nötige zu tun, um sicherzustellen, dass Probleme in Ihrem Code nicht das allgemeine Funktionieren der Plattform beeinträchtigen.

Obwohl viele glauben, dass Indikatoren kaum Fehler haben können, treten Fehler auf. Wenn dies geschieht und MetaTrader 5 ein Ereignis auslöst, das unser Code ignoriert, kann es zu Leistungsproblemen der Plattform kommen, z. B. zu Verlangsamungen oder sogar zum Einfrieren. Es liegt jedoch nicht an MetaTrader 5, sondern an Ihrer Anwendung, die nicht richtig auf die ausgelösten Ereignisse reagiert.

Um diese Art von Situation zu demonstrieren, implementieren wir ein sehr einfaches Stück Code, mit einem sehr einfachen, aber sehr interessanten Ziel: uns zu sagen, wie oft das OnCalculate-Ereignis in einem bestimmten Zeitraum ausgelöst wurde. Dieser Code ist unten zu sehen:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. uint gl_Counter;
05. //+------------------------------------------------------------------+
06. int OnInit()
07. {
08.    gl_Counter = 0;
09. 
10.    Print(__FUNCTION__);
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.    if (!gl_Counter)
18.    {
19.       uint arr[];
20. 
21.       if (FileLoad(_Symbol, arr) > 0)
22.          gl_Counter = arr[0];
23.    }
24.    
25.    Print(__FUNCTION__, " :: ", ++gl_Counter);
26. 
27.    return rates_total;
28. };
29. //+------------------------------------------------------------------+
30. void OnDeinit(const int reason)
31. {
32.    uint arr[1];
33. 
34.    arr[0] = gl_Counter;
35.    FileSave(_Symbol, arr);
36. 
37.    Print(__FUNCTION__);
38. };
39. //+------------------------------------------------------------------+

Code 04

Es gibt nichts in diesem Kodex, was wir nicht schon gesehen und besprochen haben, sodass er für jeden, der das in diesen Artikeln Gezeigte studiert und praktiziert, recht verständlich ist. Der einzige Teil, der vielleicht Zweifel aufkommen lässt, ist der, der sich auf die Funktionen FileLoad und FileSave bezieht. Da sie in der offiziellen Dokumentation sehr gut erklärt sind, werde ich in diesem Artikel nicht weiter darauf eingehen.

Bei der Ausführung dieses Codes 04 wird jedoch etwas Ähnliches wie unten gezeigt erzeugt.

Animation 03

Beachten Sie, dass der Zähler trotz der Änderung des Zeitrahmens weiter hochzählt. Dies geschieht, weil wir in Zeile 30 von Code 04 das Ereignis erfassen, das MetaTrader 5 auslöst, wenn unser Code etwas tun muss. In diesem Fall behandeln wir keine der Ursachen, die MetaTrader 5 zum Auslösen des Ereignisses veranlasst haben. Wir weisen MetaTrader 5 einfach an, eine bestimmte Variable auf der Festplatte zu speichern. Wir könnten dies auf viele andere Arten tun, wie wir gleich noch erläutern werden. Unser Ziel ist es jedoch zu zeigen, dass es Situationen geben kann, in denen wir ein Ereignis behandeln müssen, während wir in anderen Situationen dasselbe Ereignis ignorieren können. Alles hängt davon ab, was wir erreichen wollen und wie wir unser Endziel erreichen wollen.

Wenn es die Prozedur in Zeile 30 nicht gäbe oder wenn wir sie nicht richtig handhaben würden, würde der Zähler jedes Mal, wenn wir den Zeitrahmen ändern, wieder bei Null anfangen. Das liegt daran, was in Zeile acht passiert, wo wir anfangen zu zählen, wie oft OnCalculate ausgeführt wurde. Dieser Code ist ziemlich interessant, nicht wahr? Etwas Einfaches, aber etwas, das es uns ermöglicht, verschiedene Probleme im Zusammenhang mit Ereignissen, die von MetaTrader 5 generiert werden, zu verstehen.

Abschließende Überlegungen

In diesem Artikel haben wir angefangen, viel mehr Spaß zu haben. Dies ist der erste Teil einer Reihe von Artikeln, in denen wir uns mit der Behandlung von Ereignissen beschäftigen werden. Ich werde versuchen, mich diesem Thema auf spielerische, einfache und didaktische Weise zu nähern und Ihnen zu zeigen, dass wir nicht immer die von einem anderen Programmierer vorgeschlagene Lösung verwenden sollten. Denn in einer Vielzahl von Situationen ist die von einer Person vorgeschlagene Lösung möglicherweise nicht die ideale Lösung für Sie in diesem speziellen Moment.

Ich weiß, dass viele gespannt sind auf das, was in den nächsten Artikeln behandelt werden wird. Doch bevor Sie sich kopfüber in etwas stürzen, das immer komplexer wird, sollten Sie versuchen, das in diesem Artikel Behandelte zu üben und zu lernen. Ich garantiere Ihnen, dass es sich lohnt, zu üben und zu versuchen, das hier Dargestellte zu verstehen. Als Tipp und Anreiz zum Nachdenken darüber, was praktiziert werden kann, versuchen Sie, den unten angehängten Code 04 so zu ändern, dass der Zählerwert nur dann gespeichert wird, wenn ein Zeitrahmenänderungsereignis eintritt. Bei jeder anderen Art von Ereignis, das MetaTrader 5 auslösen kann, sollte der Zähler wieder auf Null zurückgesetzt werden.

Im nächsten Artikel werde ich zeigen, wie Sie dies auf sehr sichere und einfache Weise tun können. Also ran an die Arbeit und viel Spaß beim Lernen.