DocumentazioneSezioni
MQL5 RiferimentoCostanti, Enumerazioni e StruttureStrutture DatiStruttura Richiesta di Trade 

La struttura Trade Request (MqlTradeRequest)

L'interazione tra il terminale client ed il trade server per l'esecuzione dell'operazione di piazzamento dell'ordine viene eseguita utilizzando richieste di trade. La richiesta di trade è rappresentata dalla predefinita speciale struttura di tipo MqlTradeRequest, che contiene tutti i campi necessari per eseguire affari di trade. Il risultato della richiesta di elaborazione è rappresentato dalla struttura di tipo MqlTradeResult.

struct MqlTradeRequest
  {
   ENUM_TRADE_REQUEST_ACTIONS    action;           // Tipo d'operazione di trade
   ulong                         magic;            // Expert Advisor ID (magic number)
   ulong                         order;            // Ticket dell'ordine
   string                        symbol;           // Simbolo di trade
   double                        volume;           // Volume richiesto per un affare, in lotti
   double                        price;            // Prezzo
   double                        stoplimit;        // Livello StopLimit dell'ordine
   double                        sl;               // Livello Stop Loss dell'ordine
   double                        tp;               // Take Profit level dell'ordine
   ulong                         deviation;        // Deviazione massima possibile dal prezzo richiesto
   ENUM_ORDER_TYPE               type;             // Tipo di ordine
   ENUM_ORDER_TYPE_FILLING       type_filling;     // Tipo d'esecuzione dell'ordine
   ENUM_ORDER_TYPE_TIME          type_time;        // Tipo d'espirazione dell'ordine
   datetime                      expiration;       // Orario d'espirazione dell'ordine (per gli ordini di tipo ORDER_TIME_SPECIFIED)
   string                        comment;          // Commento dell'ordine
   ulong                         position;         // Ticket della posizione
   ulong                         position_by;      // Il ticket di una posizione opposta
  };

Descrizione campi

Campi

Descrizione

action

Tipo d'operazione di trade. Può essere uno dei valori dell'enumerazione ENUM_TRADE_REQUEST_ACTIONS.

magic

Expert Advisor ID. Esso permette di organizzare l'elaborazione analitica degli ordini di trade. Ogni Expert Advisor può impostare il proprio ID univoco per l'invio di una richiesta di trade.

order

Ticket dell' ordine. E' utilizzato per modificare ordini pendenti.

symbol

Simbolo dell'ordine. Non è necessario per la modifica dell'ordine ed operazioni di chiusura di posizione.

volume

Volume richiesto dell'ordine in lotti. Si noti che il volume reale di un affare dipenderà dal tipo d'esecuzione dell'ordine.

price

Prezzo, raggiunto il quale l'ordine deve essere eseguito. Ordini di mercato di simboli, il cui tipo di esecuzione è "Esecuzione a mercato" (SYMBOL_TRADE_EXECUTION_MARKET), Di TRADE_ACTION_DEAL Digitare, Non richiedono specifiche del prezzo.

stoplimit

Il valore del prezzo, al quale l'ordine pendente Limit sarà piazzato, quando il prezzo raggiunge il prezzo(valore) (questa condizione è obbligatoria). Fino ad allora l'ordine pendente non viene piazzato.

sl

Prezzo Stop Loss in caso di movimento di prezzo sfavorevole

tp

Prezzo Take Profit in caso di movimento di prezzo favorevole

deviation

La deviazione prezzo massima, specificata in punti

type

Tipo ordine. Può essere uno dei valori dell'enumerazione ENUM_ORDER_TYPE .

type_filling

Tipo d'esecuzione dell'ordine. Può essere uno dei valori dell'enumerazione ENUM_ORDER_TYPE_FILLING.

type_time

Tipo di scadenza dell'ordine. Può essere uno dei valori dell'enumerazione ENUM_ORDER_TYPE_TIME.

expiration

Oradio di espirazione dell'ordine (per ordini di tipo ORDER_TIME_SPECIFIED)

comment

