MQL5 RiferimentoCostanti, Enumerazioni e StruttureStrutture DatiStruttura di una Transazione di Trade

Struttura di una Transazione di Trade (MqlTradeTransaction)

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 acquisto di mercato, esso viene gestito, un ordine di acquisto appropriata viene creato per l'account, l'ordine quindi viene eseguito e rimosso dalla lista di quelli aperti, e poi viene aggiunto alla cronistoria ordini, un appropriato aff viene aggiunto alla cronistoria ed una nuova posizione viene creata. Tutte queste azioni sono transazioni di trade.

Lo Speciale handler OnTradeTransaction() viene fornito in MQL5 per ottenere transazioni di trade applicate ad un account. Il primo parametro dell'handler ottiene la struttura MqlTradeTransaction descrivendo transazioni di trade.

struct MqlTradeTransaction
  {
   ulong                         deal;             // Ticket dell'Affare
   ulong                         order;            // Ticket dell'Ordine
   string                        symbol;           // Nome del simbolo di Trade
   ENUM_TRADE_TRANSACTION_TYPE   type;             // Tipo del simbolo di Trade
   ENUM_ORDER_TYPE               order_type;       // Tipo di Ordine
   ENUM_ORDER_STATE              order_state;      // Stato dell'Ordine
   ENUM_DEAL_TYPE                deal_type;        // Tipo dell'Affare
   ENUM_ORDER_TYPE_TIME          time_type;        // Tipo di Ordine per periodo dell'azione
   datetime                      time_expiration;  // Orario di espirazione dell'Ordine
   double                        price;            // Prezzo
   double                        price_trigger;    // Prezzo di attivazione dell'ordine Stop Limit
   double                        price_sl;         // Livello Stop Loss
   double                        price_tp;         // Livello Take Profit
   double                        volume;           // Volume in lotti
   ulong                         position;         // Position ticket
   ulong                         position_by;      // Ticket of an opposite position
  };

Descrizione Campi

Campo	Descrizione
deal	Ticket affare.
ordine	Ticket dell' Ordine.
symbol	Il nome del simbolo di trade, per il quale viene eseguita l'operazione.
type	Tipo di transazione di trade. Il valore può essere uno dei valori dell'enumerazione ENUM_TRADE_TRANSACTION_TYPE.
order_type	Tipo ordine di trade. Il valore può essere uno dei valori dell'enumerazione ENUM_ORDER_TYPE.
order_state	Stato dell'ordine di trade . Il valore può essere uno dei valori dell'enumerazione ENUM_ORDER_STATE.
deal_type	Tipo di affare. Il valore può essere uno dei valori dell'enumerazione ENUM_DEAL_TYPE.
time_type	Tipo di ordine all'espirazione. Il valore può essere uno dei valori ENUM_ORDER_TYPE_TIME.
time_expiration	Termine di espirazione dell'ordine (per ordini dei tipi ORDER_TIME_SPECIFIED e ORDER_TIME_SPECIFIED_DAY).
price	Prezzo. A seconda del tipo di transazione di trade, può essere il prezzo di un ordine, un affare o una posizione.
price_trigger	Prezzo di stop(attivazione) dell'ordine di stop limit (ORDER_TYPE_BUY_STOP_LIMIT e ORDER_TYPE_SELL_STOP_LIMIT).
price_sl	Prezzo di Stop Loss. A seconda del tipo di transazione di trade, può riferirsi ad un ordine, un affare o una posizione.
price_tp	Prezzo Take Profit. A seconda del tipo di transazione di trade, può riferirsi ad un ordine, un affare o una posizione.
volume	Volume in lotti. A seconda del tipo di transazione di trade, potrebbe indicare il volume attuale di un ordine, di un affare o di una posizione.

Il parametro essenziale per l'analisi della transazione ricevuta è il tipo specificato nel campo type. Ad esempio, se una transazione è di tipo TRADE_TRANSACTION_REQUEST (viene ricevuto il risultato dell' handling di una richiesta di trade dal server), la struttura ha solo un campo che viene riempito completamente - type. Altri campi non vengono analizzati. In questo caso, si possono analizzare due ulteriori richieste ed i parametri risultato presentati all'handler OnTradeTransaction(), come mostrato di seguito.

Avendo i dati su un tipo di operazione di trading, si può decidere l'analisi dello stato attuale di ordini, le posizioni e le offerte per un conto di trading. Ricordate che una richiesta di trade inviata al server dal terminale può generare generare diverse nuove operazioni. La priorità del loro arrivo presso il terminale non è garantita.

