Funzioni di Gestione degli Eventi

Il linguaggio MQL5 fornisce elaborazione di alcuni eventi predefiniti. Le funzioni per la gestione di questi eventi devono essere definite in un programma MQL5; il nome della funzione, il tipo restituito, la composizione dei parametri (se ce ne sono) ed il loro tipo, devono essere rigorosamente conformeialla descrizione della funzione gestore di eventi.

L'event handler (_* gestore di eventi) del terminale client identifica le funzioni, la gestione di questo o quell'evento, dal tipo di valore di ritorno e dal tipo di parametri. Se altri parametri, non corrispondenti alle descrizioni che seguono, vengono specificati per una funzione corrispondente, o un altro tipo di ritorno è indicato per esso, una tale funzione non sarà utilizzata come un event handler.

OnStart #

La funzione OnStart () è l'event handler d' Inizio, che viene generato automaticamente solo per l'esecuzione di scripts. Deve essere di tipo void, senza parametri:

voidOnStart()

Per la funzione OnStart (), può essere specificato il tipo di ritorno int.

OnInit #

La funzione OnInit() è l'event handler Init. Deve essere di tipo void o int, senza parametri:

void OnInit();

L'evento Init viene generato immediatamente dopo che viene scaricato un Expert Advisor o un indicatore; questo evento non viene generato per gli script. La funzione OnInit() viene utilizzata per l'inizializzazione. Se OnInit() ha il tipo int come valore di ritorno, il codice di ritorno diverso-da-zero indica l'inizializzazione di esito negativo, e genera l'evento Deinit con il codice della ragione di deinizializzazione REASON_INITFAILED.

Quando restituisce INIT_FAILED, l'EA viene forzatamente scaricato dal grafico.

Quando restituisce INIT_FAILED, l'indicatore non viene scaricato dal grafico. L'indicatore rimanendo sul grafico non è operativo — i gestori degli eventi non sono chiamati nell'indicatore.

Per ottimizzare i parametri di ingresso di un Expert Advisor, si consiglia di utilizzare i valori dell'enumerazione ENUM_INIT_RETCODE come codice di ritorno. Questi valori sono utilizzati per organizzare il corso dell' ottimizzazione, compresa la selezione del più appropriato testing agents. Durante l'inizializzazione di un Expert Advisor prima dell'inizio del testing è possibile richiedere informazioni sulla configurazione e le risorse di un agente (il numero di cores, quantità di memoria libera, ecc.) utilizzando la funzoone TerminalInfoInteger() . Sulla base delle informazioni ottenute, ci si può permettere di usare questo agente di testing, o rifiutare di utilizzalo, per l'ottimizzazione di quell' Expert Advisor.

ENUM_INIT_RETCODE

Identificatore

Descrizione

INIT_SUCCEEDED

Inizializzazione con successo, il testing dell' Expert Advisor può essere continuato.

Questo codice indica la stessa cosa del valore null - l'Expert Advisor è stato correttamente inizializzato nel tester.

INIT_FAILED

Inizializzazione fallita; non c'è alcun modo di continuare il testing a causa di errori fatali. Ad esempio, fallimento nella creazione di un indicatore che è richiesto per il lavoro dell' Expert Advisor.

Questo valore di ritorno è lo stesso che di valore diverso da zero - l'inizializzazione dell' Expert Advisor nel tester non è riuscito.

INIT_PARAMETERS_INCORRECT

Questo valore indica l'insieme di parametri di input non corretti. La stringa risultante contenente questo codice di ritorno è evidenziata in rosso nella tabella generale di ottimizzazione.

Il testing per il dato insieme di parametri dell' Expert Advisor non verrà eseguito, l'agente è libero di ricevere un nuovo compito.

Alla ricezione di questo valore, lo strategy tester in modo affidabile non passerà questo compito ad altri agenti per riprovare.

INIT_AGENT_NOT_SUITABLE

Nessun errore durante l'inizializzazione, ma per qualche motivo l'agente non è adatto per il testing. Ad esempio, non c'è abbastanza memoria, non c'è Supporto OpenCL, ecc.

