MetaTrader 5 / Exemples
English Русский 中文 Español Deutsch 日本語 Português 한국어 Italiano Türkçe
Opérations trading en MQL5 - Combien facile

Opérations trading en MQL5 - Combien facile

MetaTrader 5 — Exemples | 22 décembre 2021, 17:16
910 0
MetaQuotes
MetaQuotes

Presque l’ensemble des traders viennent sur la plateforme pour gagner de l'argent, mais certains apprécient également le processus lui-même. Cependant, il n’y a pas que le trading manuel qui peut vous offrir une expérience passionnante. Le développement de systèmes de trading automatisés peut également être très absorbant. Créer un robot de trading peut être aussi intéressant que lire un bon roman policier.

Lors du développement d'un algorithme de trading, nous devons faire face à de nombreux problèmes techniques, dont les plus importants sont les suivants :

  1. Quoi trader ?
  2. Quand trader ?
  3. Comment Trader

Il nous faut répondre à la première question pour choisir le symbole le plus approprié. Notre choix peut être affecté par de nombreux facteurs, notamment la capacité d'automatiser notre système de trading pour le marché. La deuxième question concerne l'élaboration de règles de trading indiquant clairement la direction des trades, ainsi que les points d'entrée et de sortie. La troisième question semble relativement simple : comment acheter et vendre en utilisant un langage de programmation défini ?

Dans cet article, nous verrons comment implémenter des opérations de trading dans le trading algorithmique en utilisant le langage MQL5.


Fonctionnalités MQL5 pour Algo Trading

MQL5 est un langage de programmation de stratégies de trading doté de nombreuses fonctions de trading pour travailler avec les ordres, les positions et les demandes de trading. Ainsi, créer des robots de trading algo dans MQL5 est la tâche la moins laborieuse pour un développeur.

Les fonctionnalités MQL5 vous permettent de faire une demande de trade et de l'envoyer à un serveur à l'aide des fonctions OrderSend() ou OrderSendAsync(), de recevoir son résultat de traitement, d'afficher l'historique de trading, d'examiner les spécifications de contrat pour un symbole, de gérer un événement de trade, ainsi que recevoir d'autres données nécessaires.

En outre, MQL5 peut être utilisé pour écrire des indicateurs techniques personnalisés et appliquer ceux déjà mis en œuvre, dessiner des marques et des objets sur un graphique, développer une interface utilisateur personnalisée, etc. Des exemples de mise en œuvre peuvent être vus dans plusieurs articles.


Opérations de trade : Facile comme ABC !

Il existe plusieurs types d'opérations de trading de base qui peuvent être nécessaires pour votre robot de trading :

  1. acheter/vendre au cours actuel,
  2. passer un ordre en attente d'achat/vente selon une certaine condition,
  3. Supprimer un ordre en attente
  4. fermeture/ajout/réduction/inversion d'une position.

Toutes ces opérations sont effectuées à l'aide de la fonction OrderSend(). Il existe également une version asynchrone appelée OrderSendAsync(). Toutes les diverses opérations de trade sont décrites par la structure MqlTradeRequest contenant une description de la demande de trade. Par conséquent, seul le remplissage correct de la structure MqlTradeRequest et le traitement des résultats d'exécution de la demande peuvent être difficiles lors du traitement des opérations de trade.

Selon votre système de trading, vous pouvez acheter ou vendre au prix du marché (ACHETER ou VENDRE), ainsi que passer un ordre d'achat/vente en attente à une certaine distance du prix actuel du marché :

  • BUY STOP, SELL STOP - achat ou vente en cas de rupture de niveau spécifiée (pire que le cours actuel) ;
  • BUY LIMIT, SELL LIMIT - achat ou vente au cas où un niveau spécifié est atteint (mieux que le cours actuel) ;
  • BUY STOP LIMIT, SELL STOP LIMIT - configuration BUY LIMIT ou SELL LIMIT au cas où un cours spécifié serait atteint.

Ces types d’ordres standard correspondent à l'énumération ENUM_ORDER_TYPE. 



Vous aurez peut-être besoin de modifier ou supprimer un ordre en attente. Cela peut également être fait en utilisant les fonctions OrderSend()/OrderSendAsync(). Modifier une position d’ouverture est également un processus assez simple, car il est effectué en utilisant les mêmes opérations de trade.

Si vous pensez que les opérations de trade sont complexes et compliquées, il est temps que vous changiez d'avis. Nous montrerons non seulement comment coder les achats et les ventes dans MQL5 rapidement et facilement, mais aussi comment travailler avec un compte de trade et les propriétés des symboles. Les catégories de trade nous aideront dans cette entreprise.


Vérifiez votre compte de trading avec CAccountInfo

La première chose que vous devez savoir lors du lancement de votre robot de trading est quel compte de trading sera utilisé pour son fonctionnement. Puisque nous rédigeons un code de formation, nous mettrons en place une vérification pour le cas où Expert Advisor a été lancé sur un compte réel.

La catégorie CAccountInfo est utilisée pour opérer avec un compte. Nous allons ajouter l'inclusion du fichier AccountInfo.mqh et déclarer la variable de la catégorie - compte :

#include <Trade\AccountInfo.mqh>
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- object for working with the account
   CAccountInfo account;
//--- receiving the account number, the Expert Advisor is launched at
   long login=account.Login();
   Print("Login=",login);
//--- clarifying account type
   ENUM_ACCOUNT_TRADE_MODE account_type=account.TradeMode();
//--- if the account is real, the Expert Advisor is stopped immediately!
   if(account_type==ACCOUNT_TRADE_MODE_REAL)
     {
      MessageBox("Trading on a real account is forbidden, disabling","The Expert Advisor has been launched on a real account!");
      return(-1);
     }
//--- displaying the account type    
   Print("Account type: ",EnumToString(account_type));
//--- clarifying if we can trade on this account
   if(account.TradeAllowed())
      Print("Trading on this account is allowed");
   else
      Print("Trading on this account is forbidden: you may have entered using the Investor password");
//--- clarifying if we can use an Expert Advisor on this account
   if(account.TradeExpert())
      Print("Automated trading on this account is allowed");
   else
      Print("Automated trading using Expert Advisors and scripts on this account is forbidden");
//--- clarifying if the permissible number of orders has been set
   int orders_limit=account.LimitOrders();
   if(orders_limit!=0)Print("Maximum permissible amount of active pending orders: ",orders_limit);
//--- displaying company and server names
   Print(account.Company(),": server ",account.Server());
//--- displaying balance and current profit on the account in the end
   Print("Balance=",account.Balance(),"  Profit=",account.Profit(),"   Equity=",account.Equity());
   Print(__FUNCTION__,"  completed"); //---
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---

  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//---

  }

Comme nous pouvons le voir dans le code ci-dessus, de nombreuses données utiles peuvent être reçues à l'aide de la variable compte dans la fonction OnInit(). Vous pouvez ajouter ce code à votre Expert Advisor pour examiner facilement les journaux lors de l'analyse de son fonctionnement.

Les résultats d'un Expert Advisor lancé sur le compte Championnat de trading automatisé 2012 sont indiqués ci-dessous.



Réception des paramètres de Symboles avec CSymbolInfo

Nous avons maintenant les données sur le compte mais nous devons également connaître les propriétés du symbole que nous allons trader avant d'effectuer les opérations nécessaires. La catégorie CSymbolInfo avec un grand nombre de méthodes est conçue à ces fins. Nous ne montrerons qu'une petite partie des méthodes dans l'exemple ci-dessous.

#include<Trade\SymbolInfo.mqh>
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- object for receiving symbol settings
   CSymbolInfo symbol_info;
//--- set the name for the appropriate symbol
   symbol_info.Name(_Symbol);
//--- receive current rates and display
   symbol_info.RefreshRates();
   Print(symbol_info.Name()," (",symbol_info.Description(),")",
         "  Bid=",symbol_info.Bid(),"   Ask=",symbol_info.Ask());
//--- receive minimum freeze levels for trade operations
   Print("StopsLevel=",symbol_info.StopsLevel()," pips, FreezeLevel=",
         symbol_info.FreezeLevel()," pips");
//--- receive the number of decimal places and point size
   Print("Digits=",symbol_info.Digits(),
         ", Point=",DoubleToString(symbol_info.Point(),symbol_info.Digits()));
//--- spread info
   Print("SpreadFloat=",symbol_info.SpreadFloat(),", Spread(current)=",
         symbol_info.Spread()," pips");
//--- request order execution type for limitations
   Print("Limitations for trade operations: ",EnumToString(symbol_info.TradeMode()),
         " (",symbol_info.TradeModeDescription(),")");
//--- clarifying trades execution mode
   Print("Trades execution mode: ",EnumToString(symbol_info.TradeExecution()),
         " (",symbol_info.TradeExecutionDescription(),")");
//--- clarifying contracts price calculation method
   Print("Contract price calculation: ",EnumToString(symbol_info.TradeCalcMode()),
         " (",symbol_info.TradeCalcModeDescription(),")");
//--- sizes of contracts
   Print("Standard contract size: ",symbol_info.ContractSize(),
         " (",symbol_info.CurrencyBase(),")");
//--- minimum and maximum volumes in trade operations
   Print("Volume info: LotsMin=",symbol_info.LotsMin(),"  LotsMax=",symbol_info.LotsMax(),
         "  LotsStep=",symbol_info.LotsStep());
//--- 
   Print(__FUNCTION__,"  completed");
//---
   return(0);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---

  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//---

  }

Les propriétés EURUSD du championnat de trading automatisé 2012 sont présentées ci-dessous. Nous sommes maintenant prêts à effectuer des opérations de trade.



CTrade - Catégorie pratique pour les opérations de trade

Le trading dans MQL5 est effectué uniquement par deux fonctions - OrderSend() et OrderSendAsync(). En fait, ce sont deux mises en application d'une même fonction. OrderSend() envoie une demande de trade et attend le résultat de son exécution, tandis que OrderSendAsync() asynchrone envoie simplement une demande permettant à l'application de continuer son opération sans attendre la réponse d'un serveur de trading. Ainsi, il est vraiment facile de trader en MQL5, car vous n'utilisez qu'une seule fonction pour toutes les opérations de trading.

Alors, quel est le défi? Les deux fonctions reçoivent la structure MqlTradeRequest contenant plus d'une douzaine de champs comme premier paramètre. Tous les champs ne doivent pas nécessairement être remplis. L'ensemble des éléments nécessaires est fonction d’un type d’opérations de trading. Une valeur incorrecte ou un champ vide qui doit être rempli entraînera une erreur et la demande ne sera pas envoyée à un serveur. 5 de ces champs nécessitent des valeurs correctes à partir d'énumérations prédéfinies..

Un tel nombre important de champs est nécessaire pour décrire des lots de propriétés d’ordres dans une demande de trade. Les ordres peuvent changer en fonction de la politique d'exécution, du délai d'expiration et de certains autres paramètres. Mais vous n'êtes pas obligé d'apprendre toutes ces subtilités. Utilisez simplement la catégorie CTrade prête à l'emploi. Voici comment la catégorie peut être utilisée dans votre robot de trading :

#include<Trade\Trade.mqh>
//--- object for performing trade operations
CTrade  trade;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- set MagicNumber for your orders identification
   int MagicNumber=123456;
   trade.SetExpertMagicNumber(MagicNumber);
//--- set available slippage in points when buying/selling
   int deviation=10;
   trade.SetDeviationInPoints(deviation);
//--- order filling mode, the mode allowed by the server should be used
   trade.SetTypeFilling(ORDER_FILLING_RETURN);
//--- logging mode: it would be better not to declare this method at all, the class will set the best mode on its own
   trade.LogLevel(1); 
//--- what function is to be used for trading: true - OrderSendAsync(), false - OrderSend()
   trade.SetAsyncMode(true);
//---
   return(0);
  }

Voyons maintenant comment CTrade aide dans les opérations de trades.

Achat/vente au cours actuel

Les stratégies de trading offrent souvent la possibilité d'acheter ou de vendre au cours actuel sans tarder. Dans ce cas, CTrade demande uniquement de spécifier un volume d'opération de trade nécessaire. Tous les autres paramètres (cours d’ouverture et nom de symbole, niveaux Stop Loss et Take Profit, commentaires sur les ordres) sont facultatifs.

//--- 1. example of buying at the current symbol
   if(!trade.Buy(0.1))
     {
      //--- failure message
      Print("Buy() method failed. Return code=",trade.ResultRetcode(),
            ". Code description: ",trade.ResultRetcodeDescription());
     }
   else
     {
      Print("Buy() method executed successfully. Return code=",trade.ResultRetcode(),
            " (",trade.ResultRetcodeDescription(),")");
     }

Par défaut, CTrade utilisera le nom du symbole du graphique sur lequel il a été lancé si le nom du symbole n'est pas spécifié. C'est pratique pour les stratégies simples. Pour les stratégies multidevises, vous devez toujours spécifier explicitement le symbole pour lequel l'opération de trading sera effectuée.

//--- 2. example of buying at the specified symbol
   if(!trade.Buy(0.1,"GBPUSD"))
     {
      //--- failure message
      Print("Buy() method failed. Return code=",trade.ResultRetcode(),
            ". Code description: ",trade.ResultRetcodeDescription());
     }
   else
     {
      Print("Buy() method executed successfully. Return code=",trade.ResultRetcode(),
            " (",trade.ResultRetcodeDescription(),")");
     }

Tous les paramètres d’ordres peuvent être spécifiés : Niveaux Stop Loss/Take Profit, cours d'ouverture et commentaires.

//--- 3. example of buying at the specified symbol with specified SL and TP
   double volume=0.1;         // specify a trade operation volume
   string symbol="GBPUSD";    //specify the symbol, for which the operation is performed
   int    digits=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS); // number of decimal places
   double point=SymbolInfoDouble(symbol,SYMBOL_POINT);         // point
   double bid=SymbolInfoDouble(symbol,SYMBOL_BID);             // current price for closing LONG
   double SL=bid-1000*point;                                   // unnormalized SL value
   SL=NormalizeDouble(SL,digits);                              // normalizing Stop Loss
   double TP=bid+1000*point;                                   // unnormalized TP value
   TP=NormalizeDouble(TP,digits);                              // normalizing Take Profit
//--- receive the current open price for LONG positions
   double open_price=SymbolInfoDouble(symbol,SYMBOL_ASK);
   string comment=StringFormat("Buy %s %G lots at %s, SL=%s TP=%s",
                               symbol,volume,
                               DoubleToString(open_price,digits),
                               DoubleToString(SL,digits),
                               DoubleToString(TP,digits));
   if(!trade.Buy(volume,symbol,open_price,SL,TP,comment))
     {
      //--- failure message
      Print("Buy() method failed. Return code=",trade.ResultRetcode(),
            ". Code description: ",trade.ResultRetcodeDescription());
     }
   else
     {
      Print("Buy() method executed successfully. Return code=",trade.ResultRetcode(),
            " (",trade.ResultRetcodeDescription(),")");
     }

Comme nous l'avons déjà dit, le nombre magique et le glissement acceptable ont été définis lors de l'initialisation de la copie Ctrade. Par conséquent, ils ne sont pas obligatoires. Cependant, ils peuvent également être fixés avant chaque opération de trade si nécessaire.

Placement d’un ordre Limit

La méthode des catégories BuyLimit() ou SellLimit() appropriées est utilisée pour envoyer un ordre Limit. La version abrégée (lorsque seuls un cours d’ouverture et un volume sont spécifiés) sera appropriée dans la plupart des cas. Le cours d’ouverture pour Buy Limit devrait être inférieur au cours actuel, alors qu'il devrait être plus élevé pour Sell Limit. Ces ordres sont utilisés pour entrer sur le marché au meilleur prix et sont généralement les plus adaptés aux stratégies prévoyant le rebondissement du cours de la ligne de soutien. Le symbole, auquel un Expert Advisor a été lancé, est utilisé dans ce cas :

//--- 1. example of placing a Buy Limit pending order
   string symbol="GBPUSD";    // specify the symbol, at which the order is placed
   int    digits=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS); // number of decimal places
   double point=SymbolInfoDouble(symbol,SYMBOL_POINT);         // point
   double ask=SymbolInfoDouble(symbol,SYMBOL_ASK);             // current buy price
   double price=1000*point;                                   // unnormalized open price
   price=NormalizeDouble(price,digits);                       // normalizing open price
//--- everything is ready, sending a Buy Limit pending order to the server
   if(!trade.BuyLimit(0.1,price))
     {
      //--- failure message
      Print("BuyLimit() method failed. Return code=",trade.ResultRetcode(),
            ". Code description: ",trade.ResultRetcodeDescription());
     }
   else
     {
      Print("BuyLimit() method executed successfully. Return code=",trade.ResultRetcode(),
            " (",trade.ResultRetcodeDescription(),")");
     }

Une version plus détaillée avec spécification de tous les paramètres peut également être utilisée : Niveaux SL/TP, délai d'expiration, nom de symbole et commentaires sur les ordres.

//--- 2. example of placing a Buy Limit pending order with all parameters
   double volume=0.1;
   string symbol="GBPUSD";    // specify the symbol, at which the order is placed
   int    digits=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS); // number of decimal places
   double point=SymbolInfoDouble(symbol,SYMBOL_POINT);         // point
   double ask=SymbolInfoDouble(symbol,SYMBOL_ASK);             // current buy price
   double price=1000*point;                                 // unnormalized open price
   price=NormalizeDouble(price,digits);                      // normalizing open price
   int SL_pips=300;                                         // Stop Loss in points
   int TP_pips=500;                                         // Take Profit in points
   double SL=price-SL_pips*point;                           // unnormalized SL value
   SL=NormalizeDouble(SL,digits);                            // normalizing Stop Loss
   double TP=price+TP_pips*point;                           // unnormalized TP value
   TP=NormalizeDouble(TP,digits);                            // normalizing Take Profit
   datetime expiration=TimeTradeServer()+PeriodSeconds(PERIOD_D1);
   string comment=StringFormat("Buy Limit %s %G lots at %s, SL=%s TP=%s",
                               symbol,volume,
                               DoubleToString(price,digits),
                               DoubleToString(SL,digits),
                               DoubleToString(TP,digits));
//--- everything is ready, sending a Buy Limit pending order to the server
   if(!trade.BuyLimit(volume,price,symbol,SL,TP,ORDER_TIME_GTC,expiration,comment))
     {
      //--- failure message
      Print("BuyLimit() method failed. Return code=",trade.ResultRetcode(),
            ". Code description: ",trade.ResultRetcodeDescription());
     }
   else
     {
      Print("BuyLimit() method executed successfully. Return code=",trade.ResultRetcode(),
            " (",trade.ResultRetcodeDescription(),")");
     }

Votre tâche dans la deuxième version est d'indiquer correctement les niveaux SL et TP. Il convient de noter que le niveau de Take Profit doit être supérieur au cours d'ouverture lors de l'achat, tandis que le niveau de Stop Loss doit être inférieur au cours d'ouverture. La situation inverse concerne les ordres Sell Limit. Vous pouvez facilement connaître votre erreur lorsque vous testez un Expert Advisor sur des données historiques. Dans de tels cas, la classe CTrade affiche automatiquement les messages (sauf si vous engagez la fonction LogLevel).

Placement d’un ordre stop

Des méthodes similaires BuyStop() et SellStop() sont utilisées pour envoyer un ordre stop. Le cours d'ouverture pour Buy Stop devrait être supérieur au cours actuel, tandis qu'il devrait être inférieur pour Sell Stop. Les ordres Stop sont utilisés dans les stratégies qui entrent sur le marché lors d'une rupture du niveau de résistance, ainsi que pour réduire les pertes. Version simplifiée :

//--- 1. example of placing a Buy Stop pending order
   string symbol="USDJPY";    // specify the symbol, at which the order is placed
   int    digits=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS); // number of decimal places
   double point=SymbolInfoDouble(symbol,SYMBOL_POINT);         // point
   double ask=SymbolInfoDouble(symbol,SYMBOL_ASK);             // current buy price
   double price=1000*point;                                    // unnormalized open price
   price=NormalizeDouble(price,digits);                        // normalizing open price
//--- everything is ready, sending a Buy Stop pending order to the server 
   if(!trade.BuyStop(0.1,price))
     {
      //--- failure message
      Print("BuyStop() method failed. Return code=",trade.ResultRetcode(),
            ". Code description: ",trade.ResultRetcodeDescription());
     }
   else
     {
      Print("BuyStop() method executed successfully. Return code=",trade.ResultRetcode(),
            " (",trade.ResultRetcodeDescription(),")");
     }

Version plus détaillée lorsque le nombre maximum de paramètres pour l'ordre en attente Buy Stop doit être spécifié :

//--- 2. example of placing a Buy Stop pending order with all parameters
   double volume=0.1;
   string symbol="USDJPY";    // specify the symbol, at which the order is placed
   int    digits=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS); // number of decimal places
   double point=SymbolInfoDouble(symbol,SYMBOL_POINT);         // point
   double ask=SymbolInfoDouble(symbol,SYMBOL_ASK);             // current buy price
   double price=1000*point;                                   // unnormalized open price
   price=NormalizeDouble(price,digits);                       // normalizing open price
   int SL_pips=300;                                          // Stop Loss in points
   int TP_pips=500;                                          // Take Profit in points
   double SL=price-SL_pips*point;                            // unnormalized SL value
   SL=NormalizeDouble(SL,digits);                             // normalizing Stop Loss
   double TP=price+TP_pips*point;                            // unnormalized TP value
   TP=NormalizeDouble(TP,digits);                             // normalizing Take Profit
   datetime expiration=TimeTradeServer()+PeriodSeconds(PERIOD_D1);
   string comment=StringFormat("Buy Stop %s %G lots at %s, SL=%s TP=%s",
                               symbol,volume,
                               DoubleToString(price,digits),
                               DoubleToString(SL,digits),
                               DoubleToString(TP,digits));
//--- everything is ready, sending a Buy Stop pending order to the server 
   if(!trade.BuyStop(volume,price,symbol,SL,TP,ORDER_TIME_GTC,expiration,comment))
     {
      //--- failure message
      Print("BuyStop() method failed. Return code=",trade.ResultRetcode(),
            ". Code description: ",trade.ResultRetcodeDescription());
     }
   else
     {
      Print("BuyStop() method executed successfully. Return code=",trade.ResultRetcode(),
            " (",trade.ResultRetcodeDescription(),")");
     }

La méthode de catégorie CTrade appropriée est utilisée pour envoyer l'ordre Sell Stop. La spécification correcte des cours est ici d'une importance cruciale.

Gestion de postes

Vous pouvez utiliser des méthodes d'ouverture de position au lieu de celles Buy() et Sell() mais vous devrez spécifier plus de détails dans ce cas :

//--- number of decimal places
   int    digits=(int)SymbolInfoInteger(_Symbol,SYMBOL_DIGITS);
//--- point value
   double point=SymbolInfoDouble(_Symbol,SYMBOL_POINT);
//--- receiving a buy price
   double price=SymbolInfoDouble(_Symbol,SYMBOL_ASK);
//--- calculate and normalize SL and TP levels
   double SL=NormalizeDouble(price-1000*point,digits);
   double TP=NormalizeDouble(price+1000*point,digits);
//--- filling comments
   string comment="Buy "+_Symbol+" 0.1 at "+DoubleToString(price,digits);
//--- everything is ready, trying to open a buy position
   if(!trade.PositionOpen(_Symbol,ORDER_TYPE_BUY,0.1,price,SL,TP,comment))
     {
      //--- failure message
      Print("PositionOpen() method failed. Return code=",trade.ResultRetcode(),
            ". Code description: ",trade.ResultRetcodeDescription());
     }
   else
     {
      Print("PositionOpen() method executed successfully. Return code=",trade.ResultRetcode(),
            " (",trade.ResultRetcodeDescription(),")");
     }

Vous devez spécifier uniquement un nom de symbole, le reste sera fait par la catégorie CTrade.

//--- closing a position at the current symbol
   if(!trade.PositionClose(_Symbol))
     {
      //--- failure message
      Print("PositionClose() method failed. Return code=",trade.ResultRetcode(),
            ". Code description: ",trade.ResultRetcodeDescription());
     }
   else
     {
      Print("PositionClose() method executed successfully. Return code=",trade.ResultRetcode(),
            " (",trade.ResultRetcodeDescription(),")");
     }

Seuls les niveaux Stop Loss et Take Profit sont disponibles pour modifier une position d’ouverture. Ceci est fait en utilisant la méthode PositionModify()

//--- number of decimal places
   int    digits=(int)SymbolInfoInteger(_Symbol,SYMBOL_DIGITS);
//--- point value
   double point=SymbolInfoDouble(_Symbol,SYMBOL_POINT);
//--- receiving the current Bid price
   double price=SymbolInfoDouble(_Symbol,SYMBOL_BID);
//--- calculate and normalize SL and TP levels
   double SL=NormalizeDouble(price-1000*point,digits);
   double TP=NormalizeDouble(price+1000*point,digits);
//--- everything is ready, trying to modify the buy position
   if(!trade.PositionModify(_Symbol,SL,TP))
     {
      //--- failure message
      Print("Метод PositionModify() method failed. Return code=",trade.ResultRetcode(),
            ". Code description: ",trade.ResultRetcodeDescription());
     }
   else
     {
      Print("PositionModify() method executed successfully. Return code=",trade.ResultRetcode(),
            " (",trade.ResultRetcodeDescription(),")");
     }

Modification et suppression d’un ordre

La méthode OrderModify() a été implémentée dans la catégorie CTrade pour modifier les paramètres de l’ordre en attente. Tous les paramètres requis doivent être soumis à cette méthode.

//--- this is a sample order ticket, it should be received
   ulong ticket=1234556;
//--- this is a sample symbol, it should be received
   string symbol="EURUSD";
//--- number of decimal places
   int    digits=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS);
//--- point value
   double point=SymbolInfoDouble(symbol,SYMBOL_POINT);
//--- receiving a buy price
   double price=SymbolInfoDouble(symbol,SYMBOL_ASK);
//--- calculate and normalize SL and TP levels
//--- they should be calculated based on the order type
   double SL=NormalizeDouble(price-1000*point,digits);
   double TP=NormalizeDouble(price+1000*point,digits);
   //--- setting one day as a lifetime
   datetime expiration=TimeTradeServer()+PeriodSeconds(PERIOD_D1);   
//--- everything is ready, trying to modify the order 
   if(!trade.OrderModify(ticket,price,SL,TP,ORDER_TIME_GTC,expiration))
     {
      //--- failure message
      Print("OrderModify() method failed. Return code=",trade.ResultRetcode(),
            ". Code description: ",trade.ResultRetcodeDescription());
     }
   else
     {
      Print("OrderModify() method executed successfully. Return code=",trade.ResultRetcode(),
            " (",trade.ResultRetcodeDescription(),")");
     }

Vous devriez recevoir le ticket de l’ordre qui doit être modifié. Les niveaux corrects de Stop Loss et de Take Profit doivent être spécifiés en fonction de leur type. En outre, le nouveau cours d'ouverture devrait également être correct par rapport au cours actuel.

Vous devez connaître un ticket d'un ordre pour le supprimer :

//--- this is a sample order ticket, it should be received
   ulong ticket=1234556;
//--- everyrging is ready, trying to modify a buy position
   if(!trade.OrderDelete(ticket))
     {
      //--- failure message
      Print("OrderDelete() method failed. Return code=",trade.ResultRetcode(),
            ". Code description: ",trade.ResultRetcodeDescription());
     }
   else
     {
      Print("OrderDelete() method executed successfully. Return code=",trade.ResultRetcode(),
            " (",trade.ResultRetcodeDescription(),")");
     }

La catégorie contient également la méthode polyvalente OrderOpen(), qui peut définir des ordres en attente de tout type. Contrairement aux méthodes spécialisées BuyLimit, BuyStop, SellLimit et SellStop, il est requis de spécifier des paramètres plus essentiels. Peut-être que vous le trouverez plus pratique.


Que faut-il résoudre d'autre ?

Nous avons donc répondu à deux questions sur trois. Vous avez choisi le symbole de votre stratégie et nous vous avons montré comment coder facilement les opérations d'achat et de vente, ainsi que les ordres en attente dans un robot de trading. Mais la section Catégories de trades contient des outils plus utiles pour les développeurs MQL5 :

  • COrderInfo - pour la gestion des ordres ;
  • CHistoryOrderInfo - pour la gestion des ordres exécutés dans l'historique du trading ;
  • CPositionInfo - pour la gestion des positions ;
  • CDealInfo - pour traiter des contrats ;
  • CTerminalInfo - pour recevoir des données sur le terminal (il s’agit ici d’un point très intéressant).

Avec ces catégories, vous pouvez concentrer votre attention sur l’aspect trading de votre stratégie en minimisant tous les problèmes techniques. En outre, la catégorie CTrade peut être utilisée pour examiner les demandes de trades. Après un peu de pratique, vous pourrez l'utiliser pour créer vos catégories personnalisées avec les logiques nécessaires pour gérer les résultats d'exécution des demandes de trades.

La dernière question est de savoir comment recevoir des signaux de trading et comment les coder en MQL5. La plupart des novices dans le trading algo commencent par étudier des systèmes de trading standard simples, par exemple, ceux basés sur la croisée de moyennes mobiles. Pour ce faire, vous devez d'abord apprendre à bien gérer les indicateurs techniques en les créant et en les utilisant dans votre robot de trading.

Nous vous recommandons de lire les articles des sections Indicateurs et Exemples->Indicateurs en commençant par les plus anciens. Cela vous permettra de passer des sujets les plus simples aux plus complexes. Si vous souhaitez avoir rapidement une idée sur l'utilisation des indicateurs, consultez MQL5 pour débutants : Guide d'utilisation des indicateurs techniques dans les Expert Advisors.


Opérations de trades dans MQL5

Simplifier les choses compliquées

Dans toute entreprise, les premières difficultés se transforment progressivement en problèmes les plus simples qu’il vous faut traiter. Les méthodes de développement de robots de trading proposées ici sont principalement destinées aux novices, bien que de nombreux développeurs expérimentés puissent également trouver quelque chose de nouveau et d'utile.

Le langage MQL5 offre non seulement des opportunités illimitées pour le trading algo, mais permet également à chacun de les mettre en application de la manière la plus simple et la plus rapide. Utilisez les catégories de trades de la bibliothèque standard pour gagner du temps pour des choses plus importantes, par exemple, pour rechercher la réponse à l'éternelle question de tous les traders - qu'est-ce qu'une tendance et comment la trouver en temps réel.

Bientôt, vous verrez que développer un robot de trading en MQL5 est bien plus simple que d'apprendre une langue étrangère ou de suivre une tendance !


Traduit du russe par MetaQuotes Ltd.
Article original : https://www.mql5.com/ru/articles/481

Avertissement: Tous les droits sur ces documents sont réservés par MetaQuotes Ltd. La copie ou la réimpression de ces documents, en tout ou en partie, est interdite.

Autres articles par cet auteur

Aller à la discussion
Stratégies d’ordres. Un Expert Advisor polyvalent Stratégies d’ordres. Un Expert Advisor polyvalent
Cet article se concentre sur les stratégies qui utilisent activement les ordres en attente, un métalangage qui peut être créé pour décrire formellement de telles stratégies et l'utilisation d'un Expert Advisor polyvalent dont le fonctionnement est basé sur ces descriptions.
Rapide Plongée dans MQL5 Rapide Plongée dans MQL5
Vous avez décidé d'étudier le langage de programmation des stratégies de trading MQL5, mais vous n'y connaissez rien ? Nous avons essayé d'examiner les terminaux MQL5 et MetaTrader 5 du point de vue des nouveaux venus et avons écrit ce court article d'introduction. Dans cet article, vous pouvez trouver une brève idée des possibilités du langage, ainsi que quelques conseils pour travailler avec MetaEditor 5 et le terminal.
Un démarrage rapide ou un petit guide pour les débutants Un démarrage rapide ou un petit guide pour les débutants
Bonjour cher lecteur ! Dans cet article, je vais essayer de vous expliquer et de vous montrer comment maîtriser facilement et rapidement les principes de création d'Expert Advisors, de travail avec des indicateurs, etc. Il est destiné aux débutants et ne comportera pas d'exemples difficiles ou abstraits.
Comment créer un robot de trading en un rien de temps Comment créer un robot de trading en un rien de temps
Le trading sur les marchés financiers comporte de nombreux risques, dont le plus critique - le risque de prendre une mauvaise décision de trading. Le rêve de tout trader est de trouver un robot de trading, qui soit toujours en bon état et non sujet aux faiblesses humaines - peur, cupidité et impatience.