MQL4 · Migration MQL5
Convertir un EA MQL4 en MQL5 : la méthode de portage en six étapes
Inventaire, couche d’abstraction, remplacement des appels, compilation, comparaison des transactions : une méthode éprouvée pour porter un EA MQL4 vers MQL5 sans perdre son comportement en chemin.
Convertir un EA MQL4 en MQL5 ne consiste pas à ouvrir le fichier .mq4 dans MetaEditor 5 et à corriger les erreurs de compilation une par une jusqu’à ce qu’il n’en reste plus. Cette approche donne un programme qui compile, mais dont le comportement s’écarte souvent de l’original sans que l’on sache où ni pourquoi. La méthode décrite ici procède autrement : elle isole d’abord ce qui doit changer, remplace ces éléments de façon contrôlée, puis vérifie que le comportement est conservé en comparant les transactions des deux versions.
Elle suppose que vous connaissez les différences de fond entre les deux langages, présentées dans Différences entre MQL4 et MQL5. Chaque remplacement technique est détaillé dans sa propre page de la rubrique Migrer de MQL4 vers MQL5.
Étape 1 : établir une version de référence
Avant de toucher au code, assurez-vous de disposer d’une version MQL4 stable, compilée sans avertissement sous #property strict (voir #property strict), et d’un backtest de référence sur une période et un symbole connus. Exportez la liste des transactions de ce backtest : heure d’ouverture, sens, volume, prix, heure et motif de fermeture. C’est cette liste qui servira de juge de paix.
Si l’EA utilise encore les anciennes fonctions init(), start() et deinit(), remplacez-les dès maintenant par OnInit(), OnTick() et OnDeinit() dans la version MQL4, et vérifiez que le backtest reste identique. Chaque modification faite côté MQL4, où vous pouvez comparer à l’original sur la même plateforme, est une modification de moins à faire à l’aveugle côté MQL5.
Étape 2 : faire l’inventaire
Recherchez dans le code tous les appels qui devront être remplacés. Une recherche textuelle dans MetaEditor suffit :
- trading :
OrderSend,OrderModify,OrderClose,OrderDelete,OrderSelect,OrdersTotal,OrdersHistoryTotal, et toutes les fonctionsOrder...()qui lisent les propriétés d’un ordre ; - indicateurs :
iMA,iRSI,iMACD,iBands,iATR,iCustomet les autres fonctionsi...avec leur paramètre de décalage ; - séries :
Open[,High[,Low[,Close[,Time[,Volume[,Bars; - prix et propriétés :
Bid,Ask,MarketInfo,RefreshRates; - compte :
AccountBalance,AccountEquity,AccountFreeMarginet les autres fonctionsAccount...(); - erreurs : tous les tests sur des codes numériques de trading (129, 130, 138…).
Comptez les occurrences. Un EA où ces appels sont dispersés sur des centaines de lignes demandera davantage de travail qu’un EA qui les regroupe déjà dans quelques fonctions.
Étape 3 : créer une couche d’abstraction dans MQL4
C’est l’étape qui fait gagner le plus de temps. Regroupez chaque catégorie d’appels dans des fonctions dédiées, toujours dans la version MQL4 : GetBid(), GetAsk(), MaValue(shift), CountPositions(magic), OpenBuy(lots, sl, tp), CloseAll(magic)… Remplacez dans le reste du code tous les appels directs par ces fonctions, puis vérifiez que le backtest MQL4 reste identique.
À l’issue de cette étape, la logique de l’EA ne dépend plus directement de l’API MQL4. Le portage se réduit à réécrire le corps de ces quelques fonctions en MQL5.
//+------------------------------------------------------------------+
//| Couche d'abstraction : version MQL4 |
//+------------------------------------------------------------------+
#property strict
input int InpMaPeriod = 50;
input int InpMagic = 20240;
double GetBid() { RefreshRates(); return Bid; }
double GetAsk() { RefreshRates(); return Ask; }
double MaValue(const int shift)
{
return iMA(_Symbol, 0, InpMaPeriod, 0, MODE_SMA, PRICE_CLOSE, shift);
}
double ClosePrice(const int shift) { return iClose(_Symbol, 0, shift); }
int CountPositions()
{
int n = 0;
for(int i = OrdersTotal() - 1; i >= 0; i--)
if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES)
&& OrderMagicNumber() == InpMagic && OrderSymbol() == _Symbol
&& OrderType() <= OP_SELL) // OP_BUY (0) ou OP_SELL (1)
n++;
return n;
}
bool OpenBuy(const double lots)
{
int ticket = OrderSend(_Symbol, OP_BUY, lots, NormalizeDouble(GetAsk(), _Digits),
5, 0, 0, "", InpMagic, 0, clrNONE);
if(ticket < 0) Print("OpenBuy : erreur ", GetLastError());
return ticket >= 0;
}
//--- la logique n'utilise que la couche d'abstraction
void OnTick()
{
if(CountPositions() == 0 && ClosePrice(1) > MaValue(1))
OpenBuy(0.10);
}
Remarquez l’utilisation de _Symbol, _Digits et iClose : ces éléments existent dans les deux langages, ce qui réduit encore les différences entre les deux versions.
Étape 4 : réécrire la couche en MQL5
Créez un nouveau fichier .mq5, copiez-y la logique de l’EA telle quelle, et réécrivez uniquement les fonctions de la couche d’abstraction. Voici la même couche en MQL5 :
//+------------------------------------------------------------------+
//| Couche d'abstraction : version MQL5 |
//+------------------------------------------------------------------+
#include <Trade\Trade.mqh>
input int InpMaPeriod = 50;
input int InpMagic = 20240;
CTrade trade;
int g_maHandle = INVALID_HANDLE;
int OnInit()
{
g_maHandle = iMA(_Symbol, _Period, InpMaPeriod, 0, MODE_SMA, PRICE_CLOSE);
if(g_maHandle == INVALID_HANDLE) return INIT_FAILED;
trade.SetExpertMagicNumber(InpMagic);
trade.SetDeviationInPoints(5);
return INIT_SUCCEEDED;
}
void OnDeinit(const int reason) { IndicatorRelease(g_maHandle); }
double GetBid() { return SymbolInfoDouble(_Symbol, SYMBOL_BID); }
double GetAsk() { return SymbolInfoDouble(_Symbol, SYMBOL_ASK); }
double MaValue(const int shift)
{
double buf[1];
if(CopyBuffer(g_maHandle, 0, shift, 1, buf) != 1) return 0.0;
return buf[0];
}
double ClosePrice(const int shift) { return iClose(_Symbol, _Period, shift); }
int CountPositions()
{
int n = 0;
for(int i = PositionsTotal() - 1; i >= 0; i--)
{
ulong ticket = PositionGetTicket(i); // sélectionne la position
if(ticket == 0) continue;
if(PositionGetInteger(POSITION_MAGIC) == InpMagic
&& PositionGetString(POSITION_SYMBOL) == _Symbol)
n++;
}
return n;
}
bool OpenBuy(const double lots)
{
if(!trade.Buy(lots, _Symbol))
{
Print("OpenBuy : retcode ", trade.ResultRetcode());
return false;
}
return trade.ResultRetcode() == TRADE_RETCODE_DONE;
}
void OnTick()
{
if(CountPositions() == 0 && ClosePrice(1) > MaValue(1))
OpenBuy(0.10);
}
La fonction OnTick() est identique dans les deux versions : c’est tout l’intérêt de la méthode. Les détails de chaque remplacement sont expliqués dans Des ordres MQL4 aux positions MQL5 et Des fonctions iXXX aux handles.
Étape 5 : compiler et corriger les détails
Compilez la version MQL5 et corrigez les messages restants. Ils concernent généralement des détails : conversions de type plus strictes, constantes de période, fonctions Account...() à remplacer par AccountInfoDouble(ACCOUNT_BALANCE) ou AccountInfoDouble(ACCOUNT_EQUITY), codes d’erreur numériques à remplacer par des codes de retour. Ne passez à l’étape suivante qu’avec zéro erreur et zéro avertissement.
Étape 6 : comparer les transactions
Lancez un backtest MQL5 sur le même symbole et la même période que la référence MQL4, en mode « Open prices only » si votre EA ne travaille que sur les bougies clôturées, ce qui limite l’influence de la modélisation des ticks. Comparez ensuite les deux listes de transactions : nombre de trades, dates d’entrée, sens. De petits écarts de prix sont normaux, car les données des deux serveurs ne sont pas identiques ; des trades manquants ou supplémentaires signalent en revanche une différence de logique à comprendre. La page Testeur MT4 contre testeur MT5 détaille les sources d’écart légitimes.
Organiser le travail
Pour un EA de taille moyenne, procédez fonction par fonction et non fichier par fichier. Portez d’abord les fonctions de lecture (prix, propriétés, séries, indicateurs), vérifiez avec des Print qu’elles renvoient les mêmes valeurs que la version MQL4 sur quelques bougies du même historique, puis seulement les fonctions de trading. Cette progression vous permet de localiser immédiatement l’origine d’un écart : si les valeurs lues concordent mais que les trades diffèrent, le problème se trouve dans la couche de trading ou dans la logique de décision, pas dans les données.
Conservez aussi un journal des choix effectués pendant le portage : traitement du netting, gestion des codes de retour, valeur du glissement. Ces décisions ne sont pas visibles dans le code final et seront précieuses lors des évolutions futures de l’EA.
Pièges fréquents
- Netting : sur un compte en netting, deux achats successifs ne créent pas deux positions mais une seule position agrandie. Un EA qui compte ses positions pour limiter son exposition doit en tenir compte.
- Décalage de 1 : un
CopyBuffermal paramétré renvoie la valeur d’une autre bougie que celle attendue. Vérifiez la bougie lue avec quelquesPrintcomparés au graphique. - Handles créés à chaque tick : appeler
iMAdansOnTicken MQL5 crée potentiellement une nouvelle instance d’indicateur à chaque appel. Créez les handles dansOnInit. - Valeurs de retour ignorées :
trade.Buypeut renvoyertruealors que le serveur a refusé la requête ; testez aussiResultRetcode().
Questions fréquentes
Existe-t-il un convertisseur automatique de MQL4 vers MQL5 ?
Il existe des outils et des bibliothèques de compatibilité, mais aucun ne garantit un comportement identique, notamment pour le modèle ordres/positions. La méthode par couche d’abstraction donne un code MQL5 propre que vous maîtrisez.
Faut-il garder la version MQL4 après la migration ?
Oui, au moins le temps de la validation. Elle sert de référence pour comparer les transactions et pour comprendre tout écart de comportement.
Par quoi commencer : les ordres ou les indicateurs ?
Par la couche d’abstraction dans MQL4, qui regroupe les deux. Ensuite, les indicateurs et les séries sont généralement les plus simples à porter ; le modèle de trading demande le plus d’attention.
Faut-il porter les commentaires et les noms de paramètres ?
Oui, gardez les mêmes noms de paramètres input dans les deux versions : vous pourrez ainsi appliquer les mêmes réglages et comparer les backtests sans risque de confusion.
Pourquoi tester en mode « Open prices only » pour comparer ?
Parce que ce mode réduit l’influence des différences de modélisation des ticks entre MT4 et MT5. Il n’est pertinent que si l’EA prend ses décisions à la clôture des bougies.
