DocumentationSections
Référence MQL5Constantes, Enumérations et StructuresConstantes de TradingTypes d'Opérations de Trading 

Types d'Opérations de Trading

Le trading est effectué en envoyant des ordres pour ouvrir des positions avec la fonction OrderSend(), mais aussi pour placer, modifier ou supprimer des ordres en attente. Chaque ordre fait référence au type de l'opération demandée. Les opérations de trading sont décrites dans l'énumération ENUM_TRADE_REQUEST_ACTIONS.

ENUM_TRADE_REQUEST_ACTIONS

Identificateur

Description

TRADE_ACTION_DEAL

Place un trade pour une exécution immédiate avec les paramètres spécifiés (ordre au marché)

TRADE_ACTION_PENDING

Place un trade pour une exécution dans des conditions spécifiées (ordre en attente)

TRADE_ACTION_SLTP

Modifie les valeurs du Stop Loss et du Take Profit d'une position ouverte

TRADE_ACTION_MODIFY

Modifie les paramètres d'un ordre placé précedemment

TRADE_ACTION_REMOVE

Supprime l'ordre en attente placé précedemment

TRADE_ACTION_CLOSE_BY

Ferme une position par une position opposée

 
Exemple de l'opération de trading TRADE_ACTION_DEAL pour ouvrir une position Buy :

#define EXPERT_MAGIC 123456   // MagicNumber de l'
//+------------------------------------------------------------------+
//| Ouverture d'une position Buy                                     |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- déclare et initialise la demande de trading et le résultat de la demande
   MqlTradeRequest request={};
   MqlTradeResult  result={};
//--- paramètres de la demande
   request.action   =TRADE_ACTION_DEAL;                     // type de l'opération de trading
   request.symbol   =Symbol();                              // symbole
   request.volume   =0.1;                                   // volume de 0.1 lot
   request.type     =ORDER_TYPE_BUY;                        // type de l'ordre
   request.price    =SymbolInfoDouble(Symbol(),SYMBOL_ASK); // prix d'ouverture
   request.deviation=5;                                     // déviation du prix autorisée
   request.magic    =EXPERT_MAGIC;                          // MagicNumber de l'ordre
//--- envoi la demande
   if(!OrderSend(request,result))
      PrintFormat("OrderSend erreur %d",GetLastError());     // en cas d'erreur d'envoi de la demande, affiche le code d'erreur
//--- informations de l'opération
   PrintFormat("retcode=%u  transaction=%I64u  ordre=%I64u",result.retcode,result.deal,result.order);
  }
//+------------------------------------------------------------------+

 
Exemple de l'opération de trading TRADE_ACTION_DEAL pour ouvrir une position Sell :

#define EXPERT_MAGIC 123456   // MagicNumber de l'
//+------------------------------------------------------------------+
//| Ouverture d'une position Sell                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- déclare et initialise la demande de trading et le résultat de la demande
   MqlTradeRequest request={};
   MqlTradeResult  result={};
//--- paramètres de la demande
   request.action   =TRADE_ACTION_DEAL;                     // type de l'opération de trading
   request.symbol   =Symbol();                              // symbole
   request.volume   =0.1;                                   // volume de 0.2 lot
   request.type     =ORDER_TYPE_SELL;                        // type de l'ordre
   request.price    =SymbolInfoDouble(Symbol(),SYMBOL_BID); // prix d'ouverture
   request.deviation=5;                                     // déviation du prix autorisée
   request.magic    =EXPERT_MAGIC;                          // MagicNumber de l'ordre
//--- envoi la demande
   if(!OrderSend(request,result))
      PrintFormat("OrderSend erreur %d",GetLastError());     // en cas d'erreur d'envoi de la demande, affiche le code d'erreur
//--- informations de l'opération
   PrintFormat("retcode=%u  transaction=%I64u  ordre=%I64u",result.retcode,result.deal,result.order);
  }
<b88>//+------------------------------------------------------------------+

 
Exemple de l'opération de trading TRADE_ACTION_DEAL pour fermer des positions :

#define EXPERT_MAGIC 123456   // MagicNumber de l'expert
//+------------------------------------------------------------------+
//| Fermeture de toutes les positions                                |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- déclare et initialise la demande de trading et le résultat
   MqlTradeRequest request;
   MqlTradeResult  result;
   int total=PositionsTotal(); // nombre de positions ouvertes
//--- boucle sur toutes les positions ouvertes
   for(int i=total-1; i>=0; i--)
     {
      //--- paramètres de l'ordre
      ulong  position_ticket=PositionGetTicket(i);                                      // ticket de la position
      string position_symbol=PositionGetString(POSITION_SYMBOL);                        // symbole
      int    digits=(int)SymbolInfoInteger(position_symbol,SYMBOL_DIGITS);              // nombre de décimales
      ulong  magic=PositionGetInteger(POSITION_MAGIC);                                  // MagicNumber de la position
      double volume=PositionGetDouble(POSITION_VOLUME);                                 // volume de la position
      ENUM_POSITION_TYPE type=(ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);    // type de la position
      //--- affiche les informations de la position
      PrintFormat("#%I64u %s  %s  %.2f  %s [%I64d]",
                  position_ticket,
                  position_symbol,
                  EnumToString(type),
                  volume,
                  DoubleToString(PositionGetDouble(POSITION_PRICE_OPEN),digits),
                  magic);
      //--- si le MagicNumber correspond
      if(magic==EXPERT_MAGIC)
        {
         //--- remise à zéro de la demande et du résultat
         ZeroMemory(request);
         ZeroMemory(result);
         //--- paramètres de l'opration
         request.action   =TRADE_ACTION_DEAL;        // type de l'opération de trading
         request.position =position_ticket;          // ticket de la position
         request.symbol   =position_symbol;          // symbole 
         request.volume   =volume;                   // volume de la position
         request.deviation=5;                        // déviation du prix autoriséee
         request.magic    =EXPERT_MAGIC;             // MagicNumber de la position
         //--- définit le prix et le type de l'ordre suivant le type de la position
         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;
           }
         //--- affiche les informations de clôture
         PrintFormat("Ferme #%I64d %s %s",position_ticket,position_symbol,EnumToString(type));
         //--- envoi la demande
         if(!OrderSend(request,result))
            PrintFormat("OrderSend erreur %d",GetLastError());  // en cas d'échec de l'envoi, affiche le code d'erreur
         //--- informations sur l'opération   
         PrintFormat("retcode=%u  transaction=%I64u  ordre=%I64u",result.retcode,result.deal,result.order);
         //---
        }
     }
  }
//+------------------------------------------------------------------+

 
Exemple de l'opération de trading TRADE_ACTION_PENDING pour placer un ordre en attente :

#property description "Exemple de placement d'ordres en attente"
#property script_show_inputs
#define EXPERT_MAGIC 123456                             // MagicNumber de l'expert
input ENUM_ORDER_TYPE orderType=ORDER_TYPE_BUY_LIMIT;   // type de l'ordre
//+------------------------------------------------------------------+
//| Placement d'ordres en attente                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- déclare et initialise la demande de trade et le résultat
   MqlTradeRequest request={};
   MqlTradeResult  result={};
//--- paramètres pour placer un ordre en attente
   request.action   =TRADE_ACTION_PENDING;                             // type de trade operation
   request.symbol   =Symbol();                                         // symbole
   request.volume   =0.1;                                              // volume de 0.1 lot
   request.deviation=2;                                                // déviation autorisée du prix
   request.magic    =EXPERT_MAGIC;                                     // MagicNumber de l'ordre
   int offset = 50;                                                    // décalage du prix courant pour placer un ordre, en points
   double price;                                                       // prix de déclenchement de l'ordre
   double point=SymbolInfoDouble(_Symbol,SYMBOL_POINT);                // valeur du point
   int digits=SymbolInfoInteger(_Symbol,SYMBOL_DIGITS);                // nombre de décimales (précision)
   //--- vérification du type de l'opération
   if(orderType==ORDER_TYPE_BUY_LIMIT)
     {
      request.type     =ORDER_TYPE_BUY_LIMIT;                          // type de l'ordre
      price=SymbolInfoDouble(Symbol(),SYMBOL_ASK)-offset*point;        // prix d'ouverture
      request.price    =NormalizeDouble(price,digits);                 // prix d'ouverture normalisé
     }
   else if(orderType==ORDER_TYPE_SELL_LIMIT)
     {
      request.type     =ORDER_TYPE_SELL_LIMIT;                          // type de l'ordre
      price=SymbolInfoDouble(Symbol(),SYMBOL_ASK)+offset*point;         // prix d'ouverture
      request.price    =NormalizeDouble(price,digits);                  // prix d'ouverture normalisé
     }
   else if(orderType==ORDER_TYPE_BUY_STOP)
     {
      request.type =ORDER_TYPE_BUY_STOP;                                // type de l'ordre
      price        =SymbolInfoDouble(Symbol(),SYMBOL_ASK)+offset*point; // prix d'ouverture
      request.price=NormalizeDouble(price,digits);                      // prix d'ouverture normalisé
     }
   else if(orderType==ORDER_TYPE_SELL_STOP)
     {
      request.type     =ORDER_TYPE_SELL_STOP;                           // type de l'ordre
      price=SymbolInfoDouble(Symbol(),SYMBOL_ASK)-offset*point;         // prix d'ouverture
      request.price    =NormalizeDouble(price,digits);                  // prix d'ouverture normalisé
     }
   else Alert("Cet exemple ne permet de ne placer que des ordres en attente");   // si aucun ordre en attente n'est sélectionné
//--- envoie la demande
   if(!OrderSend(request,result))
      PrintFormat("OrderSend erreur %d",GetLastError());                 // en cas d'échec de l'envoi de la demande, affiche le code de l'erreur
//--- informations sur l'opération
   PrintFormat("retcode=%u  transaction=%I64u  ordre=%I64u",result.retcode,result.deal,result.order);
  }
//+------------------------------------------------------------------+

 
Exemple de l'opération de trading TRADE_ACTION_SLTP pour modifier les valeurs des Stop Loss et Take Profit d'une position ouverte :

#define EXPERT_MAGIC 123456  // MagicNumber de l' expert
//+------------------------------------------------------------------+
//| Modification du Stop Loss et du Take Profit d'une position       |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- déclare et initialise la demande de trade et le résultat
   MqlTradeRequest request;
   MqlTradeResult  result;
   int total=PositionsTotal(); // nombre de positions ouvertes
//--- boucle sur toutes les positions ouvertes
   for(int i=0; i<total; i++)
     {
      //--- paramètres de l'ordre
      ulong  position_ticket=PositionGetTicket(i);// ticket de la position
      string position_symbol=PositionGetString(POSITION_SYMBOL); // symbole 
      int    digits=(int)SymbolInfoInteger(position_symbol,SYMBOL_DIGITS); // nombre de décimales
      ulong  magic=PositionGetInteger(POSITION_MAGIC); // MagicNumber de la position
      double volume=PositionGetDouble(POSITION_VOLUME);    // volume de la position
      double sl=PositionGetDouble(POSITION_SL);  // Stop Loss de la position
      double tp=PositionGetDouble(POSITION_TP);  // Take Profit de la position
      ENUM_POSITION_TYPE type=(ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);  // type de la position
      //--- affiche quelques informations sur la position
      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);
      //--- si le MagicNumber correspond et que le Stop Loss et le Take Profit ne sont pas définis
      if(magic==EXPERT_MAGIC && sl==0 && tp==0)
        {
         //--- calcule les niveaux de prix actuels
         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;
         //--- si la distance de décalage minimum autorisée en points du prix de cloturê courant n'est pas définie
         if(stop_level<=0)
            stop_level=150; // définit la distance de décalage de 150 points du priwx de clôture courant
         else
            stop_level+=50; // définit la distance de décalage à (SYMBOL_TRADE_STOPS_LEVEL + 50) points pour la fiabilité
 
         //--- calcul et arrondi des valeurs du Stop Loss et du 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);
           }
         //--- remise à zéro de la demande et du résultat
         ZeroMemory(request);
         ZeroMemory(result);
         //--- définition des paramètres de l'opération
         request.action  =TRADE_ACTION_SLTP; // type de l'opération de trading
         request.position=position_ticket;   // ticket de la position
         request.symbol=position_symbol;     // symbole 
         request.sl      =sl;                // Stop Loss de la position
         request.tp      =tp;                // Take Profit de la position
         request.magic=EXPERT_MAGIC;         // MagicNumber de la position
         //--- affiche des informations sur la modification
         PrintFormat("Modification de #%I64d %s %s",position_ticket,position_symbol,EnumToString(type));
         //--- envoi de la demande
         if(!OrderSend(request,result))
            PrintFormat("OrderSend erreur %d",GetLastError());  // en cas d'échec de l'envoi, affiche le code de l'erreur
         //--- informations sur l'opération   
         PrintFormat("retcode=%u  deal=%I64u  order=%I64u",result.retcode,result.deal,result.order);
        }
     }
  }
//+------------------------------------------------------------------+

 
Exemple de l'opération de trading TRADE_ACTION_MODIFY pour modifier les niveaux de prix d'ordres en attente :

#define EXPERT_MAGIC 123456  // MagicNumber de l'expert
//+------------------------------------------------------------------+
//| Modification des ordres en attente                               |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- déclare et initialise la demande de trade et le résultat
   MqlTradeRequest request={};
   MqlTradeResult  result={};
   int total=OrdersTotal(); // nombre total d'ordres en attente placés
//--- boucle sur tous les ordres en attente placés
   for(int i=0; i<total; i++)
     {
      //--- paramètres pour l'ordre
      ulong  order_ticket=OrderGetTicket(i);                             // ticket de l'ordre
      string order_symbol=Symbol();                                      // symbole
      int    digits=(int)SymbolInfoInteger(order_symbol,SYMBOL_DIGITS);  // nombre de décimales
      ulong  magic=OrderGetInteger(ORDER_MAGIC);                         // MagicNumber de l'ordre
      double volume=OrderGetDouble(ORDER_VOLUME_CURRENT);                // volume actuel de l'ordre
      double sl=OrderGetDouble(ORDER_SL);                                // Stop Loss actuel de l'ordre
      double tp=OrderGetDouble(ORDER_TP);                                // Take Profit actuel de l'ordre
      ENUM_ORDER_TYPE type=(ENUM_ORDER_TYPE)OrderGetInteger(ORDER_TYPE); // type de l'ordre
      int offset = 50;                                                   // décalage du prix courant pour placer l'ordre, en points
      double price;                                                      // prix de déclenchement de l'ordre
      double point=SymbolInfoDouble(order_symbol,SYMBOL_POINT);          // valeur du point
      //--- affiche des informations sur l'ordre
      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);
      //--- si le MagicNumber correspond, et que le Stop Loss et le Take Profit ne sont pas définis
      if(magic==EXPERT_MAGIC && sl==0 && tp==0)
        {
         request.action=TRADE_ACTION_MODIFY;                           // type de l'opération de trading
         request.order = OrderGetTicket(i);                            // ticket de l'ordre
         request.symbol   =Symbol();                                   // symbole
         request.deviation=5;                                          // déviation autorisée du prix
        //--- définition du niveau de prix, du Take Profit et du Stop Loss de l'ordre suivant son type
         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);                // prix d'ouverture normalisé
           }
         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);                 // prix d'ouverture normalisé
           }
         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);                 // prix d'ouverture normalisé
           }
         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);                 // prix d'ouverture normalisé
           }
         //--- envoi de la demande
         if(!OrderSend(request,result))
            PrintFormat("OrderSend erreur %d",GetLastError());  // en cas d'échec de l'envoi de la demande, affiche le code de l'erreur
         //--- informations sur l'opération   
         PrintFormat("retcode=%u  transaction=%I64u  ordre=%I64u",result.retcode,result.deal,result.order);
         //--- remise à zéro de la demande et du résultat
         ZeroMemory(request);
         ZeroMemory(result);
        }
     }
  }
//+------------------------------------------------------------------+

 
Exemple de l'opération de trading TRADE_ACTION_REMOVE pour supprimer des ordres en attente :

#define EXPERT_MAGIC 123456  // MagicNumber de l'expert
//+------------------------------------------------------------------+
//| Suppression des ordres en attente                                |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- déclare et initialise la demande de trading et le résultat
   MqlTradeRequest request={};
   MqlTradeResult  result={};
   int total=OrdersTotal(); // nombre total d'ordre en attente placés
//--- boucle sur tous les ordres en attente placés
   for(int i=total-1; i>=0; i--)
     {
      ulong  order_ticket=OrderGetTicket(i);                   // Ticket de l'ordre
      ulong  magic=OrderGetInteger(ORDER_MAGIC);               // MagicNumber de l'ordre
      //--- si le MagicNumber correspond
      if(magic==EXPERT_MAGIC)
        {
         //--- remise à zéro de la demande et du résultat
         ZeroMemory(request);
         ZeroMemory(result);
         //--- paramètres de l'opération
         request.action=TRADE_ACTION_REMOVE;                   // type de l'opération de trading
         request.order = order_ticket;                         // Ticket de l'ordre
         //--- envoi la demande
         if(!OrderSend(request,result))
            PrintFormat("OrderSend erreur %d",GetLastError());  // en cas d'échec de l'envoi de la demande, affiche le code d'erreur
         //--- informations sur l'opération   
         PrintFormat("retcode=%u  transaction=%I64u  ordre=%I64u",result.retcode,result.deal,result.order);
        }
     }
  }
//+------------------------------------------------------------------+

 
Exemple de trade TRADE_ACTION_CLOSE_BY pour des positions fermées par des positions opposées :

#define EXPERT_MAGIC 123456  // MagicNumber de l' expert
//+------------------------------------------------------------------+
//| Ferme toutes les positions par des positions opposées            |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- déclare et initialise la demande de trade et son résultat
   MqlTradeRequest request;
   MqlTradeResult  result;
   int total=PositionsTotal(); // nombre de positions ouvertes
//--- boucle sur toutes les positions ouvertes
   for(int i=total-1; i>=0; i--)
     {
      //--- paramètres de l'ordre
      ulong  position_ticket=PositionGetTicket(i);                                    // ticket de la position
      string position_symbol=PositionGetString(POSITION_SYMBOL);                      // symbole 
      int    digits=(int)SymbolInfoInteger(position_symbol,SYMBOL_DIGITS);            // ticket de la position
      ulong  magic=PositionGetInteger(POSITION_MAGIC);                                // MagicNumber de la position
      double volume=PositionGetDouble(POSITION_VOLUME);                               // volume de la position
      double sl=PositionGetDouble(POSITION_SL);                                       // Stop Loss de la position
      double tp=PositionGetDouble(POSITION_TP);                                       // Take Profit de la position
      ENUM_POSITION_TYPE type=(ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);  // type de la position
      //--- affiche les informations de la position
      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);
      //--- si le MagicNumber correspond
      if(magic==EXPERT_MAGIC)
        {
         for(int j=0; j<i; j++)
           {
            string symbol=PositionGetSymbol(j); // symbole de la position opposée
            //--- si les symboles de la position initiale et de la position opposée correspondent
            if(symbol==position_symbol && PositionGetInteger(POSITION_MAGIC)==EXPERT_MAGIC)
              {
               //--- définit le type de la position opposée
               ENUM_POSITION_TYPE type_by=(ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
               //--- sortie si les types de la position initiale et de la position opposée correpondent
               if(type==type_by)
                  continue;
               //--- remise à zéro de la demande et de son résultat
               ZeroMemory(request);
               ZeroMemory(result);
               //--- définition des paramètres de l'opération
               request.action=TRADE_ACTION_CLOSE_BY;                         // type de l'opération de trading
               request.position=position_ticket;                             // ticket de la position
               request.position_by=PositionGetInteger(POSITION_TICKET);      // ticket de la position opposée
               //request.symbol     =position_symbol;
               request.magic=EXPERT_MAGIC;                                   // MagicNumber de la position
               //--- affiche des informations sur la cloture par une position opposée
               PrintFormat("Close #%I64d %s %s by #%I64d",position_ticket,position_symbol,EnumToString(type),request.position_by);
               //--- envoie la demande
               if(!OrderSend(request,result))
                  PrintFormat("OrderSend erreur %d",GetLastError()); // en cas d'impossibilité d'envoyer la demande, affiche le code d'erreur
 
               //--- information sur l'opération   
               PrintFormat("retcode=%u  deal=%I64u  order=%I64u",result.retcode,result.deal,result.order);
              }
           }
        }
     }
  }
//+------------------------------------------------------------------+