Dopo il ritorno di questo codice, l'agente non riceverà compiti fino alla fine di questa ottimizzazione.

La funzione OnInit() del tipo void indica sempre l'inizializzazione con successo.

OnDeinit #

OnDeinit() viene chiamato durante la deinizializzazione ed è l'event handler Deinit. Deve essere dichiarato come void(tipo) e dovrebbe avere un parametro di tipo const int, che contiene il codice del motivo della deinizializzazione. Se viene dichiarato un tipo diverso, il compilatore genererà un avviso, ma la funzione non verrà chiamata. Per gli script, l'evento Deinit non viene generato e quindi la funzione OnDeinit() non può essere utilizzata negli scripts.

void OnDeinit(const int motivo);

L'evento Deinit viene generato per l'Expert Advisors e gli Indicatori nei seguenti casi:

  • prima della reinizializzazione dovuta alla variazione di un simbolo o di un periodo del grafico, al quale il programma MQL5 è annesso;
  • prima dello scarico(_*decarico) del programma MQL5.

OnTick #

L'eventoNewTick viene generato per li Expert Advisors solo quando viene ricevuto un nuovo tick per un simbolo, al grafico al quale è annesso l'Expert Advisor. E' inutile definire la funzione OnTick() in un indicatore personalizzato o uno script, perché l'evento NewTick non viene generato per essi.

L'evento Tick viene generato solo per Expert Advisor, ma questo non vuol dire che l'Expert Advisor ha richiesto la funzione OnTick(), dal momento che gli eventi NewTick non solo vengono generati per Expert Advisor, ma anche eventi di Timer, BookEvent e ChartEvent vengono generati. Deve essere dichiarato come tipo void, senza parametri:

void OnTick();

OnTimer #

La funzione OnTimer() viene chiamata quando avviene l'evento Timer, che viene generato dal timer di sistema solo per Expert Advisors ed Indicatori - non può essere utilizzato negli script. La frequenza del verificarsi dell'evento viene impostata al momento della sottoscrizione riguardo le notifiche su quell' evento che dev'essere ricevuto dalla funzione EventSetTimer().

È possibile annullare la sottoscrizione a ricevere gli eventi timer per un particolare Expert Advisor utilizzando la funzione EventKillTimer(). La funzione deve essere definita con il tipo void, senza parametri:

void OnTimer();

Si consiglia di chiamare la funzione EventSetTimer() una volta nella funzione OnInit(), e la funzione EventKillTimer() dovrebbe essere chiamata una volta in OnDeinit().

Ogni Expert Advisor, così come ogni Indicatore lavora con il proprio timer e riceve gli eventi solo da esso. Non appena il programma MQL5 programma si arresta, il timer viene distrutto forzatamente, se era stato stato creato ma non disabilitato dalla funzione EventKillTimer ().

OnTrade #

La funzione viene chiamata quando avviene l'evento Trade, che appare quando si cambia l'elenco degli ordini piazzati e delle posizioni aperte, la cronistoria degli ordini e storia degli affari. Quando una attività di trade viene eseguita (apertura ordine pendente, apertura/chiusura posizione, impostazione stops, innesco ordini pendenti, ecc), la cronistoria degli ordini e/o elenco delle posizioni ed ordini correnti, viene cambiata di conseguenza.

void OnTrade();

Gli utenti devono autonomamente applicare nel codice, la verifica di uno stato di un account di trade, quando un tale evento viene ricevuto (se ciò è richiesto dalle condizioni della strategia di trading). Se la funzione OrderSend() chiamata è stata completata con successo e ha restituito un valore true, questo significa che il trading server ha messo l'ordine nella coda per l'esecuzione ed ha assegnato un numero di ticket ad essa. Non appena il server elabora questo ordine, l'evento Trade verrà generato. E se un utente ricorda il valore del ticket, lui/lei sarà in grado di scoprire cosa è successo all'ordine utilizzando questo valore durante l' OnTrade() event handling.

OnTradeTransaction #