La struttura MqlTradeTransaction viene riempita in modi diversi a seconda del tipo di transazione di trade (ENUM_TRADE_TRANSACTION_TYPE):

TRADE_TRANSACTION_ORDER_* and TRADE_TRANSACTION_HISTORY_*

I seguenti campi nella struttura MqlTradeTransaction sono riempiti per le transazioni di trade relative alla gestione degli ordini aperti (TRADE_TRANSACTION_ORDER_ADD, TRADE_TRANSACTION_ORDER_UPDATE e TRADE_TRANSACTION_ORDER_DELETE) e la cronistoria degli ordini (TRADE_TRANSACTION_HISTORY_ADD, TRADE_TRANSACTION_HISTORY_UPDATE, TRADE_TRANSACTION_HISTORY_DELETE):

order - ticket dell'ordine;
symbol - nome simbolo dell'ordine;
type - tipo di transazione di trade;
order_type - tipo di ordine;
orders_state - corrente stato dell'ordine;
time_type - tipo di espirazione dell'ordine;
time_expiration - orario di espirazione dell'ordine (per ordini aventi i tipi di espirazione ORDER_TIME_SPECIFIED e ORDER_TIME_SPECIFIED_DAY);
price - order price specified by a client;
price_trigger - prezzo di stop dell'ordine di stop limit (solo per ORDER_TYPE_BUY_STOP_LIMIT e ORDER_TYPE_SELL_STOP_LIMIT);
price_sl - prezzo dell'ordine di Stop Loss (filled, se specificato nell'ordine);
price_tp - prezzo dell'ordine di Take Profit (filled, se specificato nell'ordine);
volume - corrente volume dell'ordine (unfilled). Il volume iniziale dell'ordine può essere trovato nella cronistoria degli ordini usando la funzione HistoryOrders *.

TRADE_TRANSACTION_DEAL_*

I seguenti campi nella struttura MqlTradeTransaction vengono riempiti per le transazioni di trade relative all' handling delgli affari (TRADE_TRANSACTION_DEAL_ADD, TRADE_TRANSACTION_DEAL_UPDATE e TRADE_TRANSACTION_DEAL_DELETE):

deal - ticket dell'affare;
order - ticket dell'ordine, dove è stato eseguito l'affare su cui si basa;
symbol - nome del simbolo dell'affare;
type - tipo di transazione di trade;
deal_type - tipo di affare;
price - prezzo dell'affare;
price_sl - prezzo di Stop Loss (filled, se specificato nell'ordine, dove è stato eseguito l'affare su cui si basa);
price_tp - prezzo di Take Profit (filled, se specificato nell'ordine, dove è stato eseguito l'affare su cui si basa);
volume - volume dell'affare in lotti.

TRADE_TRANSACTION_POSITION

I seguenti campi nella struttura MqlTradeTransaction sono riempiti per le transazioni di trade relative alla modifica delle posizioni non connesse all'esecuzione degli affari (TRADE_TRANSACTION_POSITION):

symbol - nome di posizione del simbolo;
type - tipo di transazione di trade;
deal_type - tipo di posizione (DEAL_TYPE_BUY o DEAL_TYPE_SELL);
prezzo - prezzo di apertura media ponderata della posizione;
price_sl - prezzo di Stop Loss;
price_tp - prezzo di Take Profit;
volume - volume della posizione in lotti, se è stato cambiato.

Il ambio della posizione (aggiunta, cambio o chiusura), come risultato dell'esecuzione dell'affare, non porta al verificarsi della transazione TRADE_TRANSACTION_POSITION.

TRADE_TRANSACTION_REQUEST

Solo un campo nella struttura MqlTradeTransaction è riempito per le transazioni di trade che descrivono il fatto che una richiesta di trade è stata elaborata dal server ed il risultato dell' elaborazione è stato ricevuto (TRADE_TRANSACTION_REQUEST):

type - tipo di transazione di trade;

Solo il campo tipo (tipo di transazione di trade) deve essere analizzato per tali operazioni. Il secondo e terzo parametro della funzione OnTradeTransaction (richiesta e risultato) devono essere analizzati per ulteriori dati.

Esempio:

input int MagicNumber=1234567;

