MetaTrader 5 herunterladen

Ereignisbearbeiter

In der Sprache MQL5 ist die Bearbeitung einiger vorbestimmten Ereignissen vorausgesehen. Funktionen für die Bearbeitung dieser Ereignisse müssen im Programm MQL5 bestimmt werden;  Funktionsname, Typ des Rückgabewertes, Parametervorrat (wenn sie vorhanden sind) und ihre Typen müssen der Beschreibung der Funktion-Bearbeiter des Ereignisses strikt entsprechen.

Nämlich nach dem Typ des Rückgabewertes und Typen der Parameter identifiziert der Bearbeiter von Ereignissen des Client-Terminals die Funktionen, die verschiedene Ereignisse bearbeiten. Wenn die entsprechende Funktion andere angegebene Parameter hat, die den folgenden Beschreibungen nicht entsprechen oder ein anderer Typ des Rückgabewertes angegeben wird, wird diese Funktion für die Bearbeitung des Ereignisses nicht benutzt werden.

OnStart

Funktion OnStart() ist der Bearbeiter des Ereignisses Start,  wird nur für ablaufende Scripts automatisch generiert. Muss den Typ void haben, hat keine Parameter:

void OnStart();

für die Funktion  OnStart() ist es zugänglich, den Typ des Rückgabewertes int anzugeben.

OnInit

Funktion OnInit() ist der Bearbeiter des Ereignisses Init. Kann den Typ void oder int, haben, hat keine Parameter:

void OnInit();

Ereignis Init wird sofort nach Der Expert- oder Indikatorladung generiert werden, für Scripts wird dieses Ereignis nicht generiert. Funktion  OnInit() wird für die Initialisierung verwendet. Wenn  OnInit() Rückgabewert des Typs int hat, bedeutet der Nichtnullrückgabekode verfehlte Initialisierung und generiert Ereignis Deinit mit dem Kode des Deinitialisierungsgrundes REASON_INITFAILED.

Für Optimierung von Eingabeparametern wird es empfohlen Werte aus ENUM_INIT_RETCODE als Rückgabecode zu verwenden. Diese Werte werden für die Organisation der Verlauf der Optimierung, einschließlich der Auswahl der am besten geeigneten Testagenten eingesetzt. Während der Initialisierung eines Expert Advisor vor Beginn des Tests können Sie Informationen über die Konfiguration und die Ressourcen eines Agenten (die Anzahl der Kerne, Menge des freien Speichers, etc.) unter Verwendung des TerminalInfoInteger()-Funktion anfordern. Basierend auf diesen Informationen können Sie entweder Verwendung des Agenten erlauben oder ablehnen bei der Optimierung dieses Expert Advisors.

ENUM_INIT_RETCODE

Identifikator

Beschreibung

INIT_SUCCEEDED

Erfolgreiche Initialisierung, Test des Expert Advisor kann fortgesetzt werden.

Dieser Code bedeutet das gleiche wie ein Null-Wert - der Expert Advisor wurde erfolgreich im Tester initialisiert.

INIT_FAILED

Initialisierung fehlgeschlagen, es gibt keinen Sinn den Test fortzusetzen wegen der fatale Fehler. Zum Beispiel konnte nicht einen Indikator erstellen, der für die Arbeit des Expert Advisors erforderlich ist.

Dieser Rückgabewert bedeutet das gleiche wie ein anderer Wert als Null - Initialisierung des Expert Advisors im Tester gescheitert.

INIT_PARAMETERS_INCORRECT

Mit diesem Wert kann der Programmierer einen falschen Satz von Eingabeparameter beziehen. Auf die gesamte Optimierung-Tabelle wird die Zeile des Ergebnisses diesem Return-Code in rot hervorgehoben.

Test für die gegebenen Satz von Parametern des Expert Advisors nicht ausgeführt wird, ist der Agent frei, um eine neue Aufgabe zu erhalten.

Nach Erhalt dieses Wert wird Strategie Tester garantiert diese Aufgabe an andere Agenten für erneut Ausführen nicht übertragen.

INIT_AGENT_NOT_SUITABLE

