Nouveau : la formation trading algorithmique MQL5, MQL4 et ProRealTimeDécouvrir →

MQL5 · Ordres et positions

La classe CTrade en MQL5 : envoyer et contrôler ses ordres simplement

CTrade simplifie l’envoi des ordres en MQL5 : Buy, Sell, PositionModify, PositionClose. Voici comment la régler, l’utiliser et surtout vérifier ce que le serveur a vraiment exécuté.

Mis à jour le 23 octobre 2026Lecture : 7 minPar Alix, OptiBot Trading

CTrade est la classe de la bibliothèque standard MQL5 qui simplifie l’envoi des requêtes de trading. Vous l’incluez avec #include <Trade\Trade.mqh>, vous déclarez un objet, vous le réglez une fois (magic number, déviation, mode de remplissage) puis vous appelez des méthodes explicites comme Buy, Sell, PositionModify ou PositionClose. Après chaque appel, les méthodes ResultRetcode, ResultDeal ou ResultOrder vous indiquent ce que le serveur a réellement fait.

La documentation la décrit comme une classe utilitaire facilitant l’accès aux fonctions de trading. Sous le capot, elle remplit les structures MqlTradeRequest et MqlTradeResult que vous manipuleriez sinon à la main avec OrderSend. Elle hérite de CObject. Pour situer cette page dans l’ensemble, consultez la rubrique Ordres et positions en MQL5.

La règle d’or : true ne veut pas dire exécuté

Toutes les méthodes de trading de CTrade renvoient un bool. La documentation est constante sur ce point, de Buy à PositionClose : true signifie que la vérification de base des structures a réussi, et la réussite de la méthode ne signifie pas toujours la réussite de l’opération de trading. Il faut vérifier le code de retour du serveur avec ResultRetcode() et, selon l’opération, le ticket renvoyé par ResultDeal() (opération au marché) ou ResultOrder() (ordre en attente).

Ce double contrôle est le réflexe à acquérir avant tout le reste :

  • false : la requête n’a pas pu être envoyée ou est mal formée ; GetLastError() donne la raison côté terminal ;
  • true et ResultRetcode() égal à TRADE_RETCODE_DONE (10009) : requête exécutée ;
  • true et TRADE_RETCODE_PLACED (10008) : ordre placé (cas normal des ordres en attente) ;
  • true et un autre code : le serveur a refusé ou n’a exécuté qu’une partie, à analyser avec la page Codes de retour du serveur de trading.

Les méthodes, par famille

La documentation organise les méthodes de CTrade en groupes. Voici ceux dont un Expert Advisor se sert au quotidien.

Réglages

MéthodeRôle
SetExpertMagicNumber(ulong magic)magic number placé dans chaque requête
SetDeviationInPoints(ulong deviation)déviation de prix maximale acceptée, en points
SetTypeFilling(ENUM_ORDER_TYPE_FILLING filling)mode de remplissage imposé
SetTypeFillingBySymbol(const string symbol)mode de remplissage choisi d’après SYMBOL_FILLING_MODE du symbole
SetAsyncMode(bool mode)envoi asynchrone (via OrderSendAsync)
LogLevel(...)niveau de journalisation de la classe

Ces méthodes de réglage ne renvoient rien (void), sauf SetTypeFillingBySymbol qui renvoie false si la politique de remplissage n’a pas pu être déterminée. Selon la documentation, si FOK et IOC sont tous deux autorisés pour le symbole, c’est ORDER_FILLING_FOK qui est retenu. Le sujet est approfondi dans Modes de remplissage.

Positions

  • PositionOpen(symbol, order_type, volume, price, sl, tp, comment="") : ouverture générique ;
  • PositionModify(symbol, sl, tp) et PositionModify(ticket, sl, tp) : modification des stops ;
  • PositionClose(symbol, deviation=ULONG_MAX) et PositionClose(ticket, deviation=ULONG_MAX) : fermeture ;
  • PositionClosePartial(symbol ou ticket, volume, deviation=ULONG_MAX) : fermeture partielle ;
  • PositionCloseBy(ticket, ticket_by) : fermeture par position opposée (hedging).

Sur un compte hedging, les surcharges par symbole de PositionModify et PositionClose agissent, d’après la documentation, sur la position au ticket le plus bas. Préférez les surcharges par ticket dès que plusieurs positions peuvent coexister.

Raccourcis d’ouverture

  • Buy(volume, symbol=NULL, price=0.0, sl=0.0, tp=0.0, comment="") : si le prix est omis, la documentation indique que le prix Ask courant est utilisé ; si le symbole est omis, c’est celui du graphique ;
  • Sell(...) : même signature, avec le prix Bid courant par défaut ;
  • BuyLimit, BuyStop, SellLimit, SellStop(volume, price, symbol=NULL, sl=0.0, tp=0.0, type_time=ORDER_TIME_GTC, expiration=0, comment="") : ordres en attente.

Ordres en attente

  • OrderOpen(symbol, order_type, volume, limit_price, price, sl, tp, type_time, expiration, comment="") ;
  • OrderModify(ticket, price, sl, tp, type_time, expiration, stoplimit) ;
  • OrderDelete(ticket).

Lecture des résultats

Après l’envoi : ResultRetcode() (uint), ResultRetcodeDescription() (string), ResultDeal(), ResultOrder() (ulong), ResultVolume(), ResultPrice(), ResultBid(), ResultAsk(), ResultComment(). Après une vérification : CheckResultRetcode(), CheckResultMarginFree() et les autres méthodes CheckResult…. Enfin, PrintRequest() et PrintResult() écrivent la dernière requête et son résultat dans le journal, ce qui est précieux pour déboguer.

Exemple complet : un module de trading avec CTrade

Cet Expert Advisor minimal montre la configuration type et une fonction d’ouverture qui contrôle correctement le résultat. La logique de signal est volontairement absente : l’EA ouvre une position d’achat s’il n’en a aucune, uniquement pour illustrer le flux. N’utilisez cet exemple que sur un compte de démonstration.

//+------------------------------------------------------------------+
//| Démonstration de CTrade : configuration et contrôle du résultat  |
//+------------------------------------------------------------------+
#include <Trade\Trade.mqh>

input ulong  InpMagic     = 240502;  // magic number
input double InpLots      = 0.10;    // volume
input int    InpSLPoints  = 300;     // stop loss en points
input int    InpTPPoints  = 600;     // take profit en points
input ulong  InpDeviation = 10;      // déviation maximale en points

CTrade trade;

int OnInit()
  {
   trade.SetExpertMagicNumber(InpMagic);
   trade.SetDeviationInPoints(InpDeviation);
   //--- mode de remplissage d'après les réglages du symbole
   if(!trade.SetTypeFillingBySymbol(_Symbol))
      Print("Mode de remplissage non déterminé pour ", _Symbol);
   return(INIT_SUCCEEDED);
  }

//--- true si l'EA a déjà une position sur ce symbole
bool HasMyPosition()
  {
   for(int i = PositionsTotal() - 1; i >= 0; i--)
     {
      if(PositionGetTicket(i) == 0) continue;
      if(PositionGetString(POSITION_SYMBOL) == _Symbol &&
         (ulong)PositionGetInteger(POSITION_MAGIC) == InpMagic)
         return(true);
     }
   return(false);
  }

//--- ouvre un achat et renvoie le ticket du deal (0 si échec)
ulong OpenBuy()
  {
   MqlTick tick;
   if(!SymbolInfoTick(_Symbol, tick)) return(0);

   double sl = NormalizeDouble(tick.bid - InpSLPoints * _Point, _Digits);
   double tp = NormalizeDouble(tick.bid + InpTPPoints * _Point, _Digits);

   if(!trade.Buy(InpLots, _Symbol, tick.ask, sl, tp, "demo CTrade"))
     {
      Print("Requête non envoyée, erreur ", GetLastError());
      return(0);
     }
   uint rc = trade.ResultRetcode();
   if(rc != TRADE_RETCODE_DONE && rc != TRADE_RETCODE_DONE_PARTIAL)
     {
      PrintFormat("Refus du serveur : %u (%s)", rc, trade.ResultRetcodeDescription());
      trade.PrintRequest();          // détail de la requête dans le journal
      return(0);
     }
   PrintFormat("Deal %I64u exécuté à %.5f pour %.2f lot",
               trade.ResultDeal(), trade.ResultPrice(), trade.ResultVolume());
   return(trade.ResultDeal());
  }

void OnTick()
  {
   if(!HasMyPosition())
      OpenBuy();
  }

Remarquez que les stops d’un achat sont calculés à partir du Bid, puisqu’une position acheteuse se ferme au Bid. Ce point est expliqué dans Placer et modifier stop loss et take profit.

Ordres en attente : lire ResultOrder plutôt que ResultDeal

Pour un ordre en attente, aucune transaction n’a lieu au moment de l’envoi : le serveur enregistre seulement l’ordre. Le code de retour attendu est alors TRADE_RETCODE_PLACED (10008) et le ticket utile est celui de l’ordre, renvoyé par ResultOrder(). La documentation de BuyLimit et de OrderOpen le précise : il faut vérifier ResultRetcode() et la valeur renvoyée par ResultOrder(). Mémorisez ce ticket si votre EA doit ensuite modifier l’ordre avec OrderModify(ticket, …) ou le supprimer avec OrderDelete(ticket). Le détail des ordres limites et stop est traité dans Ordres limites et stop.

Le mode asynchrone

SetAsyncMode(true) fait passer la classe sur OrderSendAsync : la méthode rend la main dès que la requête est partie, sans attendre la réponse du serveur. Selon la documentation d’OrderSendAsync, le résultat contient alors le code 10008 et le véritable résultat de l’exécution arrive par l’événement OnTradeTransaction. Ce mode n’a d’intérêt que pour les EA qui envoient beaucoup de requêtes rapprochées. Pour un EA classique, restez en mode synchrone : le code est plus simple et le retcode est disponible immédiatement après l’appel.

Bonnes pratiques avec CTrade

Un objet par EA, réglé une seule fois. Déclarez l’objet en variable globale et réglez-le dans OnInit. Le magic number s’applique alors à toutes les requêtes, y compris les modifications et fermetures.

Plusieurs objets si plusieurs stratégies. Un EA qui gère deux stratégies avec deux magic numbers peut utiliser deux objets CTrade, chacun avec son propre réglage.

Ne pas compter sur les valeurs par défaut. Fixez explicitement la déviation et le mode de remplissage. Sur certains symboles, le mode de remplissage incorrect produit le code 10030 (TRADE_RETCODE_INVALID_FILL).

Combiner avec les classes d’information. La bibliothèque standard fournit aussi CPositionInfo (#include <Trade\PositionInfo.mqh>, méthodes SelectByIndex, SelectByTicket, Magic, PriceOpen, StopLoss…) et CSymbolInfo (#include <Trade\SymbolInfo.mqh>, méthodes RefreshRates, LotsMin, LotsStep, StopsLevel, NormalizePrice…). Elles complètent CTrade pour lire positions et symboles. La bibliothèque standard est présentée dans la rubrique MQL5 avancé.

Journaliser les refus. ResultRetcodeDescription() et ResultComment() donnent un texte exploitable dans le journal ; ajoutez-y le symbole, le volume et les prix demandés.

CTrade simplifie l’écriture mais ne protège pas votre compte : un volume mal calculé ou un stop absent est envoyé tel quel. Le trading avec effet de levier comporte un risque élevé de perte ; validez chaque modification sur un compte de démonstration.

FAQ

Pourquoi trade.Buy renvoie-t-il true alors qu’aucune position n’est ouverte ?

Parce que true signifie uniquement que les structures ont passé la vérification de base. Le serveur a pu refuser la requête : lisez ResultRetcode() et ResultRetcodeDescription() pour connaître la raison.

Faut-il passer le prix à Buy et Sell ?

Ce n’est pas obligatoire : avec price=0.0, la documentation indique que la méthode utilise le prix Ask courant pour Buy et Bid pour Sell. Passer le prix lu juste avant permet en revanche de calculer les stops sur la même cotation.

Quelle différence entre PositionOpen et Buy ?

Buy et Sell sont des raccourcis avec des paramètres par défaut. PositionOpen attend explicitement le symbole, le type d’ordre (ORDER_TYPE_BUY ou ORDER_TYPE_SELL), le volume, le prix et les stops ; elle est pratique quand le sens est une variable.

CTrade fonctionne-t-elle dans un script ?

Oui, la classe s’utilise dans tout programme autorisé à trader, Expert Advisor ou script, du moment que le trading algorithmique est autorisé dans le terminal.

A

Alix · fondateur d’OptiBot Trading

Développeur MQL5 et ProBuilder, spécialiste du backtest et de l’optimisation de stratégies automatiques. Chaque contenu est vérifié sur la documentation officielle (MQL5.com, manuels ProRealTime) et testé avant publication. Notre méthode éditoriale.