//--- abilita la classe di trading CTrade e dichiara la variabile di questa classe
#include <Trade\Trade.mqh>
CTrade trade;
//--- flags per installare ed eliminare gli ordini pendenti
bool pending_done=false;
bool pending_deleted=false;
//--- i ticket degli ordini pendenti verranno memorizzati qui
ulong order_ticket;
//+--------------------------------------------------------------------------------+
//| Funzione di inizializzazione dell' Expert                                      |
//+--------------------------------------------------------------------------------+
int OnInit()
  {
//--- imposta il MagicNumber per machiare tutti i nostri ordini
   trade.SetExpertMagicNumber(MagicNumber);
//--- le richieste di trade verranno eseguite in modalità asincrona usando la funzione OrderSendAsync()
   trade.SetAsyncMode(true);
//--- inizializza la variabile per zero
   order_ticket=0;
//---
   return(INIT_SUCCEEDED);
  }
//+--------------------------------------------------------------------------------+
//| Funzione tick dell'Expert                                                      |
//+--------------------------------------------------------------------------------+
void OnTick()
  {
//---installa un ordine pendente
   if(!pending_done)
     {
      double ask=SymbolInfoDouble(_Symbol,SYMBOL_ASK);
      double buy_stop_price=NormalizeDouble(ask+1000*_Point,(int)SymbolInfoInteger(_Symbol,SYMBOL_DIGITS));
      bool res=trade.BuyStop(0.1,buy_stop_price,_Symbol);
      //--- se la funzione BuyStop() viene eseguita con successo
      if(res)
        {
         pending_done=true;
         //--- ottiene il risultato dell'invio di una richiesta da ctrade
         MqlTradeResult trade_result;
         trade.Result(trade_result);
         //--- ottiene request_id per la richiesta inviata
         uint request_id=trade_result.request_id;
         Print("La richiesta è stata inviata per impostare un ordine pendente. Request_ID=",request_id);
         //--- memorizza il ticket dell'ordine (sarà zero se si usa la modalità di invio asincrona a CTrade)
         order_ticket=trade_result.order;
         //--- tutto è stato fatto, uscita precoce dall'handler OnTick()
         return;
        }
     }
//--- elimina l'ordine pendente
   if(!pending_deleted)
      //--- controllo addizionale
      if(pending_done && (order_ticket!=0))
        {
         //--- prova ad eliminare l'ordine pendente
         bool res=trade.OrderDelete(order_ticket);
         Print("OrderDelete=",res);
         //--- quando la richiesta di eliminazione viene inviata con successo
         if(res)
           {
            pending_deleted=true;
            //--- ottiene il risultato della richiesta di esecuzione
            MqlTradeResult trade_result;
            trade.Result(trade_result);
            //--- prende l' ID della richiesta dal risultato
            uint request_id=trade_result.request_id;
            //--- visualizza nel Journal
            Print("La richiesta è stata inviata per eliminare un ordine pendente #",order_ticket,
                  ". Request_ID=",request_id,
                  "\r\n");
            //--- fissa il ticket dell'ordine dal risultato della richiesta
            order_ticket=trade_result.order;
           }
        }
//---
  }
//+--------------------------------------------------------------------------------+
//| Funzione TradeTransaction                                                      |
//+--------------------------------------------------------------------------------+
void OnTradeTransaction(const MqlTradeTransaction &trans,
                        const MqlTradeRequest &request,
                        const MqlTradeResult &result)
  {
//--- ottiene type come valore dell'enumerazione
   ENUM_TRADE_TRANSACTION_TYPE type=(ENUM_TRADE_TRANSACTION_TYPE)trans.type;
//--- se la transazione è il risultato dell'handling richiesta, verrà visualizzato solo il suo nome
   if(type==TRADE_TRANSACTION_REQUEST)
     {
      Print(EnumToString(type));
      //--- visualizza il nome stringa della richiesta maneggiata
      Print("------------RequestDescription\r\n",RequestDescription(request));
      //--- mostra la descrizione del risultato della richiesta
      Print("------------ResultDescription\r\n",TradeResultDescription(result));
      //--- memorizza il ticket dell'ordine per la sua cancellazione al prossimo handling in OnTick()
      if(result.order!=0)
        {
         //--- elimina quest'ordine dal suo ticket alla prossima chiamata OnTick()
         order_ticket=result.order;
         Print(" Ticket dell'ordine pendente ",order_ticket,"\r\n");
        }
     }
   else // mostra la descrizione completa per le transazioni di altro tipo
//--- mostra la descrizione di una transazione ricevuta nel Journal
      Print("------------TransactionDescription\r\n",TransactionDescription(trans));

//---
  }