Es gibt keine Fehler während der Initialisierung, aber aus irgendeinem Grund ist der Agent nicht geeignet für Test. Zum Beispiel, nicht genug Speicher, kein OpenCL-Unterstützung etc.

Nach der Rückkehr von diesem Code wird der Agent Aufgaben bis zum Ende dieser Optimierung nicht empfangen.

Funktion OnInit() des Typs void bedeutet immer erfolgreiche Initialisierung.

OnDeinit

Funktion OnDeinit() wird bei der Deinitialisierung aufgerufen und ist der Bearbeiter des Ereignisses Deinit . Muss mit dem Typ void erklärt werden und einen Parameter des Typs const int haben, der Kode des Deinitialisierungsgrundes hat. Wenn ein anderer Typ erklärt wird, gibt... Für Scripts wird das Ereignis Deinit nicht generiert, darum darf man nicht die Funktion OnDeinit() in Scripts verwenden.

void OnDeinit(const int reason);

Ereignis Deinit wird für Experten und Indikatoren in folgenden Fällen generiert:

  • vor Uminitialisierung wegen der Änderung des Symbols oder Chartperiode, zu dem mql5-Programm angeschlossen ist;
  • vor Neuinitialisierung wegen der Veranderung von Inputparametern;
  • vor Entladung des mql5-Programms.

OnTick

Ereignis NewTick wird nur für Experten generiert beim Eingang des neuen Ticks nach Symbol, zu dessen Chart Expert angeschlossen ist. Es ist sinnlos, die Funktion  OnTick() im Benutzerindikator oder Script zu bestimmen, denn das Ereignis NewTick wird für sie nicht generiert.

Ereignis Tick wird nur für Experten generiert, das bedeutet aber nicht, dass Experten die Funktion OnTick() haben muessen, denn für Experten werden nicht nur Ereignisse NewTick, sondern auch Ereignisse Timer, BookEvent und ChartEvent generiert. Muss mit dem Typ void, erklärt werden  hat keine Parameter:

void OnTick();

OnTimer

Funktion OnTimer() wird beim Erscheinen des Ereignisses Timer aufgerufen, das vom Systemtimer nur für Experten und Anzeiger generiert wird - in Skripts kann sie nicht verwendet werden.  Funktion OnTimer() wird nur beim Eintritt des Ereignisses Timer aufgerufen, das vom Systemtimer nur für Experten generirt wird - man muss sie nicht in Scripts oder Indikatoren verwenden. Periode des Eintritt dieses Ereignisses wird bei der Subskription auf Benachrichtigungsempfang über dieses Ereignis durch die Funktion EventSetTimer() eingesetzt.

Annulieren der Aufnahme der Timerereignisse für jeden konkreten Experten erfolgt durch die Funktion EventKillTimer(). Funktion muss mit dem Typ void bestimmt werden, hat keine Parameter:

void OnTimer();

Es ist empfehlenswert, die Funktion EventSetTimer() in der Funktion OnInit() einmalig aufzurufen, und Die Funktion EventKillTimer() einmalig in der Funktion OnDeinit() aufzurufen.

Jeder Expert und Anzeiger arbeitet nur mit seinem Timer und erhaelt Ereignisse nur von ihm. Wenn das mql5-Programm zu funktionieren stoppt, wird Timer zwangslaeufig entfernt, wenn er durch die Funktion EventKillTimer() erzeugt aber nicht entfernt wurde.

OnTrade

Funktion wird beim Eintritt von Trade aufgerufen, das bei der Änderung der Liste der aufgestellten Order und offenen Positionen, Ordergeschichte und Dealgeschichte entsteht. Bei jeder Handelshandlung (Aufstellung de zurückgesetzten Order, Öffnung/Schliessung der Position, Einstellung von Stops, Ausloesung der zurückgesetzten Ordern usw.) verändert sich entsprechenderweise die Geschichte der Ordern und Deals und/oder Liste der Positionen und laufender Ordern.

void OnTrade();

Benutzer muss selbsstaendig, Pruefung des Standes vom Handelskonto beim Erhalten dieses Ereignisses zu realisieren (wenn es nach Bedingungen der Handelsstrategie notwendig ist). Wenn der Funktionsaufruf  OrderSend() erfolgreich beendet und den Wert true zurückgibt - bedeutet es, dass Handelsserver Order in Warteschlange eingereiht hat und ihr die Ticketnummer zugeordnet hat. Sobald der Server diesen Befehl bearbeitet, wird das Ereignis Trade generiert werden.  Wenn der Benutzer den Ticketwert im Kopf behaelt, kann er bei  der Bearbeitung des Ereignisses OnTrade() aufklaeren, was mit der Order geschehen ist.

OnTradeTransaction

Als Ergebnis der Durchführung von bestimmten Aktionen auf dem Handelskonto, ändert sich der Kontostand. Zu solchen Aktionen gehören:

  • Senden der Handelsanfrage aus einer beliebigen MQL5-Anwendung in dem Client-Terminal mittels der Funktionen OrderSend und OrderSendAsync und ihre nachfolgende Ausführung;
  • Senden der Handelsanfrage über die grafische Oberfläche des Terminals und ihre nachfolgende Ausführung;
  • Auslösen von aufgeschobenen Ordern und Stop-Ordern auf dem Server;
  • Ausführen von Operationen auf der Seite der Handel-Server.

Als Ergebnis dieser Aktionen werden die folgenden Handelstransaktionen durchgeführt:

  • Die Verarbeitung der Handelsanfrage;
  • Änderung der offenen Aufträge;
  • Änderung der Ordergeschichte;
  • Änderung der Dealgeschichte;
  • Änderung der Position.

Zum Beispiel, beim Senden Marktkauforder, wird Marktkauforder behandelt und eine entsprechende Marktkauforder für das Konto erstellt. Ist die Order durchgeführt, wird sie aus der Auftragsliste entfernt und zur Ordergeschichte hinzugefügt. Dann wird der entsprechende Deal zur Geschichte hinzugefügt und eine neue Position wird erstellt. Alle diese Aktionen sind Handelstransaktionen. Ankunft jeder solchen Transaktion im Terminal ist ein Ereignis TradeTransaction. Es ruft den Handler OnTradeTransaction auf

void  OnTradeTransaction(
   const MqlTradeTransaction   trans,        // Struktur der Handelstransaktion
   const MqlTradeRequest&        request,      // Struktur der Anfrage
   const MqlTradeResult&         result        // Struktur der Antwort
   );

Der Handler enthält drei Parameter:

  • trans - in diesen Parameter wird die Struktur MqlTradeTransaction übergeben, die die auf das Handelskonto angewendete Handelstransaktion beschreibt;
  • request - in diesen Parameter wird die Struktur MqlTradeRequest übergeben, die eine Handelsanfrage beschreibt;
  • result - in diesen Parameter wird die Struktur MqlTradeResult übergeben, die das Ergebnis der Ausführung einer Handelsanfrage beschreibt.

Zwei letzte Parameter request und result werden mit den Werten nur für Transaktion des Typs TRADE_TRANSACTION_REQUEST ausgefüllt, die Information über Transaktion kann man aus dem Parameter type der Variable trans erhalten. Beachten Sie, dass in diesem Fall das Feld request_id in der Variable result den Identifikator der Handelsanfrage request enthält, als Ergebnis dessen Ausführung die in der Variable trans beschriebene Handelstransaktion durchgeführt wurde. Das Vorhandensein des Identifikators der Anfrage erlaubt die ausgeführte Aktion (Aufruf der Funktion OrderSend oder OrderSendAsync) mit dem in die OnTradeTransaction() übergebenen Ergebnis dieser Aktion zu verbinden.