Quando si eseguono alcune azioni precise su un trade account, il suo stato cambia. Tali azioni comprendono:

  • Inviare una richiesta di trade da qualsiasi applicazione MQL5 nel terminale client utilizzando le funzioni OrderSend e OrderSendAsync e la sua ulteriore esecuzione;
  • Inviare una richiesta di trade tramite l'interfaccia grafica del terminale e la sua esecuzione ulteriore;
  • Attivazione di ordini pendenti ed ordini di stop sul server;
  • Esecuzione di operazioni sul lato trade server.

Le operazioni commerciali di seguito vengono eseguite come risultato di queste azioni:

  • gestione di una richiesta di trade;
  • cambio di ordini aperti;
  • cambio della cronistoria degli ordini;
  • cambio della cronistoria degli affari;
  • cambio delle posizioni.

Per esempio, quando si invia un ordine di mercato buy, esso viene gestito, un appropriato ordine di buy viene creato per l'account, l'ordine viene poi eseguito e rimosso dalla lista di quelli aperti, quindi viene aggiunto alla cronistoria ordini, un appropriato affare si aggiunge alla cronistoria e una nuova posizione viene creata. Tutte queste azioni sono transazioni di trade. L' arrivo di una tale operazione presso il terminale è un evento TradeTransaction. Esso chiama l'handler(_*gestore) OnTradeTransaction

void  OnTradeTransaction(
   const MqlTradeTransaction   trans,        // struttura transazione di trade
   const MqlTradeRequest&        request,      // struttura request
   const MqlTradeResult&         result        // struttura result 
   );

L'handler contiene tre parametri:

  • trans - questo parametro riceve la struttura MqlTradeTransaction che descrive una transazione di trade applicata ad un account;
  • request - questo parametro riceve la struttura MqlTradeRequest che descrive una richiesta di trade;
  • result - questo parametro riceve la struttura MqlTradeResult che descrive un risultato di esecuzione di una richiesta di trade.

Gli ultimi due parametri request e result sono riempiti da valori solo per il tipo di transazione TRADE_TRANSACTION_REQUEST, i dati sulle transazioni possono essere ricevuti dal tipo di parametro della variabile trans. Si noti che in questo caso, il campo request_id nella variabile result contiene l'ID di requesttrade request, dopo l'esecuzione di cui la transazione commerciale descritta nella variabile trans è stata eseguita. Request ID consente di associare l'azione eseguita (chimate di funzioni OrderSend oppure OrderSendAsync ) con il risultato di questa azione inviata a OnTradeTransaction().

Una richiesta di trade manualmente inviata dal terminale o via funzioni OrderSend()/OrderSendAsync() può generare varie transazioni consecutive sul trade server. La priorità di arrivo di queste transazioni al terminale, non è garantita. Quindi, non si deve aspettare che un gruppo di transazioni arriveranno dopo un altro, durante lo sviluppo del vostro algoritmo di trading.

  • Tutti i tipi di transazioni di trade sono descritti nell' enumerazione ENUM_TRADE_TRANSACTION_TYPE.
  • La struttura MqlTradeTransaction descrive una transazione di trade che è riempita in modi diversi a seconda del tipo di transazione. Ad esempio, solo tipo di campo (tipo di transazione di trade) deve essere analizzato per le transazioni di tipo TRADE_TRANSACTION_REQUEST. Il secondo e terzo parametro della funzione OnTradeTransaction (richiesta e risultato) devono essere analizzati per dati aggiuntivi. Per ulteriori informazioni, vedere "Struttura di una transazione di Trade".
  • Una descrizione di una transazione di trade non fornisce tutte le informazioni disponibili riguardanti gli ordini, gli affari e le posizioni (per esempio, i commenti). Le funzioni OrderGet*, HistoryOrderGet*, HistoryDealGet* and PositionGet* devono essere usate per ottenere informazioni estese.

Dopo l'applicazione di transazioni di trade per un account client, esse sono costantemente messe nella coda di transazioni del terminale, da cui costantemente vengono inviate al punto di ingresso OnTradeTransaction in ordine di arrivo al terminale.

