Discussione sull’articolo "Architettura basata sugli eventi in MQL5: Come convertire un Expert Advisor in un sistema di trading a tutti gli effetti"

Nuovo commento
 

Il nuovo articolo Architettura basata sugli eventi in MQL5: Come convertire un Expert Advisor in un sistema di trading a tutti gli effetti è stato pubblicato:

L'articolo è dedicato all'architettura basata sugli eventi in MQL5 e descrive il passaggio dal modello monolitico OnTick all'elaborazione distribuita. Prenderemo in considerazione eventi predefiniti e personalizzati, servizi e messaggistica tra programmi, nonché errori architetturali comuni. Un esempio pratico dimostra come organizzare le interazioni tra indicatori e un Expert Advisor (EA) per ridurre il carico, migliorare la leggibilità e semplificare la manutenzione.

Quando si sviluppa un Expert Advisor (EA) in MQL5, molti iniziano con la soluzione più ovvia: inseriscono tutta la logica nel metodo OnTick. È davvero più facile iniziare in questo modo. Ma questo approccio ha un costo nascosto. Con la crescita del progetto, le regole di trading, la verifica delle condizioni, l'elaborazione degli ordini, l'aggiornamento dei dati, l'interfaccia, i calcoli e la registrazione vengono tutti combinati in un unico gestore. Di conseguenza, il codice cresce fino a diventare ingestibile e di fatto, è tenuto insieme solo dalla pura fortuna. Qualsiasi cambiamento in un punto inizia a influenzare parti completamente diverse del sistema. Si corregge il pannello visivo e improvvisamente lo scenario di trading smette di funzionare correttamente. Si modifica il filtro di entrata - un errore viene visualizzato durante il controllo in background. Un simile EA si trasforma rapidamente in un monolite fragile, dove la complessità cresce più velocemente della fiducia dello sviluppatore.

MetaTrader 5 è molto più di un semplice flusso di quotazioni. Si basa su eventi. Il terminale riceve costantemente tick, segnali del timer, azioni dell'utente, cambiamenti dello stato di trading ed eventi relativi alla profondità del mercato. Questi messaggi devono essere gestiti separatamente. Per raggiungere questo obiettivo, MQL5 prevede diversi gestori di eventi, ognuno con la propria area di responsabilità. OnTick è responsabile degli aggiornamenti di mercato. OnTimer — per attività periodiche e in background. OnChartEvent — per la reazione all'interfaccia grafica e alle azioni dell'utente. Quando la logica viene distribuita in base al suo scopo, il codice smette di essere disordinato. Inizia ad assomigliare a un sistema ingegneristico ben strutturato, in cui ogni modulo svolge il proprio compito e non interferisce con quelli vicini.

Eventi MQL5

In questo articolo analizzeremo come passare dal modello tutto in OnTick verso un'architettura più matura basata sugli eventi. Analizziamo i ruoli dei gestori di eventi predefiniti e degli eventi personalizzati, nonché dei servizi non collegati a un grafico. Analizziamo più da vicino gli errori tipici che compromettono l'architettura ancor prima che inizi il lavoro vero e proprio. L'idea principale è semplice: quando MQL5 viene utilizzato per lo scopo per cui è stato progettato, ci permette di costruire non solo robot di trading, ma anche sistemi applicativi completi.


Autore: MetaQuotes

 
Lavorare con gli indicatori senza buffer in un sistema di trading automatico: probabilmente può servire da esempio.
  
//+------------------------------------------------------------------+
//| Funzione di trading                                                   |
//+------------------------------------------------------------------+
void OnTrade()
  {
   Sleep(0);
//---
  }
//+------------------------------------------------------------------+
//| Funzione TradeTransaction                                        |
//+------------------------------------------------------------------+
void OnTradeTransaction(const MqlTradeTransaction& trans,
                        const MqlTradeRequest& request,
                        const MqlTradeResult& result)
  {
   Sleep(0);
//---
  }
A che scopo?
  
            if(!cTrade.PositionClose(cPosition.Ticket()))
              {
               PrintFormat("Error close Sell position: %d", GetLastError());
               return;
              }
A quanto pare, cTrade contiene un'istruzione di uscita in caso di errore.
 
fxsaber #:
Lavorare con gli indicatori senza buffer in un sistema automatizzato: probabilmente può servire da esempio.


Nell'esempio viene effettuato un aggiornamento rigoroso dei dati del simbolo (sarebbe opportuno utilizzare MQL_TESTER).

void OnTick()
  {
//---
   if(BuySignal)
     {
      cSymbol.Refresh();
      cSymbol.RefreshRates();


Tuttavia, non viene verificata l’attualità del segnale calcolato tramite gli eventi e i tick. E questo è un problema reale.


È possibile attenuarla tramite OrderSend asincroni, ma non risolverla. Pertanto, anche in un esempio come questo, è necessario trasmettere additionally nell’evento ChartEvent i dati del tick in cui si è verificata la generazione dell’evento.

 
Fantastico, il tipo di servizio dei programmi MQL5 è davvero sottovalutato.
 
Ottimo esempio, grazie.
Nuovo commento