Eine Handelsanfrage, die aus dem Terminal manuell oder durch die Handelsfunktionen OrderSend()/OrderSendAsync() gesendet ist, kann mehrere konsequente Handelstransaktionen auf dem Handel-Server auslösen. Dabei ist die Reihenfolge des Eingangs dieser Transaktionen in das Terminal nicht gewährleistet, deshalb darf man seinen Handelsalgorithmus auf der Erwartung des Eingangs einiger Handelstransaktionen nach der Ankunft der anderen nicht bauen.

  • Alle Typen der Handelstransaktionen werden in der Enumeration ENUM_TRADE_TRANSACTION_TYPE beschrieben.
  • Die Struktur MqlTradeTransaction, die eine Handelstransaktion beschreibt, wird auf unterschiedlicher Weise je nach Typ der Transaktion ausgefüllt. Zum Beispiel, für Transaktionen des Typs TRADE_TRANSACTION_REQUEST muss nur type Feld (Typ der Handelstransaktion) analysiert werden. Für zusätzliche Informationen muss man die zweiten und dritten Parameter der Funktion OnTradeTransaction (request und result) analysieren. Weitere Informationen finden Sie im Abschnitt "Struktur der Handelstransaktion".
  • In der Beschreibung der Handelstransaktion werden nicht alle verfügbaren Informationen über Aufträge, Deals und Positionen (zum Beispiel, Kommentar) übergeben. Für erweiterte Informationen sollten die Funktionen OrderGet *, HistoryOrderGet *, HistoryDealGet * und PositionGet * verwendet werden.

Nach der Anwendung der Handelstransaktionen auf das Kundenkonto werden sie in die Warteschlange der Handeltransaktionen des Terminals konsequent gestellt, woher in den Eingangspunkt OnTradeTransaction in der Reihenfolge der Ankunft in das Terminal schon konsequent übergeben werden.

Während der Verarbeitung der Handelstransaktionen von einem Expert Advisor mit Hilfe des Handlers OnTradeTransaction bearbeitet das Terminal neu ankommenden Handelstransaktionen weiter. Somit kann sich der Zustand des Handelskontodes während des OnTradeTransaction schon ändern. Zum Beispiel, während das MQL5-Programm ein Ereignis des Hinzufügens einer neuen Order bearbeitet, kann sie ausgeführt werden, aus der offenen Auftragsliste entfernt werden und in die Geschichte übertragen werden. Im Folgenden wird das Programm über alle diesen Ereignisse benachrichtigt sein.

Länge der Warteschlange umfasst 1024 Elemente. Falls OnTradeTransaction die nächste Transaktion zu lange bearbeiten wird, können die alten Transaktionenin in der Warteschlange durch die neueren verdrängt sein.

  • Im Allgemeinen gibt es kein genaues Verhältnis nach der Anzahl der Aufrufe OnTrade und OnTradeTransaction. Ein Anruf OnTrade entspricht einem oder mehreren Aufrufen OnTradeTransaction.
  • OnTrade wird nach den entsprechenden Aufrufen OnTradeTransaction aufgerufen.

OnTester

Funktion OnTester() ist Bearbeiter des Ereignisses Tester, das nach Abschluss des historischen Testen des Experten für das vorgegebene Dateninterval.  Funktion muss mit dem Typ void bestimmt werden, hat keine Parameter:

double OnTester();

Funktion wird unmittelbar vor dem Aufruf der Funktion OnDeinit() aufgerufen und hat den Typ des Rückgabewertes  double. Funktion OnTester() kann nur in Experten beim Testen verwendet werden und ist in erster Linie für Berechnung bestimmtes Wertes bestimmt, der als Kriterium Custom max bei genetischer Optimierung der Eingabeparameter verwendet.

Bei genetischer Optimierung wird Sortieren der Ergebnisse innerhalb einer Generation absteigend durchgeführt. D.h. die besten Ergebnisse vom Standpunkt des Optimierungskriterium sind die mit dem größten Wert (für Optimierungkriterium Custom max werden Werte beachtet, die durch die Funktion OnTester zurückgegeben werden). Die schlechtesten Werte bei diesem Sortieren werden am Ende gestellt und danach weggeworfen und an Formieren der nächsten Generation nicht beteiligen.

OnTesterInit

Die Funktion OnTesterInit() ist ein Eventhandler von TesterInit, das automatisch vor dem Start der Optimierung eines Expert Advisors generiert wird. Die Funktion muss mit dem Typ void definiert werden, ohne Parameter:

void OnTesterInit();

Ein Expert Advisor, der den Handler OnTesterDeinit() oder OnTesterPass() hat, wird beim Start der Optimierung automatisch auf einem gesonderten Chart des Terminals geladen mit dem Symbol und der Periode, die im Tester angegeben wurden, und ein Ereignis TesterInit empfängt. Die Funktion soll einen Expert Advisor vor Optimierung initialisieren um dann die Ergebnisse der Optimierung zu verarbeiten.

OnTesterPass

Die Funktion OnTesterPass() ist ein Eventhandler von TesterPass, das automatisch vor dem Start der Optimierung eines Expert Advisors generiert wird. Die Funktion muss mit dem Typ void definiert werden, ohne Parameter:

void OnTesterPass();

Ein Expert Advisor mit Handler OnTesterPass() wird automatisch auf einem gesonderten Chart des Terminals geladen mit dem für ein Test angegebenen Symbol und der Periode, und erhält Ereignisse von TesterPass beim Erhalten von einem Frame bei der Optimierung. Die Funktion wird für die dynamische Verarbeitung von Optimierungsergebnisse direkt "on the fly" ausgelegt, ohne für die Vollendung der Optimierung zu warten. Frames werden durch Funktion FrameAdd() hinzugefügt. Diese Funktion kann nach einem Durchgang im Handler OnTester() aufgerufen werden.

OnTesterDeinit

Die Funktion Boxing Day() ist ein Eventhandler von TesterDeinit, das automatisch nach der Optimierung eines Expert Advisors generiert wird. Die Funktion muss mit dem Typ void definiert werden, ohne Parameter:

void OnTesterDeinit();

Ein Expert Advisor mit dem Handler TesterDeinit() wird automatisch auf dem Chart beim Start der Optimierung geladen, und erhält ein Ereignis TesterDeinit nach ihrer Fertigstellung. Die Funktion wird für die abschließende Bearbeitung aller Optimierungsergebnisse verwendet.

OnBookEvent

Funktion OnBookEvent() ist der Bearbeiter von Ereignis BookEvent. Ereignis BookEvent wird nur für Experten und Anzeiger bei der Veränderung von DOM (Depth of Market generiert).  Muss den Typ void und einen Parameter des Typs string haben:

void OnBookEvent (const string& symbol);

Um Ereignisse BookEvent  für jedes Symbol zu bekommen, reicht es, voraussichtlich auf Erhalten dieser Ereignisse für dieses Symbol durch die Funktion MarketBookAdd() zu subskribieren. Um die Subskription auf Erhalten des Ereignisses BookEvent für konkretes Symbol zu annullieren, muss man die Funktion MarketBookRelease() aufrufen.

Zum Unterschied von den anderen Ereignissen, ist das Ereignis BookEvent broadcast. Das bedeutet, wenn ein Expert Auf Erhalten des Ereignisses BookEvent durch die Funktion MarketBookAdd subskribiert, werden alle anderen Experten mit Bearbeiter OnBookEvent() dieses Ereignis bekommen. Darum muss der Symbolname, der in Bearbeiter als Parameter const string& symbol übertragen wird, analysieren.

OnChartEvent

