Domanda sulla funzione OnTradeTransaction

Alexey Viktorov  

Secondo l'aiuto.

позволяет связать выполненное действие identificatore della richiesta (chiamata delle funzioni OrderSend o OrderSendAsync) con il risultato di questa azione passata a OnTradeTransaction


Cioè, permette di controllare se l'ordine è stato eseguito correttamente nella funzione OnTradeTransaction. O sto fraintendendo qualcosa?

Ma qui c'è un avvertimento:

L'ordine di arrivo di queste transazioni al terminale non è garantito, quindi non possiamo costruire il nostro algoritmo di trading aspettando che alcune transazioni commerciali arrivino dopo altre. Inoltre, le transazioni possono essere perse nella consegna dal server al terminale.

Beh, la coerenza non garantita è metà del problema. Ma che dire del fatto che una transazione può andare persa e quindi non possiamo usare la funzione OnTradeTransaction per i controlli.

Quindi la domanda sorge spontanea: a cosa ci serve allora questa funzione gestore di eventi? È un add-on assolutamente inutile per il terminale? O sto di nuovo fraintendendo qualcosa?

Alexey Viktorov  

Grazie anche per questo. Ma anche se ci sono possibili perdite di transazioni quando si creano esperti di trading asincrono, non da me, di che tipo di verifica possiamo parlare?

E in generale sono soddisfatto della risposta. Non ho abbastanza conoscenze per discutere questo argomento in dettaglio.

Grazie ancora.

Mikhail Filimonov  
AlexeyVik :

Grazie anche per quello. Ma anche se quando creo, non da me, esperti di trading asincrono, sono possibili perdite di transazione, di che tipo di verifica possiamo parlare?

In generale, la risposta mi soddisfa. E non ho abbastanza conoscenze per discutere questo argomento in modo più dettagliato.

E grazie ancora.

Ho scritto un articolo su questo problema.

Dice solo come non "perdere" l'ordine effettuato dal comando OrderSendAsync

Ora è in fase di verifica, ma se non esce, ecco un esempio da questo articolo (FORTS mercato a termine):

 //+------------------------------------------------------------------+
//|                                                       Demo_1.mq5 |
//|                                          Copyright 2015, Mikalas |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2015, Mikalas"
#property link        "https://www.mql5.com"
#property version    "1.00"

input uint TimerPeriod = 1000 ;     //Время ожидания проверки ордера (1 сек.)   