Commento dell'ordine

position

Ticket di una posizione. Dovrebbe essere riempito quando una posizione viene modificata o chiusa per identificare la posizione. Di regola è uguale al ticket dell'ordine, sulla base del quale è stata aperta la posizione.

position_by

Ticket di una posizione opposta. Utilizzata quando una posizione viene chiusa da una contrapposta aperta per lo stesso simbolo nella direzione opposta.

Quando si modifica o si chiude una posizione nel sistema di copertura (hedging), assicurarsi di specificare il suo ticket (MqlTradeRequest::ticket). Il ticket può anche essere specificato nel sistema di compensazione(netting), anche se una posizione è identificata dal nome del simbolo.

Per l'invio di ordini per eseguire operazioni di trade è necessario utilizzare la funzione OrderSend(). Per ogni operazione di trade è necessario specificare i campi obbligatori; campi facoltativi possono anche essere riempiti. Ci sono sette casi possibili per inviare un ordine di trade:

Esecuzione a richiesta

Si tratta di un ordine di trade per aprire una posizione in modalità di Esecuzione della Richiesta (trade sui prezzi richiesti). Si richiede di specificare i seguenti 9 campi:

  • action
  • symbol
  • volume
  • price
  • sl
  • tp
  • deviation
  • type
  • type_filling

Inoltre è possibile specificare i valori dei campi "magic" e "field".

Esecuzione immediata

Si tratta di un ordine di trade per aprire una posizione in modalità esecuzione immediata (trade ai prezzi correnti). Richiede specificazione dei seguenti 9 campi:

  • action
  • symbol
  • volume
  • price
  • sl
  • tp
  • deviation
  • type
  • type_filling

Inoltre è possibile specificare i valori dei campi "magic" e "field".

Esecuzione a mercato

Si tratta di un ordine di trade per aprire una posizione in modalità di esecuzione a mercato. Si richiede di specificare i seguenti 5 campi:

  • action
  • symbol
  • volume
  • type
  • type_filling

Inoltre è possibile specificare i valori dei campi "magic" e "field".

Esecuzione a cambio

Si tratta di un ordine di trade per aprire una posizione in modalità di esecuzione Exchange. Si richiede di specificare i seguenti 5 campi:

  • action
  • symbol
  • volume
  • type
  • type_filling

Inoltre è possibile specificare i valori dei campi "magic" e "field".

Esempio per TRADE_ACTION_DEAL, operazione di trade per aprire una posizione Buy:

#define EXPERT_MAGIC 123456   // MagicNumber dell'expert
//+------------------------------------------------------------------+
//| Apre posizione Buy                                               |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- dichiara ed inizializza la richiesta di trade ed il risultato della richiesta di trade
   MqlTradeRequest request={};
   MqlTradeResult  result={};
//--- parametri della richiesta
   request.action   =TRADE_ACTION_DEAL;                     // tipo di operazione di trade
   request.symbol   =Symbol();                              // simbolo
   request.volume   =0.1;                                   // volume di 0.1 lotti
   request.type     =ORDER_TYPE_BUY;                        // tipo di ordine
   request.price    =SymbolInfoDouble(Symbol(),SYMBOL_ASK); // prezzo per l'apertura
   request.deviation=5;                                     // permessa la deviazione dal prezzo
   request.magic    =EXPERT_MAGIC;                          // MagicNumber dell'ordine
//--- invia la richiesta
   if(!OrderSend(request,result))
      PrintFormat("OrderSend error %d",GetLastError());     // se impossibilitato ad inviare la richiesta, da in output il codice d'errore
//--- informazione riguardo l'operazione
   PrintFormat("retcode=%u  deal=%I64u  order=%I64u",result.retcode,result.deal,result.order);
  }
//+------------------------------------------------------------------+

 
Esempio di TRADE_ACTION_DEAL, operazione di trade per aprire la posizione Sell:

#define EXPERT_MAGIC 123456   // MagicNumber dell'expert
//+------------------------------------------------------------------+
//| Apre posizione Sell                                              |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- dichiara ed inizializza la richiesta di trade ed il risultato della richiesta di trade
   MqlTradeRequest request={};
   MqlTradeResult  result={};
//--- parametri della richiesta
   request.action   =TRADE_ACTION_DEAL;                     // tipo di operazione di trade
   request.symbol   =Symbol();                              // simbolo
   request.volume   =0.2;                                   // volume di 0.2 lotti
   request.type     =ORDER_TYPE_SELL;                        // tipo di ordine
   request.price    =SymbolInfoDouble(Symbol(),SYMBOL_BID); // prezzo per l'apertura
   request.deviation=5;                                     // permessa la deviazione dal prezzo
   request.magic    =EXPERT_MAGIC;                          // MagicNumber dell'ordine
//--- invia la richiesta
   if(!OrderSend(request,result))
      PrintFormat("OrderSend error %d",GetLastError());     // se impossibilitato ad inviare la richiesta, da in output il codice d'errore
//--- informazione riguardo l'operazione
   PrintFormat("retcode=%u  deal=%I64u  order=%I64u",result.retcode,result.deal,result.order);
  }
//+------------------------------------------------------------------+

 
Esempio di TRADE_ACTION_DEAL, operazione di trade per chiudere la posizione:

#define EXPERT_MAGIC 123456   // MagicNumber dell'expert
//+------------------------------------------------------------------+
//| Chiude tutte le posizioni                                        |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- dichiara ed inizializza la richiesta di trade ed il risultato della richiesta di trade
   MqlTradeRequest request;
   MqlTradeResult  result;
   int total=PositionsTotal(); // numero della posizione aperta   
//--- itera su tutte le posizioni
   for(int i=total-1; i>=0; i--)
     {
      //--- parametri per l'ordine
      ulong  position_ticket=PositionGetTicket(i);                                      // ticket della posizione
      string position_symbol=PositionGetString(POSITION_SYMBOL);                        // simbolo 
      int    digits=(int)SymbolInfoInteger(position_symbol,SYMBOL_DIGITS);              // numero delle posizioni decimali
      ulong  magic=PositionGetInteger(POSITION_MAGIC);                                  // MagicNumber della posizione
      double volume=PositionGetDouble(POSITION_VOLUME);                                 // volume della posizione
      ENUM_POSITION_TYPE type=(ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);    // tipo della posizione
      //--- informazioni output riguardo la posizione
      PrintFormat("#%I64u %s  %s  %.2f  %s [%I64d]",
                  position_ticket,
                  position_symbol,
                  EnumToString(type),
                  volume,
                  DoubleToString(PositionGetDouble(POSITION_PRICE_OPEN),digits),
                  magic);
      //--- se il MagicNumber corrisponde
      if(magic==EXPERT_MAGIC)
        {
         //--- azzera la richiesta ed i valori risultato
         ZeroMemory(request);
         ZeroMemory(result);
         //--- imposta i parametri dell'operazione
         request.action   =TRADE_ACTION_DEAL;        // tipo di operazione di trade
         request.position =position_ticket;          // ticket della posizione
         request.symbol   =position_symbol;          // simbolo 
         request.volume   =volume;                   // volume della posizione
         request.deviation=5;                        // deviazione consentita dal prezzo
         request.magic    =EXPERT_MAGIC;             // MagicNumber della posizione
         //--- imposta il prezzo ed il tipo d'ordine a seconda del tipo della posizione
         if(type==POSITION_TYPE_BUY)
           {
            request.price=SymbolInfoDouble(position_symbol,SYMBOL_BID);
            request.type =ORDER_TYPE_SELL;
           }
         else
           {
            request.price=SymbolInfoDouble(position_symbol,SYMBOL_ASK);
            request.type =ORDER_TYPE_BUY;
           }
         //--- informazioni output riguardo la chiusura
         PrintFormat("Close #%I64d %s %s",position_ticket,position_symbol,EnumToString(type));
         //--- imposta la richiesta
         if(!OrderSend(request,result))
            PrintFormat("OrderSend errore %d",GetLastError());  // se impossibile inviare la richiesta, da in output il codice d'errore
         //--- informazioni riguardo l'operazione   
         PrintFormat("retcode=%u  deal=%I64u  order=%I64u",result.retcode,result.deal,result.order);
         //---
        }
     }
  }