//+--------------------------------------------------------------------------------+
//| Restituisce la descrizione testuale della transazione                          |
//+--------------------------------------------------------------------------------+
string TransactionDescription(const MqlTradeTransaction &trans)
  {
//---
   string desc=EnumToString(trans.type)+"\r\n";
   desc+="Simbolo: "+trans.symbol+"\r\n";
   desc+="Ticket dell'affare: "+(string)trans.deal+"\r\n";
   desc+="Tipo di Affare: "+EnumToString(trans.deal_type)+"\r\n";
   desc+="Ticket dell'Ordine: "+(string)trans.order+"\r\n";
   desc+="Tipo di Ordine: "+EnumToString(trans.order_type)+"\r\n";
   desc+="Stato dell'Ordine: "+EnumToString(trans.order_state)+"\r\n";
   desc+="Tipo dell'orario dell'Ordine: "+EnumToString(trans.time_type)+"\r\n";
   desc+="Espirazione dell'Ordine: "+TimeToString(trans.time_expiration)+"\r\n";
   desc+="Prezzo: "+StringFormat("%G",trans.price)+"\r\n";
   desc+="Innesco Prezzo: "+StringFormat("%G",trans.price_trigger)+"\r\n";
   desc+="Stop Loss: "+StringFormat("%G",trans.price_sl)+"\r\n";
   desc+="Take Profit: "+StringFormat("%G",trans.price_tp)+"\r\n";
   desc+="Volume: "+StringFormat("%G",trans.volume)+"\r\n";
//--- restituisce la stringa ottenuta
   return desc;
  }
//+--------------------------------------------------------------------------------+
//| Restituisce la descrizione testuale della transazione                          |
//+--------------------------------------------------------------------------------+
string RequestDescription(const MqlTradeRequest &request)
  {
//---
   string desc=EnumToString(request.action)+"\r\n";
   desc+="Simbolo: "+request.symbol+"\r\n";
   desc+="Magic Number: "+StringFormat("%d",request.magic)+"\r\n";
   desc+="Ticket dell'Ordine: "+(string)request.order+"\r\n";
   desc+="Tipo dell'Ordine: "+EnumToString(request.type)+"\r\n";
   desc+="Riempimento dell'Ordine: "+EnumToString(request.type_filling)+"\r\n";
   desc+="Tipo di orario dell'Ordine: "+EnumToString(request.type_time)+"\r\n";
   desc+="Espirazione dell'Ordine: "+TimeToString(request.expiration)+"\r\n";
   desc+="Prezzo: "+StringFormat("%G",request.price)+"\r\n";
   desc+="Punti di deviazione: "+StringFormat("%G",request.deviation)+"\r\n";
   desc+="Stop Loss: "+StringFormat("%G",request.sl)+"\r\n";
   desc+="Take Profit: "+StringFormat("%G",request.tp)+"\r\n";
   desc+="Stop Limit: "+StringFormat("%G",request.stoplimit)+"\r\n";
   desc+="Volume: "+StringFormat("%G",request.volume)+"\r\n";
   desc+="Commento: "+request.comment+"\r\n";
//--- restituisce la stringa ottenuta
   return desc;
  }
//+--------------------------------------------------------------------------------+
//| Restituisce la descrizione testuale del risultato della richiesta di handling  |
//+--------------------------------------------------------------------------------+
string TradeResultDescription(const MqlTradeResult &result)
  {
//---
   string desc="Retcode "+(string)result.retcode+"\r\n";
   desc+="ID Richiesta: "+StringFormat("%d",result.request_id)+"\r\n";
   desc+="Ticket dell'Ordine: "+(string)result.order+"\r\n";
   desc+="Ticket dell'Affare: "+(string)result.deal+"\r\n";
   desc+="Volume: "+StringFormat("%G",result.volume)+"\r\n";
   desc+="Prezzo: "+StringFormat("%G",result.price)+"\r\n";
   desc+="Ask: "+StringFormat("%G",result.ask)+"\r\n";
   desc+="Bid: "+StringFormat("%G",result.bid)+"\r\n";
   desc+="Commento: "+result.comment+"\r\n";
//--- restituisce la stringa ottenuta
   return desc;
  }

Vedi anche

Tipi di Transazione di Trade, OnTradeTransaction()

Struttura di un Risultato di Richiesta di Trade

Struttura per i Prezzi Correnti