Nachschlagewerk MQL5MQL5 ProgrammeProgrammausführung

Durchführung der Programme

Jedes Skript, jeder Dienst und jeder Expert Advisor läuft in einem separaten Thread. Alle Indikatoren, die auf einem Symbol berechnet werden, auch wenn sie verschiedenen Charts zugeordnet sind, arbeiten im gleichen Thread. Somit teilen sich alle Indikatoren auf einem Symbol die Ressourcen eines Threads.

Alle anderen Aktionen, die mit einem Symbol verbunden sind, wie die Verarbeitung von Ticks und die Synchronisation der Geschichte werden auch konsequent in dem selben Thread mit Indikatoren durchgeführt. Dies bedeutet, dass, wenn der Indikator hält unendliche Aktion, alle anderen Ereignisse in diesem Symbol nie durchgeführt werden.

Beim Starten eines Expert Advisors, stellen Sie sicher dass er aktuelle Handelsumwelt hat und Geschichte des Symbols für die Periode, und synchronisieren Sie Daten zwischen dem Terminal und dem Server. Für alle diese Verfahren stellt das Terminal eine Startverzögerung von nicht mehr als 5 Sekunden, wonach der Expert Advisor mit verfügbaren Daten gestartet wird. Daher, wenn es kein Verbindung zum Server gibt, kann dies zu einer Verzögerung des Starts des Expert Advisors führen.

Eine kurze Zusammenfassung des MQL5-Programmen ist in der Tabelle dargestellt:

Programm	Durchführung	Bemerkung
Service (Dienst)	Ein separater Thread, die Anzahl der Threads für Dienste ist gleich der Anzahl der Dienste.	Ein Dienst mit einer Schleife kann den Betrieb anderer Programme nicht unterbrechen.
Skript	In einem eigenen Thread, wie viele Skripte, so viele Ausführungsthreads für sie	Ein endloses Skript kann nicht Ausführung andere Programme brechen
Expert Advisor	In einem eigenen Thread, wie viele Expert Advisors, so viele Ausführungsthreads für sie	Ein endloser Expert Advisor nicht Ausführung andere Programme brechen
Indikator	Ein Thread für alle Indikatoren auf ein Symbol. Wie viele Symbole mit Indikatoren, so viele Ausführungsthreads für sie	Eine Endlosschleife in einem des Indikators wird Ausführung aller anderen Indikatoren auf diesem Symbol stoppen

Sofort nach Anhängen des Programms zum Chart Erfolgt sein Einspeichern in Client-Terminal und in Speicher des Client-Terminals und Initialisierung der globalen Variablen. Wenn eine der globalen Variablen des Typen Klasse Konstrukteur hat, wird dieser Konstrukteur während der Initialisierung der globalen Variablen aufgerufen werden.

Danach wartet das Programm auf das Ereignis vom Client-Terminal. Jedes mql5-Programm muss wenigstens eine Funktion-Bearbeiter des Ereignisses haben, sonst wird das Programm nicht durchgeführt werden. Funktionen-Bearbeiter haben vorbestimmte Namen, vorbestimmte Parametervorraete und vorbestimmte Rückkehrtypen.

Typ	Funktionsname	Parameter	Anwendung	Bemerkung
int	OnInit	keine	Experten und Anzeiger	Bearbeiter des Ereignisses Init. Zugelassen Typ des Rückgabewertes void.
void	OnDeinit	const int reason	Experten und Anzeiger	Bearbeiter des Ereignisses Deinit.
void	OnStart	keine	Skripte und Dienste	Start Ereignisbehandlung.
int	OnCalculate	const int rates_total, const int prev_calculated, const datetime &Time[], const double &Open[], const double &High[], const double &Low[], const double &Close[], const long &TickVolume[], const long &Volume[], const int &Spread[]	Anzeiger	Bearbeiter des Ereignisses Calculate für alle Preisdaten.
int	OnCalculate	const int rates_total, const int prev_calculated, const int begin, const double &price[]	Anzeiger	Ereignisbearbeiter Calculate in einem Datenfeld. In Indikator können nicht 2 Bearbeiter Calculate gleichzeitig sein. In diesem Fall wird nur ein Ereignisbearbeiter Calculate in einem Datenfeld funktionieren.
void	OnTick	keine	Experten	Ereignisbearbeiter NewTick. Wenn das Ereignis des neuen Ticks verarbeitet wird, werden andere Ereignisse dieses Typs nicht aufgenommen.
void	OnTimer	keine	Experten und Anzeiger	Ereignisbearbeiter Timer.
void	OnTrade	keine	Experten	Ereignisbearbeiter Trade.
double	OnTester	keine	Experten	Ereignisbearbeiter Tester.
void	OnChartEvent	const int id, const long &lparam, const double &dparam, const string &sparam	Experten und Indikatoren	Ereignisbearbeiter ChartEvent.
void	OnBookEvent	const string &symbol_name	Experten und Indikatoren	Ereignisbearbeiter BookEvent.

