MQL5 RiferimentoGestione degli EventiOnTradeTransaction

OnTradeTransaction

La funzione è chiamata nell' EA quando si verifica l'evento TradeTransaction. La funzione è destinata alla gestione dei risultati di esecuzione delle richieste di trade.

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

Parametri

trans

[in] MqlTradeTransaction tipo di variabile che descrive una transazione effettuata su un conto di trading.

request

[in] MqlTradeRequest tipo di variabile che descrive una richiesta di trade che ha portato alla transazione. Contiene i valori per i tipi di transazione TRADE_TRANSACTION_REQUEST solo.

result

[in] MqlTradeResult tipo di variabile contenente un risultato di esecuzione di una richiesta di trade che ha portato alla transazione. Contiene i valori per i tipi di transazione TRADE_TRANSACTION_REQUEST solo.

Valore di ritorno

Nessun valore di ritorno

Nota

OnTradeTransaction() è chiamato a gestire l'evento TradeTransaction inviato dal trade server al terminale nei seguenti casi:

invia una richiesta di trade da un programma MQL5 usando le funzioni OrderSend()/OrderSendAsync() e la sua successiva esecuzione;
inviare manualmente una richiesta di trade tramite la GUI e la sua successiva esecuzione;
attivazioni di ordini pendenti e stop, sul server;
eseguire operazioni sul lato del trade server.

I dati sul tipo di transazione sono contenuti nel tipo di campo della variabile trans. I tipi di transazioni di trade sono descritti nell'enumerazione ENUM_TRADE_TRANSACTION_TYPE:

TRADE_TRANSACTION_ORDER_ADD - aggiunta di un nuovo ordine attivo
TRADE_TRANSACTION_ORDER_UPDATE - modifica di un ordine esistente
TRADE_TRANSACTION_ORDER_DELETE - eliminazione di un ordine dall'elenco di quelli attivi
TRADE_TRANSACTION_DEAL_ADD: aggiunta di un affare alla cronistoria
TRADE_TRANSACTION_DEAL_UPDATE - modifica di un affare nella cronistoria
TRADE_TRANSACTION_DEAL_DELETE: eliminazione di un affare dalla cronistoria
TRADE_TRANSACTION_HISTORY_ADD - aggiunta di un ordine alla cronologia come risultato di esecuzione o cancellazione
TRADE_TRANSACTION_HISTORY_UPDATE - modifica di un ordine nella cronistoria degli ordini
TRADE_TRANSACTION_HISTORY_DELETE - eliminazione di un ordine dalla cronistoria degli ordini
TRADE_TRANSACTION_POSITION - modifica della posizione non correlata ad un'esecuzione di trade
TRADE_TRANSACTION_REQUEST - notifica che una richiesta di trade è stata elaborata dal server ed il risultato del suo trattamento è stato ricevuto.

Quando si gestiscono le transazioni del tipo TRADE_TRANSACTION_REQUEST, è necessario analizzare il secondo e il terzo parametro della funzione OnTradeTransaction() - request e result - per ricevere ulteriori informazioni.

L'invio di una richiesta di trade porta ad una catena di transazioni di trade su un conto di trading: 1) la richiesta è accettata per l'elaborazione, 2) viene creato un ordine di acquisto appropriato per l'account, 3) l'ordine viene quindi eseguito, 4) l'ordine eseguito viene rimosso dalla lista di quelli attivi, 5) aggiunto alla cronistoria degli ordini, 6) la transazione successiva viene aggiunta alla cronistoria e 7) viene creata una nuova posizione. Tutte queste fasi sono transazioni di trade. L'arrivo di ciascuna di tali transazioni al terminale è l'evento TradeTransaction. La priorità dell'arrivo di queste transazioni al terminale non è garantita. Pertanto, non dovresti aspettarti che un gruppo di transazioni arrivi dopo un altro quando sviluppi il tuo algoritmo di trading.

Quando le transazioni vengono elaborate dal gestore OnTradeTransaction() di EA, il terminale continua a gestire le transazioni di trade in entrata. Pertanto, lo stato dell'account di trading può cambiare nel corso dell'operazione OnTradeTransaction(). Ad esempio, mentre un programma MQL5 gestisce l'aggiunta di un nuovo ordine, può essere eseguito, eliminato dall'elenco degli ordini aperti e spostato nella cronistoria. Il programma viene informato di tutti questi eventi.

La lunghezza della coda delle transazioni comprende 1024 elementi. Se OnTradeTransaction() gestisce ancora un'altra transazione troppo a lungo, le precedenti possono essere sostituite da nuove transazioni nella coda.