ulong       order_ticket;
uint        request_id;
//
ulong       magic_number = 1010000 ;   //по 10000 на каждый символ
ulong       magic_storage;
ulong       mem_magic;
datetime    mem_time;
uint        mem_tick;
ulong       deal_volume;             //Счётчик заливки ордера
//
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit ()
{
  deal_volume = 0 ;             
   //--- Установка таймера
   if ( ! EventSetMillisecondTimer ( 500 ) )     //0.5 cек.
  {
     MessageBox ( "Таймер не установлен!" , "Ошибка" , MB_OK | MB_ICONHAND );
     return ( INIT_FAILED );
  } 
   return ( INIT_SUCCEEDED );
}
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit ( const int reason )
{
//--- удаление таймера
   EventKillTimer ();
}
//+------------------------------------------------------------------+
//| Expert Get retcode function                                      |
//+------------------------------------------------------------------+
string GetRetCode( const uint code )
{
   string retcode;
//---  
   switch ( code )
  {
     case 10004 : retcode = "Реквота" ;
         break ;
     case 10006 : retcode = "Запрос отвергнут" ;
         break ;
     case 10007 : retcode = "Запрос отменен трейдером" ;
         break ;
     case 10008 : retcode = "Ордер размещен" ;
         break ;
     case 10009 : retcode = "Заявка выполнена" ;
         break ;
     case 10010 : retcode = "Заявка выполнена частично" ;
         break ;
     case 10011 : retcode = "Ошибка обработки запроса" ;
         break ;
     case 10012 : retcode = "Запрос отменен по истечению времени" ;
         break ;
     case 10013 : retcode = "Неправильный запрос" ;
         break ;
     case 10014 : retcode = "Неправильный объем в запросе" ;
         break ;
     case 10015 : retcode = "Неправильная цена в запросе" ;
         break ;
     case 10016 : retcode = "Неправильные стопы в запросе" ;
         break ;
     case 10017 : retcode = "Торговля запрещена" ;
         break ;
     case 10018 : retcode = "Рынок закрыт" ;
         break ;
     case 10019 : retcode = "Нет достаточных денежных средств для выполнения запроса" ;
         break ;
     case 10020 : retcode = "Цены изменились" ;
         break ;
     case 10021 : retcode = "Отсутствуют котировки для обработки запроса" ;
         break ;
     case 10022 : retcode = "Неверная дата истечения ордера в запросе" ;
         break ;
     case 10023 : retcode = "Состояние ордера изменилось" ;
         break ;
     case 10024 : retcode = "Слишком частые запросы" ;
         break ;
     case 10025 : retcode = "В запросе нет изменений" ;
         break ;
     case 10026 : retcode = "Автотрейдинг запрещен сервером" ;
         break ;
     case 10027 : retcode = "Автотрейдинг запрещен клиентским терминалом" ;
         break ;
     case 10028 : retcode = "Запрос заблокирован для обработки" ;
         break ;
     case 10029 : retcode = "Ордер или позиция заморожены" ;
         break ;
     case 10030 : retcode = "Указан неподдерживаемый тип исполнения ордера по остатку" ;
         break ;
     case 10031 : retcode = "Нет соединения с торговым сервером" ;
         break ;
     case 10032 : retcode = "Операция разрешена только для реальных счетов" ;
         break ;
     case 10033 : retcode = "Достигнут лимит на количество отложенных ордеров" ;
         break ;
     case 10034 : retcode = "Достигнут лимит на объем ордеров и позиций для данного символа" ;
         break ;
     case 10035 : retcode = "Неверный или запрещённый тип ордера" ;
         break ;
     case 10036 : retcode = "Позиция с указанным POSITION_IDENTIFIER уже закрыта" ;
         break ;
     default : retcode = "Нет кода возврата." ;  
         break ; 
  }
   return ( retcode );
}
//+------------------------------------------------------------------+
//| Expert place order function                                      |
//+------------------------------------------------------------------+
bool PlaceOrder( const string a_symbol, const double price, const double volume, const bool buy_sell )
{
   MqlTradeRequest request = { 0 };
   MqlTradeResult   result  = { 0 };
//---  
  order_ticket = 0 ;
  request_id = 0 ;
  mem_time = TimeTradeServer ();   //Время установки ордера (для для сокращения поиска в истории)
  mem_tick = GetTickCount ();       //Начало отсчёта времени (для проверки, если не сработала функция OnTradeTransaction)   
  mem_magic = magic_storage + 1 ;   //Уникальный номер (magic) ордера
  
   if ( mem_magic >= ( magic_number + 9999 ) ) mem_magic = magic_number;   //Переполнение, начинаем сначала
     
//--- Fill structure
  request.action = TRADE_ACTION_PENDING ;
  request.magic  = mem_magic;
  request.symbol = a_symbol;
  request.volume = volume;
  request.price  = price;
    
   if ( buy_sell )
  {
    request.type       = ORDER_TYPE_BUY_LIMIT ;
  }
   else
  {
    request.type       = ORDER_TYPE_SELL_LIMIT ;
  } 
  request.comment      = "Отложенный ордер..." ;      
  request.type_filling = ORDER_FILLING_RETURN ;
  request.type_time    = ORDER_TIME_DAY ;
   
//--- Send order
   if ( OrderSendAsync ( request, result ) )
  {
     if ( result.retcode == TRADE_RETCODE_PLACED ) 
    {
      request_id = result.request_id;
      magic_storage = mem_magic;
       return ( true );
    }
     else
    {
      mem_magic = 0 ;
      mem_time = 0 ;
      mem_tick = 0 ;
       Print ( "Ордер не отправлен! " , a_symbol, " Код возврата = " , GetRetCode( result.retcode ) );
       return ( false );
    }
  }
   else
  {
    mem_magic = 0 ;
    mem_time = 0 ;
    mem_tick = 0 ;
     Print ( "Ордер не отправлен! " , a_symbol, " Код возврата = " , GetRetCode( result.retcode ) );
     return ( false );
  }
}
//+------------------------------------------------------------------+
//| Expert place order function                                      |
//+------------------------------------------------------------------+
void OnTick ()
{
   MqlTick a_tick;
  
   if ( SymbolInfoTick ( _Symbol , a_tick ) )
  {
    PlaceOrder( _Symbol , a_tick.ask, 1 , false );   //Устанавливаем ордер
  }     
}