Quando si maneggiano le transazioni di trade da parte di un Expert Advisor che utilizza l'handler OnTradeTransaction, il terminale continua a gestire le transazioni di trade che nuovamente arrivano. Pertanto, lo stato di un account di trade può già cambiare durante il funzionamento di OnTradeTransaction. Per esempio, mentre un programma MQL5 gestisce un evento di aggiunta un nuovo ordine, esso può essere eseguito, cancellato dalla lista di quelli aperti e spostato nella cronistoria. Inoltre poi, l'applicazione verrà notificata di questi eventi.

La lunghezza delle transazioni della coda comprende 1024 elementi. Se OnTradeTransaction gestisce una nuova transazione per troppo tempo, quelle vecchie in coda possono essere sostituite da quelle più recenti.

  • Generalmente, non vi è rapporto preciso del numero di chiamate OnTrade e OnTradeTransaction. Una chiamata OnTrade corrisponde a una o più chiamate OnTradeTransaction.
  • OnTrade viene chiamato dopo le appropriate chiamate OnTradeTransaction.

OnTester #

La funzione OnTester() è il gestore dell'evento del Tester che viene generato automaticamente dopo un test di storia di un Expert Advisor dopo che un intervallo scelto è finito. La funzione deve essere definita con il tipo double, senza parametri:

double OnTester();

La funzione viene chiamata poco prima della chiamata di OnDeinit() ed ha lo stesso tipo del valore restituito - double. OnTester() può essere utilizzata solo nel testing di Expert Advisors. Il suo scopo principale è quello di calcolare un certo valore che viene utilizzato come criterio Custom max nell' ottimizzazione genetica di parametri di input.

Nell'ottimizzazione genetica viene applicato l'ordinamento discendente ai risultati entro una generazione. Cioè dal punto di vista del criterio di ottimizzazione, i migliori risultati sono quelli con valori più grandi (per i critedi di ottimizzazione Custom max vengono presi in considerazione i valori restituiti dalla funzione OnTester). In tale ordinamento, i valori peggiori sono posizionati all'estremità e successivamente scartati e non partecipano alla formazione della prossima generazione.

OnTesterInit #

La funzione OnTesterInit() è l'handler dell'evento TesterInit, che viene generato automaticamente prima dell'inizio dell' ottimizzazione di un Expert Advisor nel tester strategia. La funzione deve essere definita con il tipo void. Non ha parametri:

void OnTesterInit();

Con l'avvio dell'ottimizzazione, un Expert Advisor con l'handler OnTesterDeinit() o OnTesterPass() viene caricato automaticamente in un grafico separato del terminale con il simbolo e il periodo specificato nel tester, e riceve l'evento TesterInit. La funzione viene utilizzata per l'inizializzazione dell' Expert Advisor prima dell'inizio dell' ottimizzazione per l'ulteriore elaborazione dei risultati di ottimizzazione.

OnTesterPass #

La funzione OnTesterPass() è il gestore dell'evento TesterPass, che viene generato automaticamente quando si riceve un frame durante l'ottimizzazione Expert Advisor nel tester strategia. La funzione deve essere definita con il tipo void. Non ha parametri:

void OnTesterPass();

Un Expert Advisor con l'handler OnTesterPass() viene caricato automaticamente in un grafico separato del terminale con il simbolo/periodo previsto per il testing, ed ottiene gli eventi TesterPass quando un frame viene ricevuto durante l'ottimizzazione. La funzione viene utilizzata per l'handling dinamico dei risultati di ottimizzazione "In loco" senza attendere il suo completamento. I frame vengono aggiunti utilizzando la funzione FrameAdd(), che può essere chiamata dopo la fine di una singolo pass nell' handler OnTester().

OnTesterDeinit #

OnTesterDeinit() è il gestore dell'evento TesterDeinit, che viene generato automaticamente dopo la fine dell' ottimizzazione dell' Expert Advisor nel tester strategia. La funzione deve essere definita con il tipo void. Non ha parametri:

void OnTesterDeinit();

Un Expert Advisor con l'handler TesterDeinit() viene automaticamente caricato su un grafico all'inizio dell'ottimizzazione, e riceve TesterDeinit dopo il suo completamento. La funzione viene utilizzata per la lavorazione finale di tutti i risultati dell'ottimizzazione.