//+------------------------------------------------------------------+

 
SL & TP Modifica

Trade order per modificare i prezzi di StopLoss e/o i prezzi TakeProfit. Si richiede di specificare i seguenti 4 settori:

  • action
  • symbol
  • sl
  • tp
  • position

 

Esempio per TRADE_ACTION_SLTP, operazione di trade per la modifica dei valori di Stop Loss e Take Profit di una posizione aperta:

#define EXPERT_MAGIC 123456  // MagicNumber dell'expert
//+------------------------------------------------------------------+
//| Modifica dello Stop Loss e Take Profit della posizione           |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- dichiara ed inizializza la richiesta di trade ed il risultato della richiesta di trade
   MqlTradeRequest request;
   MqlTradeResult  result;
   int total=PositionsTotal(); // numero delle posizioni aperte  
//--- itera su tutte le posizioni/t34>
   for(int i=0; i<total; i++)
     {
      //--- parametri dell'ordine
      ulong  position_ticket=PositionGetTicket(i);// ticket della posizione
      string position_symbol=PositionGetString(POSITION_SYMBOL); // simbolo 
      int    digits=(int)SymbolInfoInteger(position_symbol,SYMBOL_DIGITS); // numero di cifre decimali
      ulong  magic=PositionGetInteger(POSITION_MAGIC); // MagicNumber della posizione
      double volume=PositionGetDouble(POSITION_VOLUME);    // volume della posizione
      double sl=PositionGetDouble(POSITION_SL);  // Stop Loss della posizione
      double tp=PositionGetDouble(POSITION_TP);  // Take Profit della posizione
      ENUM_POSITION_TYPE type=(ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);  // tipo della posizione
      //--- output informazioni riguardo la posizione
      PrintFormat("#%I64u %s  %s  %.2f  %s  sl: %s  tp: %s  [%I64d]",
                  position_ticket,
                  position_symbol,
                  EnumToString(type),
                  volume,
                  DoubleToString(PositionGetDouble(POSITION_PRICE_OPEN),digits),
                  DoubleToString(sl,digits),
                  DoubleToString(tp,digits),
                  magic);
      //--- se il MagicNumber corrisponde, Stop Loss e Take Profit non sono stati definiti
      if(magic==EXPERT_MAGIC && sl==0 && tp==0)
        {
         //--- calcola i livelli del prezzo corrente
         double price=PositionGetDouble(POSITION_PRICE_OPEN);
         double bid=SymbolInfoDouble(position_symbol,SYMBOL_BID);
         double ask=SymbolInfoDouble(position_symbol,SYMBOL_ASK);
         int    stop_level=(int)SymbolInfoInteger(position_symbol,SYMBOL_TRADE_STOPS_LEVEL);
         double price_level;
         //--- se l'offset distanza minima consentita in punti dal corrente punto di chiusura non è impostata
         if(stop_level<=0)
            stop_level=150; // imposta l'offset distanza di 150 punti dal corrente punto di chiusura
         else
            stop_level+=50; // imposta l'offset distanza a (SYMBOL_TRADE_STOPS_LEVEL + 50) punti per l'affidabilità
 
         //--- calcolo ed arrotondamento dei valori Stop Loss e Take Profit 
         price_level=stop_level*SymbolInfoDouble(position_symbol,SYMBOL_POINT);
         if(type==POSITION_TYPE_BUY)
           {
            sl=NormalizeDouble(bid-price_level,digits);
            tp=NormalizeDouble(bid+price_level,digits);
           }
         else
           {
            sl=NormalizeDouble(ask+price_level,digits);
            tp=NormalizeDouble(ask-price_level,digits);
           }
         //--- azzero la richiesta ed i risultanti valori
         ZeroMemory(request);
         ZeroMemory(result);
         //--- setting the operation parameters
         request.action  =TRADE_ACTION_SLTP; // type of trade operation
         request.position=position_ticket;   // ticket of the position
         request.symbol=position_symbol;     // simbolo 
         request.sl      =sl;                // Stop Loss della posizione
         request.tp      =tp;                // Take Profit della posizione
         request.magic=EXPERT_MAGIC;         // MagicNumber della posizione
         //--- output informazioni riguardo la modifica
         PrintFormat("Modifica #%I64d %s %s",position_ticket,position_symbol,EnumToString(type));
         //--- invia la richiesta
         if(!OrderSend(request,result))
            PrintFormat("OrderSend error %d",GetLastError());  // se impossibile inviare la richiesta, da in output il codice errore
         //--- informazioni riguardo l'operazione   
         PrintFormat("retcode=%u  deal=%I64u  order=%I64u",result.retcode,result.deal,result.order);
        }
     }
  }