//+------------------------------------------------------------------+
//| TradeTransaction function                                        |
//+------------------------------------------------------------------+
void OnTradeTransaction ( const MqlTradeTransaction & trans,
                         const MqlTradeRequest & request,
                         const MqlTradeResult & result)
{
   switch ( trans.type )
  {
     case TRADE_TRANSACTION_REQUEST :     if ( trans.order_state == ORDER_STATE_STARTED )
                                        {
                                           if ( ( request_id != 0 ) && ( result.request_id == request_id ) )
                                          {
                                             if ( result.retcode == TRADE_RETCODE_PLACED )
                                            {
                                              order_ticket = result.order;         //Получаем билет ордера
                                              mem_tick     = GetTickCount ();       //Начало отсчёта времени (для проверки, если не сработает функция OnTradeTransaction) 
                                            }
                                             else
                                            {
                                              mem_tick = 0 ;
                                               Print ( "OnTradeTransaction: Не получен билет ордера. Запрос = " , request_id );
                                            }
                                            request_id = 0 ;
                                            mem_magic  = 0 ;
                                            mem_time   = 0 ;
                                          }  
                                        }
                                         break ;
                                    
     case TRADE_TRANSACTION_DEAL_ADD :     if ( trans.order_state == ORDER_STATE_STARTED )
                                        {
                                           if ( ( order_ticket != 0 ) && ( trans.order == order_ticket ) )
                                          { 
                                             if ( ! OrderSelect ( order_ticket ) ) order_ticket = 0 ;     //Обнуляем билет, так как ордер залился полностью.
                                             Print ( "OnTradeTransaction: Сделка совершена, билет = " , trans.order ); 
                                          } 
                                        }
                                         break ;
                                     
     case TRADE_TRANSACTION_HISTORY_ADD : if ( (order_ticket != 0 ) && ( trans.order == order_ticket ) )
                                        {
                                          order_ticket = 0 ;
                                          
                                           switch ( trans.order_state )
                                          {
                                             case ORDER_STATE_REJECTED : Print ( "OnTradeTransaction: Ордер отклонён." );
                                                                       break ;
                                                                       
                                             case ORDER_STATE_CANCELED : Print ( "OnTradeTransaction: Ордер удалён." ); 
                                                                       break ;
                                                                     
                                             case ORDER_STATE_EXPIRED :   Print ( "OnTradeTransaction: Срок действия ордера окончен." );
                                                                       break ;
                                          }   
                                        }
                                         break ;     
                                        
     case TRADE_TRANSACTION_ORDER_UPDATE : if ( trans.order_state == ORDER_STATE_REQUEST_MODIFY )
                                         {
                                           if ( ( order_ticket != 0 ) && ( trans.order == order_ticket ) )
                                           {
                                             Print ( "OnTradeTransaction: Ордер в состоянии модифицикации." );
                                              mem_tick = GetTickCount ();  
                                           }
                                         }
                                         break ;                                                                                          
  }     
}
//+------------------------------------------------------------------+
// Expert find histiry order function                                |
//+------------------------------------------------------------------+
ulong FindHistoryOrder( const ulong a_magic, const datetime a_time, const datetime b_time )
{
   if ( HistorySelect ( a_time, b_time ) )
  {
     for ( int i = HistoryOrdersTotal () - 1 ; i >= 0 ; i-- )
    {
       ulong cur_ticket = HistoryOrderGetTicket ( i );
      
       if ( ulong ( HistoryOrderGetInteger ( cur_ticket, ORDER_MAGIC ) ) == a_magic ) return ( cur_ticket );
    }
  }  
   return ( 0 ) ;
}
//+------------------------------------------------------------------+
// Expert find order function                                        |
//+------------------------------------------------------------------+
ulong FindOrder( const ulong a_magic )
{
   for ( int i = OrdersTotal () - 1 ; i >= 0 ; i-- )
  {
     ulong cur_ticket = OrderGetTicket ( i );
    
     if ( ulong ( OrderGetInteger ( ORDER_MAGIC ) ) == a_magic ) return ( cur_ticket );
  }
   return ( 0 );
}
//+------------------------------------------------------------------+
//| Expert Get order tiket function                                  |
//+------------------------------------------------------------------+
ulong GetOrderTicket( const ulong m_magic, const datetime m_time, const datetime cur_time )
{
   ulong a_ticket = FindOrder( m_magic );                         //Ищем действующий ордер
  
   if ( a_ticket > 0 )
  {
     return ( a_ticket );
  }
   else
  {
    a_ticket = FindHistoryOrder( m_magic, m_time, cur_time );   //Ищем ордер в истории
    
     if ( a_ticket > 0 )
    {
       return ( a_ticket );
    }
  }  
   return ( 0 ); 
}
//+------------------------------------------------------------------+
//| Expert Check time function                                      |
//+------------------------------------------------------------------+
bool CheckTime( const uint start_value, const uint per_value )
{
   uint end_value = GetTickCount ();
  
   if ( end_value < start_value )
  {
     if ( ( start_value - end_value ) >= per_value ) return ( true );
  } 
   else
  {
     if ( ( end_value - start_value ) >= per_value ) return ( true );
  }
   return ( false );
}
//+------------------------------------------------------------------+
// Expert Get History Deals function                                 |
//+------------------------------------------------------------------+
uint GetHistoryDeals( const ulong ticket )
{
   int deals_total = HistoryDealsTotal ();
   uint ticket_deals = 0 ;
          
   for ( int i = 0 ; i < deals_total; i++ )
  {
     ulong deal_ticket = HistoryDealGetTicket ( i );
     ulong ord_ticket = ulong ( HistoryDealGetInteger ( deal_ticket, DEAL_ORDER ) );
        
     if ( ( ord_ticket > 0 ) && ( ord_ticket == ticket ) ) ticket_deals++;
  }
           
   if ( ticket_deals > 0 ) return ( ticket_deals );
  
   return ( 0 );
}
//+------------------------------------------------------------------+
//| Expert Check order function                                      |
//+------------------------------------------------------------------+
void CheckOrder()
{
   if ( ( mem_tick > 0 ) && CheckTime( mem_tick, TimerPeriod ) )           //Проверка времени ожидания действия над ордером (установка, модификация или удадение) 
  {
     if ( mem_magic > 0 )                                                   //Нет билета, получаем билет
    {
      order_ticket = GetOrderTicket( mem_magic, mem_time, TimeTradeServer () );
      
       if ( order_ticket > 0 )
      {
        mem_tick  = GetTickCount ();                                       //Начало отсчёта времени, если в будующем вновь не сработает функция OnTradeTransaction 
      }
       else
      {
        mem_tick  = 0 ;
         Print ( "Timeout: Билет ордера не найден!" );  
      }
      mem_magic = 0 ;
      mem_time  = 0 ;
    }
     else                                                                  
    {
       if ( order_ticket > 0 )                                             //Есть билет, смотрим что произошло с ордером
      {
         if ( OrderSelect ( order_ticket ) )                                 //Ордер рабочий 
        {
           double init_volume = OrderGetDouble ( ORDER_VOLUME_INITIAL );
           double cur_volume = OrderGetDouble ( ORDER_VOLUME_CURRENT );
          
           if ( init_volume != cur_volume )
          {
             ulong d_volume = ( ulong ( init_volume - cur_volume ) - deal_volume );
            deal_volume = deal_volume + d_volume;
            
             if ( d_volume > 0 )
            { 
               Print ( "Timeout: Сделка совершена, билет = " , order_ticket, " Объём = " , d_volume );
            }  
          }
          mem_tick = GetTickCount ();
        }
         else                                                                //Ордер исполнился, удален или экпирировался   
        {
           if ( HistoryOrderSelect ( order_ticket ) )
          {
             datetime ord_time = datetime ( HistoryOrderGetInteger ( order_ticket, ORDER_TIME_SETUP ) );
            
             if ( HistorySelect ( ord_time, TimeTradeServer () ) )
            {
               uint deals = GetHistoryDeals( order_ticket );
              
               if ( deals > 0 )
              {
                 Print ( "Timeout: Сделка совершена, билет = " , order_ticket );
              }
            }
          }
           else
          {
             Print ( "Timeout: Ордер " , order_ticket, " не найден в истории!" );
          } 
          deal_volume  = 0 ;
          order_ticket = 0 ;
          mem_tick     = 0 ;
        }
      }
       else
      {
        deal_volume = 0 ;
        mem_tick    = 0 ;
         Print ( "Timeout: Нет билета ордера!" );
      }
    }
  }
}
//+------------------------------------------------------------------+
//| Expert timer function                                            |
//+------------------------------------------------------------------+
void OnTimer ()
{
  CheckOrder();
}
//+------------------------------------------------------------------+
Vasiliy Sokolov  
Mikalas:

