DocumentazioneSezioni
MQL5 RiferimentoCostanti, Enumerazioni e StruttureCostanti di TradeTipi di Operazioni di Trade 

Tipi di Operazioni di Trade

Il trading avviene con l'invio di ordini per aprire posizioni utilizzando la funzione OrderSend(), come pure per piazzare, modificare o cancellare gli ordini pendenti. Ogni ordine di trade si riferisce al tipo di operazione richiesta. Le operazioni di trading sono descritte nella enumerazione ENUM_TRADE_REQUEST_ACTIONS.

ENUM_TRADE_REQUEST_ACTIONS

Identificazione

Descrizione

TRADE_ACTION_DEAL

Piazza un ordine di trade per un' esecuzione immediata con i parametri specificati (ordine di mercato)

TRADE_ACTION_PENDING

Piazza un ordine di trade per l' esecuzione in condizioni specifiche (ordine pendente)

TRADE_ACTION_SLTP

Modifica i valori Stop Loss e Take Profit di una posizione aperta

TRADE_ACTION_MODIFY

Modifica i parametri dell' ordine effettuato in precedenza

TRADE_ACTION_REMOVE

Elimina l'ordine pendnete piazzato in precedenza

TRADE_ACTION_CLOSE_BY

Chiude una posizione da una opposta

 
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);
         //---
        }
     }
  }
//+------------------------------------------------------------------+

 
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_ASK)+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_ASK)-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);
  }
//+------------------------------------------------------------------+

 
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(ask+price_level,digits);
           }
         else
           {
            sl=NormalizeDouble(ask+price_level,digits);
            tp=NormalizeDouble(bid-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);
        }
     }
  }
//+------------------------------------------------------------------+

 
Esempio per TRADE_ACTION_MODIFY, operazione di trade per la modifica dei livelli di prezzo degli 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_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_SELL_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
           }
         //--- 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);
        }
     }
  }
//+------------------------------------------------------------------+

 
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);
        }
     }
  }
//+------------------------------------------------------------------+

 
Esempio per TRADE_ACTION_CLOSE_BY, operazione di trade per chiudere posizioni da posizioni opposte:

#define EXPERT_MAGIC 123456  // MagicNumber dell'expert
//+------------------------------------------------------------------+
//| Chiude tutte le posizioni per posizioni opposte                  |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- dichiare ed inizializza la richiesta di trade ed il risultato della richiesta di trade
   MqlTradeRequest request;
   MqlTradeResult  result;
   int total=PositionsTotal(); // numero di posizioni aperte   
//--- itera su tutte le posizioni
   for(int i=total-1; i>=0; 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);            // ticket della posizione
      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
      if(magic==EXPERT_MAGIC)
        {
         for(int j=0; j<i; j++)
           {
            string symbol=PositionGetSymbol(j); // simbolo della posizione opposta
            //--- se i simboli delle posizioni opposte ed iniziali corrispondono
            if(symbol==position_symbol && PositionGetInteger(POSITION_MAGIC))
              {
               //--- imposta il topo di posizione opposta
               ENUM_POSITION_TYPE type_by=(ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
               //--- lascia, se il tipo di posizione iniziale ed opposta corrispondono
               if(type==type_by)
                  continue;
               //--- azzera la richiesta ed i risulanti valori
               ZeroMemory(request);
               ZeroMemory(result);
               //--- imposta i parametri dell'operazione
               request.action=TRADE_ACTION_CLOSE_BY;                         // tipo di operazione di trade
               request.position=position_ticket;                             // ticket della posizione
               request.position_by=PositionGetInteger(POSITION_TICKET);      // ticket della posizione opposta
               //request.symbol     =position_symbol;
               request.magic=EXPERT_MAGIC;                                   // MagicNumber della posizione
               //--- output informazioni riguardo la chiusura per posizione opposta
               PrintFormat("Chiudi#%I64d %s %s da #%I64d",position_ticket,position_symbol,EnumToString(type),request.position_by);
               //--- invia la richiesta
               if(!OrderSend(request,result))
                  PrintFormat("OrderSend errore %d",GetLastError()); // se impossibile inviare la richiesta, output dell'error code
 
               //--- informazioni riguardo l'operazione   
               PrintFormat("retcode=%u  deal=%I64u  order=%I64u",result.retcode,result.deal,result.order);
              }
           }
        }
     }
  }