L'handler OnTrade() viene chiamato dopo le chiamate OnTradeTransaction() appropriate. In generale, non esiste una correlazione esatta nel numero di chiamate OnTrade() e OnTradeTransaction(). Una chiamata OnTrade () corrisponde a una o più chiamate OnTradeTransaction.

Ogni evento Trade può apparire come risultato di una o più richieste di trade. Le richieste di trade vengono inviate al server utilizzando OrderSend() o OrderSendAsync(). Ogni richiesta può portare a diversi eventi di trade. Non è possibile fare affidamento sull'affermazione "Una richiesta - un evento di trade", poiché l'elaborazione degli eventi può essere eseguita in più fasi ed ogni operazione può modificare lo stato degli ordini, delle posizioni e della cronistoria di trade.

Esempio di EA con il gestore OnTradeTransaction()

//+------------------------------------------------------------------+
//|                                    OnTradeTransaction_Sample.mq5 |
//|                        Copyright 2018, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2000-2024, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property description "Listener di esempio di eventi TradeTransaction"
//+------------------------------------------------------------------+
//| Funzione di inizializzazione Expert                              |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
   PrintFormat("LAST PING=%.f ms",
               TerminalInfoInteger(TERMINAL_PING_LAST)/1000.);
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Funzione tick Expert                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//---

  }
//+------------------------------------------------------------------+
//| Funzione TradeTransaction                                        |
//+------------------------------------------------------------------+
void OnTradeTransaction(const MqlTradeTransaction &trans,
                        const MqlTradeRequest &request,
                        const MqlTradeResult &result)
  {
//---
   static int counter=0;   // contatore di chiamate OnTradeTransaction()
   static uint lasttime=0; // orario dell'ultima chiamata OnTradeTransaction()
//---
   uint time=GetTickCount();
//--- se l'ultima transazione è stata eseguita più di 1 secondo fa,
   if(time-lasttime>1000)
     {
      counter=0; // allora questa è una nuova operazione di trade, il contatore può essere resettato
      if(IS_DEBUG_MODE)
         Print(" Nuova operazione di trade");
     }
   lasttime=time;
   counter++;
   Print(counter,". ",__FUNCTION__);
//--- risultato dell'esecuzione della richiesta di trade
   ulong            lastOrderID   =trans.order;
   ENUM_ORDER_TYPE  lastOrderType =trans.order_type;
   ENUM_ORDER_STATE lastOrderState=trans.order_state;
//--- il nome del simbolo, per il quale è stata eseguita una transazione
   string trans_symbol=trans.symbol;
//--- tipo di transazione
   ENUM_TRADE_TRANSACTION_TYPE  trans_type=trans.type;
   switch(trans.type)
     {
      case  TRADE_TRANSACTION_POSITION:   // modifica della posizione
        {
         ulong pos_ID=trans.position;
         PrintFormat("MqlTradeTransaction: Posizione  #%I64u %s modificata: SL=%.5f TP=%.5f",
                     pos_ID,trans_symbol,trans.price_sl,trans.price_tp);
        }
      break;
      case TRADE_TRANSACTION_REQUEST:     // invio di una richiesta di trade
         PrintFormat("MqlTradeTransaction: TRADE_TRANSACTION_REQUEST");
         break;
      case TRADE_TRANSACTION_DEAL_ADD:    // aggiunta trade
        {
         ulong          lastDealID   =trans.deal;
         ENUM_DEAL_TYPE lastDealType =trans.deal_type;
         double        lastDealVolume=trans.volume;
         // --- Trade ID in un sistema interno - un ticket assegnato da uno scambio
         string Exchange_ticket="";
         if(HistoryDealSelect(lastDealID))
            Exchange_ticket=HistoryDealGetString(lastDealID,DEAL_EXTERNAL_ID);
         if(Exchange_ticket!="")
            Exchange_ticket=StringFormat("(Exchange deal=%s)",Exchange_ticket);

         PrintFormat("MqlTradeTransaction: %s deal #%I64u %s %s %.2f lotti   %s",EnumToString(trans_type),
                     lastDealID,EnumToString(lastDealType),trans_symbol,lastDealVolume,Exchange_ticket);
        }
      break;
      case TRADE_TRANSACTION_HISTORY_ADD: // aggiunta di un ordine alla cronistoria
        {
// --- ID ordine in un sistema interno - un ticket assegnato da uno scambio
         string Exchange_ticket="";
         if(lastOrderState==ORDER_STATE_FILLED)
           {
            if(HistoryOrderSelect(lastOrderID))
               Exchange_ticket=HistoryOrderGetString(lastOrderID,ORDER_EXTERNAL_ID);
            if(Exchange_ticket!="")
               Exchange_ticket=StringFormat("(Exchange ticket=%s)",Exchange_ticket);
           }
         PrintFormat("MqlTradeTransaction: %s ordine #%I64u %s %s %s   %s",EnumToString(trans_type),
                     lastOrderID,EnumToString(lastOrderType),trans_symbol,EnumToString(lastOrderState),Exchange_ticket);
        }
      break;
      default: // altre transazioni
        {
         // --- ID ordine in un sistema interno - un ticket assegnato da Exchange
         string Exchange_ticket="";
         if(lastOrderState==ORDER_STATE_PLACED)
           {
            if(OrderSelect(lastOrderID))
               Exchange_ticket=OrderGetString(ORDER_EXTERNAL_ID);
            if(Exchange_ticket!="")
               Exchange_ticket=StringFormat("Exchange ticket=%s",Exchange_ticket);
           }
         PrintFormat("MqlTradeTransaction: %s ordine #%I64u %s %s   %s",EnumToString(trans_type),
                     lastOrderID,EnumToString(lastOrderType),EnumToString(lastOrderState),Exchange_ticket);
        }
      break;
     }
//--- ticket dell'ordine
   ulong orderID_result=result.order;
   string retcode_result=GetRetcodeID(result.retcode);
   if(orderID_result!=0)
      PrintFormat("MqlTradeResult: ordine #%d retcode=%s ",orderID_result,retcode_result);
//---
  }
