MQL4 · Migration MQL5
Des ordres MQL4 aux positions MQL5 : porter la gestion des trades
OrderSelect, OrdersTotal et OrderClose n’ont pas d’équivalent direct en MQL5 : positions, ordres en attente et transactions sont séparés. Correspondances, code de portage et piège du netting.
En MQL4, tout ce qui touche au trading passe par la notion d’ordre : une position ouverte est un ordre de type OP_BUY ou OP_SELL, un ordre limite est un ordre de type OP_BUYLIMIT, et tous se parcourent avec la même boucle OrdersTotal() / OrderSelect(). En MQL5, cette unité disparaît. MetaTrader 5 distingue les ordres (instructions, dont les ordres en attente), les transactions ou *deals* (exécutions) et les positions (expositions ouvertes). Chaque entité a ses propres fonctions.
C’est le chantier le plus délicat d’une migration, parce qu’il ne s’agit pas seulement de renommer des fonctions : le modèle change, et avec lui certaines hypothèses de votre EA. Cette page donne les correspondances, un code de portage complet et les pièges à connaître, en particulier celui du mode netting.
Le modèle MQL5 en trois entités
- Ordre : une demande adressée au serveur. Un ordre au marché est exécuté presque immédiatement et disparaît de la liste des ordres actifs ; un ordre en attente y reste jusqu’à son déclenchement, son annulation ou son expiration. En MQL5,
OrdersTotal()ne compte que ces ordres actifs, essentiellement les ordres en attente, et non les positions. - Transaction (deal) : l’exécution d’un ordre, qui ouvre, augmente, réduit ou ferme une position. Les transactions sont dans l’historique.
- Position : l’exposition ouverte sur un symbole, avec son volume, son prix moyen, son stop et son objectif.
PositionsTotal()les compte.
Un même achat au marché produit donc un ordre (dans l’historique), une transaction d’entrée (dans l’historique) et une position (active). Le modèle complet est décrit dans la page MQL5 consacrée aux ordres, positions et transactions.
Netting et hedging : la question à poser en premier
MetaTrader 5 propose deux modes de gestion des positions sur les comptes de type forex et CFD :
- en hedging, plusieurs positions indépendantes peuvent coexister sur un même symbole, y compris en sens opposé, comme en MT4 ;
- en netting, il n’existe qu’une position par symbole : un achat supplémentaire augmente la position, une vente la réduit, la ferme ou la retourne.
Le mode se lit avec AccountInfoInteger(ACCOUNT_MARGIN_MODE), qui renvoie ACCOUNT_MARGIN_MODE_RETAIL_HEDGING, ACCOUNT_MARGIN_MODE_RETAIL_NETTING ou ACCOUNT_MARGIN_MODE_EXCHANGE. Un EA MQL4 qui ouvre plusieurs trades indépendants sur un symbole (pyramidage, grille, couverture) ne fonctionnera comme prévu qu’en hedging. En netting, sa logique doit être repensée : il n’y a plus qu’un seul stop et un seul objectif par symbole. Les deux modes sont comparés en détail dans Netting ou hedging.
Table des correspondances
| Besoin | MQL4 | MQL5 |
|---|---|---|
| Compter les positions ouvertes | OrdersTotal() puis filtrer OP_BUY/OP_SELL | PositionsTotal() |
| Sélectionner une position par indice | OrderSelect(i, SELECT_BY_POS) | PositionGetTicket(i) |
| Sélectionner une position par ticket | OrderSelect(t, SELECT_BY_TICKET) | PositionSelectByTicket(t) |
| Lire volume, prix, stop | OrderLots(), OrderOpenPrice(), OrderStopLoss() | PositionGetDouble(POSITION_VOLUME / POSITION_PRICE_OPEN / POSITION_SL) |
| Lire type et magic | OrderType(), OrderMagicNumber() | PositionGetInteger(POSITION_TYPE / POSITION_MAGIC) |
| Ouvrir au marché | OrderSend(..., OP_BUY, ...) | trade.Buy(...) ou OrderSend(request, result) |
| Modifier SL/TP | OrderModify(...) | trade.PositionModify(ticket, sl, tp) |
| Fermer | OrderClose(...) | trade.PositionClose(ticket) |
| Fermer partiellement | OrderClose avec un volume partiel | trade.PositionClosePartial(ticket, volume) |
| Ordres en attente | OrdersTotal() puis filtrer les types en attente | OrdersTotal(), OrderGetTicket(i), OrderGetInteger(...) |
| Supprimer un ordre en attente | OrderDelete(ticket) | trade.OrderDelete(ticket) |
| Historique | OrdersHistoryTotal(), MODE_HISTORY | HistorySelect(début, fin), HistoryDealsTotal(), HistoryDealGetTicket(i) |
Les méthodes citées appartiennent à la classe CTrade de la bibliothèque standard, incluse avec #include <Trade\Trade.mqh>. Elle n’est pas obligatoire, mais elle évite de remplir à la main les structures MqlTradeRequest.
Exemple : la même routine dans les deux langages
Voici une routine typique : fermer toutes les positions de l’EA sur le symbole courant, puis supprimer ses ordres en attente.
//+------------------------------------------------------------------+
//| MQL4 : fermer les positions et supprimer les ordres de l'EA |
//+------------------------------------------------------------------+
void CloseAllMql4(const int magic)
{
for(int i = OrdersTotal() - 1; i >= 0; i--) // boucle descendante
{
if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) continue;
if(OrderMagicNumber() != magic || OrderSymbol() != Symbol()) continue;
RefreshRates();
if(OrderType() == OP_BUY)
{ if(!OrderClose(OrderTicket(), OrderLots(), Bid, 5, clrNONE)) Print("err ", GetLastError()); }
else if(OrderType() == OP_SELL)
{ if(!OrderClose(OrderTicket(), OrderLots(), Ask, 5, clrNONE)) Print("err ", GetLastError()); }
else
{ if(!OrderDelete(OrderTicket())) Print("err ", GetLastError()); }
}
}
//+------------------------------------------------------------------+
//| MQL5 : même routine, positions et ordres traités séparément |
//+------------------------------------------------------------------+
#include <Trade\Trade.mqh>
CTrade trade;
void CloseAllMql5(const long magic)
{
trade.SetDeviationInPoints(5);
//--- 1. positions ouvertes
for(int i = PositionsTotal() - 1; i >= 0; i--)
{
ulong ticket = PositionGetTicket(i); // sélectionne la position
if(ticket == 0) continue;
if(PositionGetInteger(POSITION_MAGIC) != magic
|| PositionGetString(POSITION_SYMBOL) != _Symbol) continue;
if(!trade.PositionClose(ticket))
PrintFormat("PositionClose #%I64u : retcode %u", ticket, trade.ResultRetcode());
}
//--- 2. ordres en attente
for(int i = OrdersTotal() - 1; i >= 0; i--)
{
ulong ticket = OrderGetTicket(i); // sélectionne l'ordre
if(ticket == 0) continue;
if(OrderGetInteger(ORDER_MAGIC) != magic
|| OrderGetString(ORDER_SYMBOL) != _Symbol) continue;
if(!trade.OrderDelete(ticket))
PrintFormat("OrderDelete #%I64u : retcode %u", ticket, trade.ResultRetcode());
}
}
Plusieurs différences sautent aux yeux. Les positions et les ordres en attente sont parcourus dans deux boucles distinctes. Le prix de clôture n’est plus fourni par le code : PositionClose utilise le prix courant. Le ticket est un ulong et non plus un int. Et l’erreur se lit avec ResultRetcode() plutôt qu’avec GetLastError().
Les pièges du portage
Le magic number doit être déclaré
En MQL4, le magic number est un paramètre de chaque OrderSend. Avec CTrade, il se fixe une fois pour toutes avec trade.SetExpertMagicNumber(magic), généralement dans OnInit(). L’oublier produit des positions sans magic, que l’EA ne reconnaîtra plus ensuite.
OrdersTotal ne compte plus les positions
C’est l’erreur de portage la plus fréquente : un EA qui teste if(OrdersTotal() == 0) pour savoir s’il a une position ouverte continuera de compiler en MQL5, mais ce test ne compte plus que les ordres en attente. L’EA ouvrira alors une nouvelle position à chaque signal. Remplacez systématiquement ces tests par un comptage des positions.
Un succès de l’envoi n’est pas une exécution
Les méthodes de CTrade renvoient true lorsque la requête a passé les vérifications de base et a été envoyée ; le résultat réel se lit dans ResultRetcode(), qui doit valoir TRADE_RETCODE_DONE (10009) pour une exécution complète, ou TRADE_RETCODE_PLACED (10008) pour un ordre en attente placé.
Le netting change la comptabilité
Sur un compte en netting, une « fermeture partielle » se fait par une transaction de sens opposé, et le prix d’ouverture de la position devient un prix moyen après un ajout. Un EA qui calcule son risque par trade à partir de chaque ordre MQL4 doit raisonner par position agrégée.
L’historique se charge explicitement
En MQL4, l’historique visible dépend de la période affichée dans l’onglet du terminal. En MQL5, il faut appeler HistorySelect(début, fin) avant de parcourir les transactions ou les ordres de l’historique. Un comptage des pertes du jour, par exemple, commence par HistorySelect sur la journée.
Cas d’usage
Pour une limite de perte journalière, l’EA MQL4 parcourt OrdersHistoryTotal() et additionne OrderProfit() des ordres fermés du jour. En MQL5, on sélectionne l’historique du jour, on parcourt les transactions, on ne garde que les sorties (DEAL_ENTRY_OUT) de l’EA et l’on additionne leur profit, éventuellement avec les commissions et le swap. La logique est la même ; seules les briques changent. La boucle MQL4 d’origine est décrite dans OrderSelect et boucles, et la méthode générale de portage dans Convertir un EA MQL4 en MQL5. Pour l’ensemble des autres chantiers, revenez à la rubrique Migrer de MQL4 vers MQL5.
Questions fréquentes
Quel est l’équivalent de OrderSelect en MQL5 ?
Il dépend de ce que vous sélectionnez : PositionGetTicket(i) ou PositionSelectByTicket(ticket) pour une position, OrderGetTicket(i) pour un ordre en attente, HistoryDealGetTicket(i) pour une transaction de l’historique après HistorySelect.
Pourquoi OrdersTotal renvoie-t-il 0 alors que j’ai une position ouverte ?
Parce qu’en MQL5, OrdersTotal() ne compte que les ordres actifs, c’est-à-dire principalement les ordres en attente. Les positions ouvertes se comptent avec PositionsTotal().
Mon EA MQL4 ouvre plusieurs trades sur un même symbole : fonctionnera-t-il en MQL5 ?
Sur un compte en hedging, oui, avec un portage classique. Sur un compte en netting, non : les trades successifs se fondent en une seule position, avec un seul stop et un seul objectif. Il faut alors repenser la logique.
Les tickets MQL4 et MQL5 ont-ils le même type ?
Non. En MQL4, un ticket est un int ; en MQL5, les tickets d’ordres, de transactions et de positions sont des ulong. Adaptez les déclarations de variables et les formats d’affichage lors du portage.
Faut-il obligatoirement utiliser CTrade ?
Non. Vous pouvez remplir vous-même une structure MqlTradeRequest et appeler OrderSend. CTrade simplifie le code et réduit les risques d’oubli, ce qui en fait le choix le plus courant pour un portage.