//+------------------------------------------------------------------+

 
Ordine Pendente

Ordine di trade per piazzare un ordine pendente. Si richiede di specificare i seguenti 11 campi:

  • action
  • symbol
  • volume
  • price
  • stoplimit
  • sl
  • tp
  • type
  • type_filling
  • type_time
  • expiration

Inoltre è possibile specificare i valori dei campi "magic" e "field".

Esempio di TRADE_ACTION_PENDING, operazione di trade per piazzare un ordine pendente:

#property description "Esempio di piazzamento dell'ordine pendente"
#property script_show_inputs
#define EXPERT_MAGIC 123456                             // MagicNumber dell'expert
input ENUM_ORDER_TYPE orderType=ORDER_TYPE_BUY_LIMIT;   // tipo d'ordine
//+------------------------------------------------------------------+
//| Piazza l'ordine pendente                                         |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- dichiara ed inizializza la richiesta di trade ed il risultato della richiesta di trade
   MqlTradeRequest request={};
   MqlTradeResult  result={};
//--- parametri per piazzare un ordine pendente
   request.action   =TRADE_ACTION_PENDING;                             // tipo di operazione di trade
   request.symbol   =Symbol();                                         // simbolo
   request.volume   =0.1;                                              // volume di 0.1 lotti
   request.deviation=2;                                                // ammonetare di deviazione dal prezzo consentita
   request.magic    =EXPERT_MAGIC;                                     // MagicNumber dell'ordine
   int offset = 50;                                                    // offset from the current price to place the order, in points
   double price;                                                       // prezzo d'innesco dell'ordine
   double point=SymbolInfoDouble(_Symbol,SYMBOL_POINT);                // valore del punto
   int digits=SymbolInfoInteger(_Symbol,SYMBOL_DIGITS);                // numero di cifre decimali (precisione)
   //--- controllo del tipo d'operazione
   if(orderType==ORDER_TYPE_BUY_LIMIT)
     {
      request.type     =ORDER_TYPE_BUY_LIMIT;                          // tipo d'ordine
      price=SymbolInfoDouble(Symbol(),SYMBOL_ASK)-offset*point;        // prezzo per l'apertura 
      request.price    =NormalizeDouble(price,digits);                 // prezzo d'apertura normalizzato 
     }
   else if(orderType==ORDER_TYPE_SELL_LIMIT)
     {
      request.type     =ORDER_TYPE_SELL_LIMIT;                          // tipo d'ordine
      price=SymbolInfoDouble(Symbol(),SYMBOL_BID)+offset*point;         // prezzo per l'apertura 
      request.price    =NormalizeDouble(price,digits);                  // prezzo d'apertura normalizzato 
     }
   else if(orderType==ORDER_TYPE_BUY_STOP)
     {
      request.type =ORDER_TYPE_BUY_STOP;                                // tipo d'ordine
      price        =SymbolInfoDouble(Symbol(),SYMBOL_ASK)+offset*point; // prezzo per l'apertura 
      request.price=NormalizeDouble(price,digits);                      // prezzo d'apertura normalizzato 
     }
   else if(orderType==ORDER_TYPE_SELL_STOP)
     {
      request.type     =ORDER_TYPE_SELL_STOP;                           // tipo d'ordine
      price=SymbolInfoDouble(Symbol(),SYMBOL_BID)-offset*point;         // prezzo per l'apertura 
      request.price    =NormalizeDouble(price,digits);                  // prezzo d'apertura normalizzato 
     }
   else Alert("Questo esempio è solo per piazzare ordini pendenti");   // se non ci sono ordini pendenti viene selezionato