//+------------------------------------------------------------------+
//| convertire i codici di risposta numerici nella stringa mnemonica |
//+------------------------------------------------------------------+
string GetRetcodeID(int retcode)
  {
   switch(retcode)
     {
      case 10004: return("TRADE_RETCODE_REQUOTE");             break;
      case 10006: return("TRADE_RETCODE_REJECT");              break;
      case 10007: return("TRADE_RETCODE_CANCEL");              break;
      case 10008: return("TRADE_RETCODE_PLACED");              break;
      case 10009: return("TRADE_RETCODE_DONE");                break;
      case 10010: return("TRADE_RETCODE_DONE_PARTIAL");        break;
      case 10011: return("TRADE_RETCODE_ERROR");               break;
      case 10012: return("TRADE_RETCODE_TIMEOUT");             break;
      case 10013: return("TRADE_RETCODE_INVALID");             break;
      case 10014: return("TRADE_RETCODE_INVALID_VOLUME");      break;
      case 10015: return("TRADE_RETCODE_INVALID_PRICE");       break;
      case 10016: return("TRADE_RETCODE_INVALID_STOPS");       break;
      case 10017: return("TRADE_RETCODE_TRADE_DISABLED");      break;
      case 10018: return("TRADE_RETCODE_MARKET_CLOSED");       break;
      case 10019: return("TRADE_RETCODE_NO_MONEY");            break;
      case 10020: return("TRADE_RETCODE_PRICE_CHANGED");       break;
      case 10021: return("TRADE_RETCODE_PRICE_OFF");           break;
      case 10022: return("TRADE_RETCODE_INVALID_EXPIRATION");  break;
      case 10023: return("TRADE_RETCODE_ORDER_CHANGED");       break;
      case 10024: return("TRADE_RETCODE_TOO_MANY_REQUESTS");   break;
      case 10025: return("TRADE_RETCODE_NO_CHANGES");          break;
      case 10026: return("TRADE_RETCODE_SERVER_DISABLES_AT");  break;
      case 10027: return("TRADE_RETCODE_CLIENT_DISABLES_AT");  break;
      case 10028: return("TRADE_RETCODE_LOCKED");              break;
      case 10029: return("TRADE_RETCODE_FROZEN");              break;
      case 10030: return("TRADE_RETCODE_INVALID_FILL");        break;
      case 10031: return("TRADE_RETCODE_CONNECTION");          break;
      case 10032: return("TRADE_RETCODE_ONLY_REAL");           break;
      case 10033: return("TRADE_RETCODE_LIMIT_ORDERS");        break;
      case 10034: return("TRADE_RETCODE_LIMIT_VOLUME");        break;
      case 10035: return("TRADE_RETCODE_INVALID_ORDER");       break;
      case 10036: return("TRADE_RETCODE_POSITION_CLOSED");     break;
      default:
         return("TRADE_RETCODE_UNKNOWN="+IntegerToString(retcode));
         break;
     }
//---
  }

Guarda anche

OrderSend, OrderSendAsync, OnTradeTransaction, Struttura della richiesta di Trade, Struttura delle transazioni di trade, Tipi di transazione di trade, Tipi di operazioni di trade, Eventi del terminale client

OnTrade

OnBookEvent