Der Client-Terminal sendet die neuen Ereignisse in die entsprechende offene Charts. Darüber hinaus können die Ereignisse durch Charts (Chartsereignisse) oder MQL5-Programme (benutzerdefinierte Ereignisse) generiert werden. Generierung von Ereignisse der Erstellung oder Löschen von graphischen Objekten auf einen Chart kann durch CHART_EVENT_OBJECT_CREATE und CHART_EVENT_OBJECT_DELETE Chartseigenschaften aktiviert oder deaktiviert werden. Jedes MQL5-Programm und jeder Chart hat eine eigene Warteschlange von Ereignissen, in die alle neu eingehenden Ereignisse hinzugefügt werden.

Ein Programm erhält Ereignisse nur aus dem Chart, auf dem es läuft. Alle Ereignisse werden nacheinander in der Reihenfolge des Eingangs bearbeitet. Wenn eine Warteschlange bereits eine NewTick Ereignis hat, oder dieses Ereignis ist gerade in Bearbeitung, dann wird nicht die neue NewTick Ereignis in der Warteschlange des MQL5 Programms platziert. Auch wenn ChartEvent bereits in der Warteschlange ist, oder dieses Ereignis in Bearbeitung ist, wird kein neues Ereignis dieser Art eingerichtet werden. Die Timer-Ereignisse werden auf die gleiche Weise behandelt – wenn ein Timer-Ereignis in der Warteschlange ist oder behandelt wird, die neue Timer-Ereignis wird nicht in der Warteschlange platziert.

Ereignis-Warteschlangen haben eine begrenzte, aber ausreichende Größe, so dass die Warteschlange-Überlauf für gut geschriebene Programme unwahrscheinlich ist. Im Falle einer Warteschlange-Überlauf, werden neue Ereignisse ohne Wartezeiten verworfen.

Es wird dringend empfohlen, keine Endlosschleifen zur Behandlung von Ereignissen zu verwenden. Mögliche Ausnahmen sind Skripte und Dienste, die ein einzelnes Start-Ereignis behandeln.

Bibliotheken verarbeiten keine Ereignisse.

Das Verbot der Verwendung von Funktionen in Indikatoren und Experten

Indikatoren, Skripte und Expert Advisors sind in MQL5 geschriebene ausführbare Programme. Sie sind für verschiedene Arten von Aufgaben ausgelegt. Deshalb gibt es einige Beschränkungen für die Verwendung bestimmter Funktionen, abhängig von der Art des Programms. Die folgenden Funktionen werden in Indikatoren verboten:

Alle Funktionen für Indikatoren sind in Expert Advisors und Skripte verboten:

Die Bibliothek ist kein eigenständiges Programm und wird im Rahmen des Programms MQL5, die sie aufgerufen hat, ausgeführt: Skript, Indikator oder Expert Advisor. Dementsprechend werden die oben genannten Beschränkungen für die genannte Bibliothek angewendet.

Die in den Diensten verbotenen Funktionen

Die Dienste akzeptieren keine Ereignisse, da sie nicht an ein Chart gebunden sind. Die folgenden Funktionen sind bei Diensten verboten:

ExpertRemove();

EventSetMillisecondTimer();

EventSetTimer();

EventKillTimer();

SetIndexBuffer();

IndicatorSetDouble();

IndicatorSetInteger();

IndicatorSetString();

PlotIndexSetDouble();

PlotIndexSetInteger();

PlotIndexSetString();

PlotIndexGetInteger();

Laden und Ausladen der Indikatoren

Indikatoren werden in folgenden Fällen ausgeladen:

Anhängen des Indikators zum Chart;
Start des Terminals (wenn Indikator vor dem früheren Terminalschliessen zum Chart angehängt wurde);
Laden der Schablone (wenn in der Schablone Indikator angegeben wird, angehängt zum Chart);
Profilwechsel (wenn Indikator zum einen der Profilcharts angehängt wird);
Wechsel des Symbols und/oder Chartperiode, zu dem der Indikator angehängt wird;
Änderung des Kontos, zu dem das Terminal verbunden ist;
nach erfolgreicher Neucompilierung des Indikators, wenn dieser Anzeiger zum Chart angehängt wurde.
Wechsel der Eingabeparameter des Indikators.

Indikatoren werden in folgenden Fällen ausgeladen:

bei Abtrennung des Indikators vom Chart;
Terminalschliessen (wenn Indikator zum Chart angehängt wurde);
Laden der Schablone, Indikator zum Chart angehängt wird;
Schliessen des Charts, zu dem Indikator angehängt wurde;
Profilwechsel, wenn Indikator zu einem der Charts des Wechselprofils angehängt wird;
Wechsel des Symbols und/oder Chartperiode, zu dem Indikator angehängt wird;
Änderung des Kontos, zu dem das Terminal verbunden ist;
Wechsel der Eingabeparameter des Indikators.