//--- invia la richiesta
   if(!OrderSend(request,result))
      PrintFormat("OrderSend errore %d",GetLastError());                 // se impossibile inviare la richiesta, da in output il codice errore
//--- informazioni riguardo l'operazione
   PrintFormat("retcode=%u  deal=%I64u  order=%I64u",result.retcode,result.deal,result.order);
  }
//+------------------------------------------------------------------+

 
Modificare Ordine Pendente

Ordine di trade per modificare i prezzi di un ordine pendente. Si richiede di specificare i seguenti 7 campi:

  • action
  • order
  • price
  • sl
  • tp
  • type_time
  • expiration

 

Esempio di TRADE_ACTION_MODIFY, operazione di trade per la modifica dei livelli di prezzo di ordini pendenti:

#define EXPERT_MAGIC 123456  // MagicNumber dell'expert
//+------------------------------------------------------------------+
//| Modifica degli ordini pendenti                                   |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- dichiara ed inizializza la richiesta di trade ed il risultato della richiesta di trade
   MqlTradeRequest request={};
   MqlTradeResult  result={};
   int total=OrdersTotal(); // numero totale di orini pendenti piazzati 
//--- itera su tutti gli ordini pendenti piazzati
   for(int i=0; i<total; i++)
     {
      //--- parametri dell'ordine
      ulong  order_ticket=OrderGetTicket(i);                             // order ticket
      string order_symbol=Symbol();                                      // simbolo
      int    digits=(int)SymbolInfoInteger(order_symbol,SYMBOL_DIGITS);  // numero di posti decimali
      ulong  magic=OrderGetInteger(ORDER_MAGIC);                         // MagicNumber dell'ordine
      double volume=OrderGetDouble(ORDER_VOLUME_CURRENT);                // corrente volume dell'ordine
      double sl=OrderGetDouble(ORDER_SL);                                // corrente Stop Loss dell'ordine
      double tp=OrderGetDouble(ORDER_TP);                                // corrente Take Profit dell'ordine
      ENUM_ORDER_TYPE type=(ENUM_ORDER_TYPE)OrderGetInteger(ORDER_TYPE); // tipo di ordine
      int offset = 50;                                                   // offset dal prezzo corrente per piazzare l'ordine, in punti
      double price;                                                      // prezzo d'innesco ordine
      double point=SymbolInfoDouble(order_symbol,SYMBOL_POINT);          // valore in punti
      //--- output informazioni riguardo l'ordine
      PrintFormat("#%I64u %s  %s  %.2f  %s  sl: %s  tp: %s  [%I64d]",
                  order_ticket,
                  order_symbol,
                  EnumToString(type),
                  volume,
                  DoubleToString(PositionGetDouble(POSITION_PRICE_OPEN),digits),
                  DoubleToString(sl,digits),
                  DoubleToString(tp,digits),
                  magic);
      //--- se il MagicNumber corrisponde, Stop Loss e Take Profit non sono definiti
      if(magic==EXPERT_MAGIC && sl==0 && tp==0)
        {
         request.action=TRADE_ACTION_MODIFY;                           // tipo d'operazione di trade
         request.order = OrderGetTicket(i);                            // ticket ordine
         request.symbol   =Symbol();                                   // simbolo
         request.deviation=5;                                          // deviazione consentita dal prezzo
        //--- imposta il livello del prezzo, Take Profit e Stop Loss dell'ordine dipendono dal suo tipo
         if(type==ORDER_TYPE_BUY_LIMIT)
           {
            price = SymbolInfoDouble(Symbol(),SYMBOL_ASK)-offset*point; 
            request.tp = NormalizeDouble(price+offset*point,digits);
            request.sl = NormalizeDouble(price-offset*point,digits);
            request.price    =NormalizeDouble(price,digits);                // prezzo d'apertura normalizzato
           }
         else if(type==ORDER_TYPE_SELL_LIMIT)
           {
           price = SymbolInfoDouble(Symbol(),SYMBOL_BID)+offset*point; 
            request.tp = NormalizeDouble(price-offset*point,digits);
            request.sl = NormalizeDouble(price+offset*point,digits);
            request.price    =NormalizeDouble(price,digits);                 // prezzo d'apertura normalizzato
           }
         else if(type==ORDER_TYPE_BUY_STOP)
           {
           price = SymbolInfoDouble(Symbol(),SYMBOL_ASK)+offset*point; 
            request.tp = NormalizeDouble(price+offset*point,digits);
            request.sl = NormalizeDouble(price-offset*point,digits);
            request.price    =NormalizeDouble(price,digits);                 // prezzo d'apertura normalizzato
           }
         else if(type==ORDER_TYPE_SELL_STOP)
           {
           price = SymbolInfoDouble(Symbol(),SYMBOL_BID)-offset*point; 
            request.tp = NormalizeDouble(price-offset*point,digits);
            request.sl = NormalizeDouble(price+offset*point,digits);
            request.price    =NormalizeDouble(price,digits);                 // prezzo d'apertura normalizzato
           }
         //--- invia la richiesta
         if(!OrderSend(request,result))
            PrintFormat("OrderSend errore %d",GetLastError());  // se impossibile inviare la richiesta, da in output il codice errore
         //--- informazioni riguardo l'operazione   
         PrintFormat("retcode=%u  deal=%I64u  order=%I64u",result.retcode,result.deal,result.order);
         //--- azzera la richiesta ed i risultanti valori
         ZeroMemory(request);
         ZeroMemory(result);
        }
     }
  }