Ho scritto un articolo su questo problema.

Dice esattamente come non "perdere" un ordine piazzato dal comando OrderSendAssync

È in fase di test ora, ma se fallisce, ecco un esempio da questo articolo (mercato dei futures FORTS):

Come se tutti lo capissero e battessero le mani per la gioia. Scusa, ma è molto più complicato di così nel tuo codice.
Mikhail Filimonov  
C-4:
Come se tutti lo capissero e battessero le mani per la gioia. Scusa, ma il tuo codice è un casino.

Qualcuno ha promesso che sarebbe stato facile?

Scusa, Vasili, aspetta che esca l'articolo....

P/S Se l'articolo non esce, scriverò qui le spiegazioni per esempio.

Alexey Viktorov  
Mikalas:

Ho scritto un articolo su questo problema.

Dice esattamente come non "perdere" un ordine piazzato dal comando OrderSendAssync

È in fase di test ora, ma se non esce, ecco un esempio per voi da quell'articolo (mercato dei futures FORTS):

Se non le dispiace che glielo chieda. Perché ti concentri sull'immissione di un ordine usando la funzione OrderSendAssync()? Se piazziamo un ordine usando la funzione OrderSend(), la transazione non andrà persa? In questo caso, ci sono più garanzie?


Nella mia inesperienza, volevo inserire la decisione in questo o quel caso in OnTradeTransactio(). Ma finora non ha funzionato così bene. E avendo letto di una possibile perdita di transazioni, vi ho chiesto chiarimenti.