OnChartEvent() ist der Bearbeiter von Gruppe der Ereignisse ChartEvent:

  • CHARTEVENT_KEYDOWN – Ereignis des Keyboardbetätigens, wenn das Chartfenster im Fokus steht;
  • CHARTEVENT_MOUSE_MOVE – Ereignisse der Maus-Bewegung und Mausklicks (wenn die Eigenschaft CHART_EVENT_MOUSE_MOVE=true ist eingegeben);
  • CHARTEVENT_OBJECT_CREATE – Ereignis der Erzeugung des graphischen Objektes (wenn die Eigenschaft CHART_EVENT_OBJECT_CREATE=true ist eingegeben);
  • CHARTEVENT_OBJECT_CHANGE – Veranderung der Objekteigenschaften durch Dialog der Eigenschaften;
  • CHARTEVENT_OBJECT_DELETE – Ereigniss der Entfernung des graphischen Objektes (wenn die Eigenschaft CHART_EVENT_OBJECT_DELETE=true ist eingegeben);
  • CHARTEVENT_OBJECT_CLICK – Ereignis des Mausklickens auf dem graphischen Objekt, das zum Chart gehört;
  • CHARTEVENT_OBJECT_DRAG – Ereignis der übertragung des graphischen Objekts mit der Maus;
  • CHARTEVENT_OBJECT_ENDEDIT – Ereignis des Abschlusses von Texteditieren im Eingabefeld des graphischen Objekts LabelEdit;
  • CHARTEVENT_CHART_CHANGE  – Ereignis von Änderungen des Charts;
  • CHARTEVENT_CUSTOM+n – Identifikator des Benutzerereignisses, wo sich n im Bereich von  0 bis 65535 befindet.
  • CHARTEVENT_CUSTOM_LAST – letzter zugaenglicher Identifikator des Benutzerereignisses  (CHARTEVENT_CUSTOM+65535).

Funktion kann nur in Experten und Indikatoren aufgerufen werden und muss den Typ void und 4 Parameter haben:

void OnChartEvent(const int id,         // Identifikator des Ereignisses   
                  const long& lparam,   // Parameter des Ereignisses des Typs long
                  const double& dparam, // Parameter des Ereignisses des Typs double
                  const string& sparam  // Parameter des Ereignisses des Typs string
  );

Für jeden Typ des Ereignisses haben Eingabeparameter der Funktion OnChartEvent() vorbestimmte Werte, die für Verarbeitung dieses Ereignisses notwendig sind. In der Tabelle sind Ereignisse und Werte aufgezählt, die durch Parameter übertragen werden.

Ereignis

Wet des Parameters id

Wert des Parameters lparam

Wert des Parameters dparam

Wert des Parameters  sparam

Ereignis des Keyboard Klickens

CHARTEVENT_KEYDOWN

Kode der betätigten Taste

Die Anzahl der Tastenanschläge, die generiert werden, während diese Taste in gedrücktem Zustand war

Der String-Wert eines Bit-Maske, die den Status der Tastatur-Tasten beschreibt

Ereignisse der Maus-Bewegung und Mausklicks (wenn die Eigenschaft CHART_EVENT_MOUSE_MOVE=true ist für das Chart eingegeben)

CHARTEVENT_MOUSE_MOVE

X-Koordinate

Y-Koordinate

Der String-Wert einer Bit-Maske, der den Status der Maustasten beschreibt

Ereignis der Erzeugung des graphischen Objektes  (wenn die Eigenschaft CHART_EVENT_OBJECT_CREATE=true ist für ein Chart eingegeben)

CHARTEVENT_OBJECT_CREATE

Name des erzeugten graphischen Objektes

Ereignis der Veränderung der Eigenschaften des Objektes durch Dialog der Eigenschaften

CHARTEVENT_OBJECT_CHANGE

Name des veränderten graphischen Objektes

Ereignis der Entfernung des graphischen Objektes  (wenn die Eigenschaft CHART_EVENT_OBJECT_DELETE=true ist für ein Chart eingegeben)

CHARTEVENT_OBJECT_DELETE

Name des entfernten graphischen Objektes

Ereignis des Mausklicks auf der graphischen Darstellung

CHARTEVENT_CLICK

X-Koordinate

Y-Koordinate

Ereignis des Mausklicks auf dem graphischen Objekt

CHARTEVENT_OBJECT_CLICK

X-Koordinate

Y-Koordinate

Name des graphischen Objektes, auf dem das Ereignis geschehen ist  

Ereignis der Verschiebung des graphischen Objektes per Mausklick

CHARTEVENT_OBJECT_DRAG

Name des verschobenen graphischen Objektes

Ereignis der Beendung des Texteditierens im Eingabefeld des graphischen Objektes "Eingabefeld"

CHARTEVENT_OBJECT_ENDEDIT

Name des graphischen Objektes "Eingabefeld", in dem Editieren des Textes beendet wurde