OnBookEvent #

La funzione OnBookEvent() è l'handlerBookEvent. BookEvent viene generato per Expert Advisors ed Indicatori quando cambia il Depth of Market. Deve essere di tipo void ed avere un parametro di tipo stringa:

void OnBookEvent (const stringsymbol);

Per ricevere gli eventi BookEvent per ogni simbolo, basta pre-iscriversi per ricevere questi eventi per quel simbolo con la funzione MarketBookAdd(). Per annullare l'iscrizione a ricevere gli eventi BookEvent per un simbolo particolare, chiamare MarketBookRelease().

A differenza di altri eventi, l'evento BookEvent è broadcast. Ciò significa che se un Expert Advisor sottoscrive la ricezione degli eventi BookEvent utilizzando MarketBookAdd, tutti gli altri Expert Advisors che hanno l'handler OnBookEvent() riceveranno questo evento. È pertanto necessario analizzare il nome del simbolo, che viene passato al gestore come parametro const string& simbol.

OnChartEvent #

OnChartEvent() è l'handler di un gruppo di eventi ChartEvent:

  • CHARTEVENT_KEYDOWN — evento di una sequenza di tasti, quando è focalizzata la finestra del grafico ;
  • CHARTEVENT_MOUSE_MOVE — eventi di spostamento del mouse e gli eventi clic del mouse (se CHART_EVENT_MOUSE_MOVE=true è impostato per il grafico);
  • CHARTEVENT_OBJECT_CREATE — evento di creazione di oggetti grafici (se CHART_EVENT_OBJECT_CREATE=true è impostato per il grafico);
  • CHARTEVENT_OBJECT_CHANGE — evento di cambiamento di proprietà di un oggetto attraverso il dialogo delle proprietà;
  • CHARTEVENT_OBJECT_DELETE — evento di eliminazione oggetto grafico (se CHART_EVENT_OBJECT_DELETE=true è impostato per il grafico);
  • CHARTEVENT_CLICK — evento di un clic del mouse sul grafico;
  • CHARTEVENT_OBJECT_CLICK — evento di un clic del mouse in un oggetto grafico appartenente al grafico;
  • CHARTEVENT_OBJECT_DRAG — evento di un movimento oggetto del grafico utilizzando il mouse;
  • CHARTEVENT_OBJECT_ENDEDIT — evento di modifica del testo finito nella casella di immissione dell'oggetto grafico LabelEdit;
  • CHARTEVENT_CHART_CHANGE — evento di modifica del grafico;
  • CHARTEVENT_CUSTOM+n — ID dell'evento dell'utente, dove n è nell'intervallo da 0 a 65535.
  • CHARTEVENT_CUSTOM_LAST — l'ultimo ID accettabile di un evento personalizzato (CHARTEVENT_CUSTOM +65535).

La funzione può essere chiamata solo in Expert Advisors ed indicatori. La funzione deve essere di tipo void con 4 parametri:

void OnChartEvent(const int id,         // Event ID
                  const long& lparam,   // Parametro dell'evento tipo long
                  const double& dparam, // Parametro dell'evento tipo double
                  const string& sparam  // Parametro dell'evento tipo stringa
  );

Per ciascun tipo di evento, i parametri di input della funzione OnChartEvent() hanno valori definiti che sono necessari per l'elaborazione di questo evento. Gli eventi e valori passati attraverso questi parametri sono elencati nella tabella seguente.

Evento

Valore del parametro id

Valore del parametro lparam

Valore del parametro dparam

Valore del parametro sparam

Evento di una sequenza di tasti

CHARTEVENT_KEYDOWN

codice di un tasto premuto