//+------------------------------------------------------------------+

 
Eliminare Ordine Pendente

Ordine di trade per eliminare un ordine pendente. Richiede di specificare i 2 campi seguenti:

  • action
  • order

 

Esempio per TRADE_ACTION_REMOVE, operazione di trade per eliminare ordini pendenti:

#define EXPERT_MAGIC 123456  // MagicNumber dell'expert
//+------------------------------------------------------------------+
//| Elimina ordini pendenti                                          |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- dichiara ed inizializza la richiesta di trade ed il risultato della richiesta di trade
   MqlTradeRequest request={};
   MqlTradeResult  result={};
   int total=OrdersTotal(); // numero totale di ordini pendenti piazzati
//--- itera su tutti gli ordini pendenti piazzati
   for(int i=total-1; i>=0; i--)
     {
      ulong  order_ticket=OrderGetTicket(i);                   // ticket ordine
      ulong  magic=OrderGetInteger(ORDER_MAGIC);               // MagicNumber dell'ordine
      //--- se il MagicNumber corrisponde
      if(magic==EXPERT_MAGIC)
        {
         //--- azzera la richiesta ed i valori del risultato
         ZeroMemory(request);
         ZeroMemory(result);
         //--- imposta i parametri dell'operazione     
         request.action=TRADE_ACTION_REMOVE;                   // tipo d'operazione di trade
         request.order = order_ticket;                         // ticket ordine
         //--- invia la richiesta
         if(!OrderSend(request,result))
            PrintFormat("OrderSend errore %d",GetLastError());  // se impossibile inviare la richiesta, da in output l' error code
         //--- informazioni riguardo l'operazione   
         PrintFormat("retcode=%u  deal=%I64u  order=%I64u",result.retcode,result.deal,result.order);
        }
     }
  }
//+------------------------------------------------------------------+

 
Guarda anche

Strutture e Classi, Funzioni di Trade, Proprietà Ordini