Ereignis der Chart-Veränderung

CHARTEVENT_CHART_CHANGE

Benutzerereignis mit  Nummer  N

CHARTEVENT_CUSTOM+N

Wert, vorgegeben durch die Funktion EventChartCustom()

Wert, vorgegeben durch die Funktion EventChartCustom()

Wert, vorgegeben durch die Funktion EventChartCustom()

OnCalculate

Funktion OnCalculate() wird nur in Benutzerindikatoren aufgerufen werden bei der Notwendigkeit, Berechnung der Indikatorenwerte am Ereignis Calculate durchzuführen. Gewöhnlich erfolgt es bei der Aufnahme des neuen Ticks für Symbol, für das der Indikator berechnet wird. Dabei braucht der Indikator nicht zum einen Preischart dieses Symbols angehängt werden.

Funktion OnCalculate() muss den Typ des Rückgabewertes int haben. Es gibt zwei Definitionsvarianten. Innerhalb eines Indikators können  beide Varianten der Funktion nicht verwendet werden.

Die erste Aufrufform ist für die Indikatoren bestimmt, die auf einem Datenpuffer berechnet werden können. Das Beispiel dieses Indikators - Custom Moving Average.

int OnCalculate (const int rates_total,      // Feldgroesse price[]
                 const int prev_calculated,  // verarbeitete Bars im früheren Aufruf 
                 const int begin,            // woher bedeutsame Daten anfangen
                 const double& price[]       // Feld für Berechnung
   );

Als Feld price[] kann eine der Preistimeserien oder berechneter Buffer irgendwelches Anzeigers übertragen werden. Um Indizierenrichtung im Feld price[] zu bestimmen, muss man die Funktion ArrayGetAsSeries() aufrufen. Um von Default-Werten nicht abzuhängen, muss man die Funktion ArraySetAsSeries() für die Felder, mit denen es zu arbeiten zu erwarten, aufrufen.

Auswahl der notwendigen Timeserie oder des Indikators als Feld price[] macht der Benutzer beim Start des Indikators auf Registerblatt "Parameters". Dafür muss das notwendige Element in der drop-down Liste des Feldes  "Apply to" angegeben werden.

Auswahl der Zeitreihe fuer Indikatorberechnung

für Erhalten der Werte des Benutzerindikators aus anderen mql5-Programmen wird die Funktion iCustom() verwendet, , die handle des Indikators für folgende Operationen rückgibt. Dabei kann auch das notwendige Feld price[] oder handle des anderen Indikators angegeben werden. Dieser Parameter muss als letzte in der Liste von Variablen des Benutzerindikators übertragen werden.
Beispiel:

void OnStart()
  {
//---
   string terminal_path=TerminalInfoString(STATUS_TERMINAL_PATH);
   int handle_customMA=iCustom(Symbol(),PERIOD_CURRENT"Custom Moving Average",13,0, MODE_EMA,PRICE_TYPICAL);
   if(handle_customMA>0)
      Print("handle_customMA = ",handle_customMA);
   else
      Print("Cannot open or not EX5 file '"+terminal_path+"\\MQL5\\Indicators\\"+"Custom Moving Average.ex5'");
 ;}

In diesem Beispiel ist der letzte Parameter der Wert PRICE_TYPICAL (aus Enumeration ENUM_APPLIED_PRICE ), der deutet, dass Benutzerindikator auf typischen Preisen gebaut werden wird, erhalten als (High+Low+Close)/3. Wenn der Parameter nicht angegeben wird, wird Indikator auf Grudlage der Werte  PRICE_CLOSE gebaut,d.h. auf Schlusspreisen jede Bar.    

Ein anderes Beispiel das übergabe des handles des Indikators als letzter Parameter demonstriert  für Festlegung des Feldes price[], ist in der Funktionbeschreibung iCustom() angegeben.

Die zweite Aufrufform ist für alle anderen Indikatoren bestimmt, die für Berechnung mehr als eine Zeitreihe verwenden.