Ripete in conteggio (il numero di volte che il tasto viene ripetuto come risultato dell'utente che tiene premuto il tasto)

Il valore di stringa di una maschera di bit che descrive lo status dei pulsanti della tastiera

Eventi del mouse (Se la proprietà CHART_EVENT_MOUSE_MOVE=true è impostata per il grafico)

CHARTEVENT_MOUSE_MOVE

la coordinata X

la coordinata Y

Il valore di stringa di una maschera di bit che descrive lo stato dei pulsanti del mouse

Evento di creazione di oggetti grafici (Se CHART_EVENT_OBJECT_CREATE=true è impostato per il grafico)

CHARTEVENT_OBJECT_CREATE

Nome dell'oggetto grafico creato

Evento di cambiamento di proprietà di un oggetto attraverso la finestra delle proprietà

CHARTEVENT_OBJECT_CHANGE

Nome dell'oggetto grafico modificato

Evento di eliminazione oggetto grafico (Se CHART_EVENT_OBJECT_DELETE=true è impostato per il grafico)

CHARTEVENT_OBJECT_DELETE

Nome dell'oggetto grafico eliminato

Evento di un click del mouse sul grafico

CHARTEVENT_CLICK

la coordinata X

la coordinata Y

Evento di un clic del mouse in un oggetto grafico appartenente alla tabella

CHARTEVENT_OBJECT_CLICK

la coordinata X

la coordinata Y

Nome dell'oggetto grafico, in cui l'evento si è verificato

Evento di trascinamento di un oggetto grafico con il mouse

CHARTEVENT_OBJECT_DRAG

Nome dell'oggetto grafico spostato

Evento del testo finito di modifica nella casella di immissione dell'oggetto grafico LabelEdit

CHARTEVENT_OBJECT_ENDEDIT

Nome dell' oggetto grafico LabelEdit, in cui la modifica del testo è stata completata

Evento di modifiche del grafico

CHARTEVENT_CHART_CHANGE

ID dell'evento dell'utente con il numero N

CHARTEVENT_CUSTOM+N

Valore impostato dalla funzione EventChartCustom()

Valore impostato dalla funzione EventChartCustom()

Valore impostato dalla funzione EventChartCustom()

OnCalculate #

La funzione OnCalculate() viene chiamata solo in indicatori personalizzati quando è necessario calcolare i valori degli indicatori dall'evento Calculate. Ciò si verifica tipicamente quando un nuovo tick viene ricevuto per il simbolo, per cui l'indicatore viene calcolato. Questo indicatore non è richiesto da essere collegato a qualsiasi grafico dei prezzi di questo simbolo.

La funzione OnCalculate() deve avere un tipo di ritorno int. Ci sono due possibili definizioni. All'interno di un indicatore non è possibile utilizzare entrambe le versioni della funzione.

La prima forma è destinata a quegli indicatori che possono essere calcolati su un buffer di dati unico. Un esempio di tale indicatore è Custom Moving Average.

int OnCalculate (const int rates_total,      // size of the price[] array
                 const int prev_calculated,  // barre gestite in una chiamata precedente
                 const int begin,            // da cui partono i dati significativi
                 const double& price[]       // dall'array per il calcolo
   );

_*Poiché l'array prezzo[], è uno delle timeseries o un buffer calcolato di un qualche indicatore, può essere passato. Per determinare la direzione di indicizzazione dell'array price[], chiamare ArrayGetAsSeries(). Per non dipendere dai valori di default, è necessario chiamare incondizionatamente la funzione ArraySetAsSeries() per quegli array, con cui si prevede di lavorare.

Timeseries o un indicatore necessario, per essere usato come array price[] può essere selezionato dall'utente nella scheda "Parametri" quando si avvia l'indicatore. Per fare questo, è necessario specificare l'elemento necessario nei menu a tendina del campo "Applica a".

Selezionando le time series per calcolare un indicatore

Per ottenere valori di un indicatore personalizzato da altri programmi MQL5, viene usata la funzione iCustom(), che restituisce l'handle indicatore per le operazioni successive. È inoltre possibile specificare il prezzo l'appropriato array price[] o l'handle di un altro indicatore. Questo parametro dovrebbe essere trasmesso per ultimo nell'elenco delle variabili di input dell' indicatore personalizzato.
Esempio:

voidOnStart()
  {
//---
   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 questo esempio, l'ultimo parametro passato è il valore PRICE_TYPICAL (dall'enumerazione ENUM_APPLIED_PRICE), che indica che l'indicatore personalizzato sarà costruito sui prezzi tipici ottenuti (High+Low+Close)/3. Se questo parametro non viene specificato, l'indicatore è costruito sulla base di valori PRICE_CLOSE, vale a dire i prezzi di chiusura di ogni barra.

Un altro esempio che mostra il passaggio dell'handler dell' indicatore come ultimo parametro per specificare l'array prezzo[], viene riportato nella descrizione della funzione iCustom ().
 

La seconda forma è destinata a tutti gli altri indicatori, in cui più di una time series è utilizzata per i calcoli.

int OnCalculate (const int rates_total,      // grandezza di input della time series
                 const int prev_calculated,  // barre gestite nella chiamata precedente
                 const datetime& time[],     // Orario
                 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
   );

Parametri di open[], high[], low[] e close[] contengono array con prezzi di open, prezzi high e low e prezzi close, del timeframe corrente. Il parametro time[] contiene un array con valori di tempo di apertura, il parametro spread[] ha un array contenente la cronistoria degli spreads (se qualche spread è fornito per il titolo negoziato). I parametri di volume[] e tick_volume[] contengono la cronistoria del volume di trade e tick, rispettivamente.

Per determinare la direzione di indicizzazione di time[], open[], high[], low[], close[], tick_volume[], volume[] and spread[], chiamare ArrayGetAsSeries(). Al fine di non dipendere da valori di default, si dovrebbe chiamare incondizionatamente la funzioneArraySetAsSeries() per queli array, con cui ci si aspetta di lavorare.

Il primo parametro rates_total contiene il numero di barre, disponibile per l'indicatore per il calcolo, e corrisponde al numero di barre disponibili nel grafico.

Dovremmo notare la connessione tra il valore di ritorno di OnCalculate() e il secondo parametro di input prev_calculated. Durante la chiamata di funzione, il parametro prev_calculated contiene un valore restituito da OnCalculate() durante la precedente chiamata. Questo permette agli algoritmi economici di fare calcoli con l'indicatore personalizzato al fine di evitare calcoli ripetuti per quelle barre che non sono state modificati sin dalla precedente esecuzione di questa funzione.

Per questo, è di solito sufficiente restituire il valore del parametro rates_total, che contiene il numero di barre nella chiamata alla funzione in corso. Se dopo l'ultima chiamata di OnCalculate() i dati sui prezzi sono cambiati (uno storico più profonda scaricato o spazi di storico riempiti di vuoti), il valore del parametro di input prev_calculated sarà impostato a zero dal terminale.

Nota: se OnCalculate restituisce zero, allora i valori dell'indicatore non sono mostrati nella DataWindow del terminale client.

Per capire meglio, sarebbe utile aviare l'indicatore, il cui codice è allegato qui sotto.

Esempio Indicatore:

#property indicator_chart_window
#property indicator_buffers 1
#property indicator_plots   1
//---- plot linea
#property indicator_label1  "Line"
#property indicator_type1   DRAW_LINE
#property indicator_color1  clrDarkBlue
#property indicator_style1  STYLE_SOLID
#property indicator_width1  1
//--- buffers indicatore
double         LineBuffer[];
//+--------------------------------------------------------------------------------+
//| Funzione di inizializzazione Indicatore Personalizzato                         |
//+--------------------------------------------------------------------------------+
int OnInit()
  {
//--- mappatura buffers indicatore
   SetIndexBuffer(0,LineBuffer,INDICATOR_DATA);
//---
   return(INIT_SUCCEEDED);
  }
//+--------------------------------------------------------------------------------+
//| Funzione di iterazione indicatore personalizato                                |
//+--------------------------------------------------------------------------------+
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[])
  {
//--- Prende il numero di barre disponibili per il simbolo corrente e periodo del grafico
   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]);
//--- restituisce il valore di prev_calculated per la prossima chiamata
   return(rates_total);
  }

Vedi anche

Eseguire Programmi, Eventi Terminale Client, Utilizzo degli eventi