Lorsqu’on développe plusieurs Expert Advisors (EAs) pour MetaTrader 5, une frustration revient souvent : la duplication de code. Vous avez écrit une fonction de gestion des risques parfaite pour un EA, et vous devez la recopier dans le suivant. Non seulement c’est fastidieux, mais cela augmente aussi le risque d’erreurs et rend la maintenance plus complexe. Heureusement, MQL5 offre une solution élégante : la création de librairies. Une librairie MQL5 est un fichier séparé (extension .mq5) qui contient des fonctions, des classes ou des procédures que vous pouvez importer dans n’importe quel EA ou indicateur. Dans cet article, nous allons vous montrer comment créer votre propre librairie pour réutiliser votre code efficacement, en suivant une méthode structurée et professionnelle. Vous apprendrez à organiser vos fonctions, à les compiler en une bibliothèque dynamique (.ex5) et à les appeler depuis plusieurs projets, tout en respectant les bonnes pratiques du langage MQL5.

1. Comprendre le concept de librairie en MQL5

Avant de coder, il est essentiel de comprendre ce qu’est une librairie en MQL5 et comment elle se distingue d’un simple include. Une librairie (ou bibliothèque) est un fichier compilé séparément, portant l’extension .ex5, qui contient des fonctions exportables. Contrairement à un fichier include (.mqh) qui est littéralement copié dans le code source lors de la compilation, une librairie est liée dynamiquement à votre EA. Cela signifie que le code de la librairie n’est pas intégré dans l’EA, mais appelé au moment de l’exécution. L’avantage principal est la modularité : vous pouvez mettre à jour la librairie sans avoir à recompiler tous les EAs qui l’utilisent (à condition de respecter l’interface). Pour créer une librairie, vous devez utiliser le mot-clé `#property library` en haut de votre fichier. Ensuite, chaque fonction que vous souhaitez rendre accessible depuis l’extérieur doit être précédée du mot-clé `export`. Par exemple :

//+------------------------------------------------------------------+
//|                                          MyTradingLibrary.mq5    |
//|                                 Copyright 2024, YourName         |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property library
#property copyright "Copyright 2024, YourName"
#property link      "https://www.mql5.com"
#property version   "1.00"

// Fonction exportée : calcul du lot basé sur le risque
double CalculateLotByRisk(double riskPercent, double stopLossPoints) export
  {
   double accountBalance = AccountInfoDouble(ACCOUNT_BALANCE);
   double tickValue = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
   double lotStep = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
   double lot = (accountBalance * riskPercent / 100) / (stopLossPoints * tickValue);
   lot = MathFloor(lot / lotStep) * lotStep;
   return(MathMax(lot, SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN)));
  }
//+------------------------------------------------------------------+

Dans cet exemple, la fonction `CalculateLotByRisk` est exportée. Elle pourra être appelée depuis n’importe quel EA après avoir importé la librairie. Notez que le fichier doit être compilé (F7) pour générer le fichier .ex5 correspondant dans le dossier `\MQL5\Libraries\`.

2. Structurer sa librairie : fonctions de trading et de gestion des risques

Une librairie bien conçue doit regrouper des fonctions par thématique. Pour un trader algorithmique, les catégories les plus utiles sont souvent la gestion des risques, les calculs de lots, les fonctions de gestion des ordres (ouverture, modification, fermeture) et les utilitaires de trading (récupération de données de marché, calculs de volatilité, etc.). L’objectif est de créer un ensemble de fonctions génériques et paramétrables que vous pourrez appeler dans tous vos EAs. Voici une structure recommandée pour une librairie de trading :

//+------------------------------------------------------------------+
//|                                                   TradeUtils.mq5 |
//|                                                    Votre société  |
//+------------------------------------------------------------------+
#property library
// Inclure les fichiers nécessaires
#include <Trade\Trade.mqh>
#include <Trade\PositionInfo.mqh>
#include <Trade\AccountInfo.mqh>

//---- Fonctions de gestion des risques
double CalculateLotByRiskPercent(double riskPercent, double stopLossPoints) export;
double CalculateLotByFixedRisk(double riskAmount, double stopLossPoints) export;

//---- Fonctions d'ouverture de positions
bool OpenBuyOrder(double lot, double sl, double tp, string comment) export;
bool OpenSellOrder(double lot, double sl, double tp, string comment) export;

//---- Fonctions de gestion des positions
bool CloseAllPositions() export;
bool ModifyStopLoss(ulong ticket, double newSL) export;

//---- Fonctions utilitaires
double GetATR(int period, int shift) export;
bool IsNewBar() export;
//+------------------------------------------------------------------+

Ensuite, vous implémentez chaque fonction dans le même fichier. Par exemple, la fonction `OpenBuyOrder` pourrait utiliser la classe `CTrade` de MQL5 pour envoyer un ordre. En encapsulant ces actions dans votre librairie, vous créez une API (interface de programmation) cohérente. Vos EAs n’auront plus qu’à appeler `TradeUtils::OpenBuyOrder(0.1, 100, 200, “Buy”)` sans se soucier des détails d’implémentation. Cela rend votre code plus lisible et plus facile à maintenir.

3. Compiler et placer la librairie dans le bon dossier

Une fois votre code écrit, la compilation est une étape cruciale. Dans MetaEditor (l’IDE de MetaTrader), ouvrez votre fichier .mq5 de librairie et appuyez sur F7. Si tout est correct, deux fichiers sont générés : un fichier .ex5 dans le dossier `\MQL5\Libraries\` et un fichier .mqh dans le dossier `\MQL5\Include\` (si vous avez coché l’option “Créer un fichier include”). Le fichier .ex5 est la librairie compilée que vos EAs utiliseront. Le fichier .mqh est un fichier d’en-tête qui contient les déclarations des fonctions exportées. Vous pouvez l’utiliser pour importer les fonctions dans votre EA. Voici comment procéder : dans votre EA, utilisez la directive `#import` pour lier la librairie. Par exemple :