In generale, per scrivere per il mercato FORTS bisogna capire questo mercato. Per ora non fa per me, forse non ne ho bisogno. Ho deciso di riscrivere il mio EA scritto in mql4 per studiare mql5. Lo sto studiando ora.

Mikhail Filimonov  
AlexeyVik:

Se non le dispiace, una domanda. Perché si concentra sull'immissione di un ordine con OrderSendAssync()? Se si inserisce un ordine usando la funzione OrderSend(), la transazione non andrà persa? In questo caso, ci sono più garanzie?


Nella mia inesperienza, volevo inserire la decisione in questo o quel caso in OnTradeTransactio(). Ma finora non ha funzionato così bene. E avendo letto di una possibile perdita di transazioni, vi ho chiesto chiarimenti.

In generale, per scrivere per il mercato FOREX, bisogna capire questo mercato. Questo non fa ancora per me, e forse non ne ho bisogno. Ho deciso di riscrivere il mio EA scritto in mql4 per studiare mql5. Lo sto studiando ora.

1. OrderSendAsync è molto più veloce (non aspetta una risposta dal server).

OrderSend è garantito per ottenere una risposta dal server.

2. L'esempio funziona perfettamente sul FOREX

cambiandoresult.retcode == TRADE_RETCODE_PLACED inresult.retcode == TRADE_RETCODE_DONE

Alexey Viktorov  
Mikalas:

1. OrderSendAsync è molto più veloce (non aspetta una risposta dal server)

2. L'esempio funziona perfettamente anche sul FOREX

cambiandoresult.retcode == TRADE_RETCODE_PLACED inresult.retcode == TRADE_RETCODE_DONE

Cioè se l'asincronia non è applicata, allora non c'è bisogno del gestore OnTradeTransaction poiché i gufi aspetteranno una risposta dal server?

Ma finora non ho trovato il modo migliore per determinare se un ordine Stop è stato attivato. Per esempio, ho impostato il mercato Buy 0.1 e SellStop 0.3 e quando si attiva 0.3, rimane 0.2 e a che punto dovrei seguirlo... Così si scopre che dobbiamo seguire due ordini ad ogni tick. E ho voluto alleggerire i gufi e monitorare solo quando la transazione avviene. Non volevo nemmeno controllare, ma controllare cosa era successo e decidere cosa fare. Ma credo che questo non sia il caso... Forse è meglio tornare ai vecchi metodi collaudati...

Mikhail Filimonov  
AlexeyVik:

Quindi, se non usiamo l'asincronia, non c'è bisogno del gestore OnTradeTransaction perché i gufi aspetteranno una risposta dal server?

Ma finora non ho trovato il modo migliore per rilevare se un ordine stop è stato attivato. Per esempio, ho impostato il mercato Buy 0.1 e SellStop 0.3 e quando si attiva 0.3, rimane 0.2 e a che punto dovrei seguirlo... Così si scopre che dobbiamo seguire due ordini ad ogni tick. E volevo alleggerire i gufi e controllare solo quando la transazione avviene. Non volevo nemmeno controllare, ma controllare cosa era successo e decidere cosa fare. Ma credo che questo non sia il caso... Forse è meglio tornare ai vecchi metodi collaudati...

Sì, puoi evitare di usare OnTradeTransaction, ma in questo caso, dovrai guardare attraverso la storia, il che ridurrà la performance complessiva dell'EA.

Ogni sviluppatore ha una scelta!

Motivazione: