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é.
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 ;trueetResultRetcode()égal àTRADE_RETCODE_DONE(10009) : requête exécutée ;trueetTRADE_RETCODE_PLACED(10008) : ordre placé (cas normal des ordres en attente) ;trueet 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éthode | Rô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)etPositionModify(ticket, sl, tp): modification des stops ;PositionClose(symbol, deviation=ULONG_MAX)etPositionClose(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.
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.
- Ordres, positions et transactions : le modèle de MT5
- Comptes netting ou hedging
- OrderSend et MqlTradeRequest
- OrderCheck : vérifier un ordre avant envoi
- Ouvrir une position au marché
- Ordres limites et stop
- Placer et modifier stop loss et take profit
- Coder un trailing stop
- Passer une position à break-even
- Fermer une position (totale ou partielle)
- Parcourir et filtrer les positions
- Le magic number
- Lire l’historique des ordres et transactions
- OnTradeTransaction : réagir aux événements de trading
- Modes de remplissage (FOK, IOC, Return)
- Gérer spread et slippage dans un EA
- Calculer et normaliser la taille de lot