int OnCalculate (const int rates_total,      // Größe der Eingabezeitreihen 
                 const int prev_calculated,  // Bars, verarbeitete im früheren Aufruf 
                 const datetime& time[],     // Time
                 const double& open[],       // Open
                 const double& high[],       // High
                 const double& low[],        // Low
                 const double& close[],      // Close
                 const long& tick_volume[],  // Tick Volume
                 const long& volume[],       // Real Volume
                 const int& spread[]         // Spread
   );

Parameter open[], high[], low[] und close[] enthalten Felder mit Öffnungspreisen, dem maximalen und minimalen Preis und Schlusspreisen des laufenden Timeframes. Parameter time [] enthält Feld mit Eroeffnungszeit, Parameter spread[] — Feld mit der Geschichte der Spreads (wenn Spread für diesen Typ (wenn Spread für dieses Handelsinstrument vorausgesehen wird). Parameter volume[] und tick_volume[] enthalten die Geschichte des Handels-und Tickvolumen.

Zu bestimmen die Richtung des Indizierenz in Feldern time[], open[], high[], low[], close[], tick_volume[], volume[] und spread[], muss man die Funktion ArrayGetAsSeries() aufrufen. Damit man von Default-Werten nicht abhängt, muss man die Funktion ArraySetAsSeries() für die Felder aufrufen, mit denen es zu arbeiten erwartet.

Der erste Parameter rates_total enthält die Zahl von Bars, zugängliche dem Indikator für Berechnungrund entspricht der Baranzahl, zugängliche auf dem Chart.

Wir muessen über den Zusammenhang zwischen dem  Rückgabewert von OnCalculate() und dem zweiten Eingabeparameter prev_calculated erwaehnen. Parameter prev_calculated enthält beim Funktionsaufruf den Wert, den die Funktion OnCalculate() beim früheren Aufruf rückgegeben hat.  Das ermöglicht rationelle Berechnungsalgorithmen des Benutzerindikators zu realisieren, um Wiederberechnungen für die Bars, die seit früheren Start dieser Funktion nicht verandert haben, zu vermeiden.

Dafür reicht es gewoehnlich, Parameterwert  rates_total rückzugeben, der die Baranzahl beim laufenden Funktionsaufruf enthält. Wenn vom Moment des letzten Aufrufes der Funktion OnCalculate() Preisdaten nicht verändert wurden  (tiefere Geschichte heruntergeladen sind oder Auslassungen der Geschichte ausgefuellt sind),wird der Wert des Eingabeparameters prev_calculated vom Terminal Null gesetzt werden.

Bemerkung: Wenn die Funktion OnCalculate Nullwert rückgibt, werden die Werte des Indikators im Fenster DataWindow des Client-Terminals nicht gezeigt.

für bessere Verständigung, ist es empfehlenswert, Indikator ablaufen zu lassen, dessen Kode unten angegeben wird.

Beispiel des Indikators:

#property indicator_chart_window
#property indicator_buffers 1
#property indicator_plots   1
//---- plot Line
#property indicator_label1  "Line"
#property indicator_type1   DRAW_LINE
#property indicator_color1  clrDarkBlue
#property indicator_style1  STYLE_SOLID
#property indicator_width1  1
//--- indicator buffers
double         LineBuffer[];
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- indicator buffers mapping
   SetIndexBuffer(0,LineBuffer,INDICATOR_DATA);
//---
   return(INIT_SUCCEEDED);
 ;}
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
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& tick_volume[],
                const long& volume[],
                const int& spread[])
  {
//--- bekommen die Anzahl der zugänglichen Bars für laufendes Symbol und laufende Periode auf dem Chart.   
   int bars=Bars(Symbol(),0);
   Print("Bars = ",bars,", rates_total = ",rates_total,", prev_calculated = ",prev_calculated);
   Print("time[0] = ",time[0]," time[rates_total-1] = ",time[rates_total-1]);
//--- return value of prev_calculated for next call
   return(rates_total);
 ;}
//+------------------------------------------------------------------+

Sehen Sie auch

Programmausführung, Ereignisse des Client-Terminals, Arbeit mit Ereignissen