//+------------------------------------------------------------------+
//|                                                   MyExpert.mq5  |
//+------------------------------------------------------------------+
#import "TradeUtils.ex5"
   double CalculateLotByRiskPercent(double riskPercent, double stopLossPoints);
   bool   OpenBuyOrder(double lot, double sl, double tp, string comment);
   bool   OpenSellOrder(double lot, double sl, double tp, string comment);
   bool   CloseAllPositions();
   double GetATR(int period, int shift);
   bool   IsNewBar();
#import
//+------------------------------------------------------------------+

Alternativement, vous pouvez inclure directement le fichier .mqh généré avec `#include `. Cette seconde méthode est souvent plus pratique car elle évite de recopier les signatures des fonctions. Assurez-vous que le fichier .ex5 se trouve bien dans le dossier `\MQL5\Libraries\` de votre plateforme MetaTrader 5. Si vous utilisez plusieurs terminaux, vous devrez copier la librairie dans chacun d’eux.

4. Importer et utiliser la librairie dans plusieurs EAs

L’avantage principal d’une librairie est de pouvoir l’utiliser dans une multitude d’EAs sans duplication de code. Une fois votre librairie `TradeUtils.ex5` créée et placée dans le dossier `Libraries`, vous pouvez l’appeler depuis n’importe quel EA. Voici un exemple concret d’utilisation dans un EA simple :

//+------------------------------------------------------------------+
//|                                               SimpleScalper.mq5 |
//+------------------------------------------------------------------+
#include <TradeUtils.mqh>

input double RiskPercent = 1.0; // Risque en % du capital
input int    StopLossPoints = 50; // Stop Loss en points

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   // Calcul du lot basé sur le risque
   double lot = CalculateLotByRiskPercent(RiskPercent, StopLossPoints);
   if(lot <= 0)
     {
      Print("Erreur de calcul du lot");
      return(INIT_FAILED);
     }
   // Ouvrir un ordre d'achat
   if(OpenBuyOrder(lot, StopLossPoints, 2*StopLossPoints, "Scalp Buy"))
     {
      Print("Ordre ouvert avec succès, lot: ", lot);
     }
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+

Dans cet EA, nous n’avons pas redéfini les fonctions de calcul de lot ou d’ouverture d’ordre. Elles sont importées depuis la librairie. Si vous devez modifier la logique de calcul du lot (par exemple, pour inclure un pourcentage de risque différent), vous n’aurez qu’à modifier la librairie, la recompiler, et tous les EAs qui l’utilisent bénéficieront automatiquement de la mise à jour. C’est un gain de temps considérable, surtout lorsque vous gérez une dizaine d’EAs.

5. Mise à jour et maintenance de votre librairie

La maintenance d’une librairie est un processus continu. À mesure que vous développez de nouveaux EAs, vous identifierez probablement de nouvelles fonctions à ajouter. Par exemple, vous pourriez vouloir ajouter une fonction pour calculer un trailing stop basé sur l’ATR. Pour mettre à jour votre librairie, ouvrez le fichier .mq5, ajoutez votre nouvelle fonction avec le mot-clé `export`, recompilez (F7) et le nouveau fichier .ex5 remplacera l’ancien. Important : si vous modifiez la signature d’une fonction existante (par exemple, en ajoutant un paramètre), vous devrez recompiler tous les EAs qui l’utilisent. Pour éviter cela, adoptez une stratégie de versioning. Par exemple, conservez les anciennes fonctions et créez des nouvelles versions avec des noms différents (ex : `CalculateLotByRiskV2`). Cela garantit la rétrocompatibilité. Enfin, documentez votre librairie. Ajoutez des commentaires en haut de chaque fonction expliquant son rôle, ses paramètres et sa valeur de retour. Vous pouvez même créer un fichier PDF ou une page HTML dédiée. Une librairie bien documentée est un atout précieux, surtout si vous travaillez en équipe ou si vous souhaitez partager votre code avec la communauté MQL5.

Besoin d’un EA sur-mesure ? Demander un devis gratuit