Laden und Ausladen der Experte

Laden des Experten erfolgt in folgenden Fällen:

Anhängen von Experten zum Chart;
Start des Terminals (wenn Expert vor dem früheren Terminalabschluss zum Chart angehängt wurde);
Laden der Schablone (wenn in der Schablone Expert angegeben wird, angehängt zum Chart);
nach erfolgreicher Neucompilierung des Experten, wenn dieser Expert zum Chart angehängt wurde.
Profilwechsel (Wenn Expert zum einen der Profilcharts angehängt wird);
Verbindung zu einem Konto, auch wenn die Kontonummer nicht geändert wurde (wenn der Expert Advisor wurde um den Chart, bevor die Zulassung des Terminals auf dem Server, verbunden).

Ausladen des Experten, angehängt zum Chart erfolgt in folgenden Fällen:

bei Abtrennung des Experten vom Chart;
beim Anhängen des Experten zum Chart - wenn auf dem Chart einen anderen Experten gab, wird dieser Expert ausgeladen;
Terminalschliessen, wenn der Expert zum Chart angehängt wurde;
Laden der Schablone, wenn der Expert zum Chart angehängt wird;
Schliessen des Charts, zu dem Expert angehängt wurde;
Profilwechsel, wenn der Expert zum einen der Charts der Wechselprofile angehängt wird;
Änderung des Kontos, zu dem das Terminal verbunden ist (wenn der Expert Advisor wurde um den Chart, bevor die Zulassung des Terminals auf dem Server, verbunden);

Aufruf der Funktion ExpertRemove().

Beim Wechsel des Symbols oder Timeframe des Charts, zu dem Expert angehängt wird, erfolgt Laden und Ausladen des Experten nicht. Dabei werden Bearbeiter OnDeinit() auf altem Symbol/Timeframe und OnInit() auf neuem Symbol/Timeframe (wenn es die solchen geben) serienweise aufgerufen, Werte der globalen Variablen und statischer Variablen werden nicht auf Null gesetzt. Alle Ereignisse, die vor dem Initialisierungsende (Funktion OnInit()) erscheinen, werden weggelassen.

Laden und Ausladen von Scripts

Scripts werden sofort nach Anhängen zum Chart geladen und sofort nach Operationsende ausgeladen. Dabei werden die Funktionen OnInit() und OnDeinit() für Scripts nicht aufgerufen.

Beim Programmausladen (Programmenfernen vom Chart) erfolgt Deinitialisierung der globalen Variablen und Entfernung der Queue von Ereignissen. In diesem Fall bedeutet Deinitialisierung Freigabe der Variablen des Typs string, Freigabe der Objekte der dynamischen Felder und Aufruf der Destruktors, wenn sie es geben.

Laden und Löschen von Diensten

Dienste werden unmittelbar nach dem Start des Terminals geladen, wenn sie zum Zeitpunkt der Terminalabschaltung gestartet wurden. Das Löschen der Dienste erfolgt unmittelbar nach Beendigung ihrer Arbeit.

Dienste haben nur eine einzige Funktion, OnStart(), in der Sie eine Endlosschleife für Empfang und Behandeln der Daten implementieren können, z.B. um nutzerdefinierte Symbole mit Hilfe der Netzwerkfunktionen zu erstellen und zu aktualisieren.

Im Gegensatz zu Expert Advisors, Indikatoren und Skripten sind Dienste nicht an ein bestimmtes Chart gebunden, daher wird ein separater Mechanismus bereitgestellt, um sie zu starten. Im Navigator wird mit dem Befehl "Dienst starten" eine neue Instanz des Dienstes angelegt. Eine Dienst-Instanz kann über das entsprechende Menü der Instanz gestartet, gestoppt und entfernt werden. Um alle Instanzen zu verwalten, verwenden Sie das Menü der Dienste.

Für bessere Verständigung der Expertenarbeit ist es empfehlenswert, Kode des im Beispiel angeführten Experten zu kompilieren und Operationen von Laden/Ausladen der Experten, Schablonen-, Symbol-, Timeframewechsel usw. durchführen.

Beispiel:

//+------------------------------------------------------------------+
//|                                                   TestExpert.mq5 |
//|                        Copyright 2009, MetaQuotes Software Corp. |
//|                                              https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "2009, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"

class CTestClass
  {
public:
   CTestClass() { Print("CTestClass constructor"); }
   ~CTestClass() { Print("CTestClass destructor"); }
  };
CTestClass global;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
   Print("Initialisation");
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
   Print("Deinitialisation with reason",reason);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//---

  }
//+------------------------------------------------------------------+

Scripts werden sofort nach Anhängen zum Chart geladen und sofort nach Operationsende ausgeladen.

Sehen Sie auch

Ereignisse des Client-Terminals, Ereignisbearbeiter

MQL5 Programme

Handelserlaubnis