La puissance de MetaTrader 5 : du débogage pas à pas à la protection des fichiers EX5 dans un environnement unifié

Introduction

Dans le monde du trading algorithmique, une idée de trading n’est que le point de départ. La véritable valeur d’un produit commence à se révéler non pas lors de l’écriture de la première ligne de code, mais au cours des cycles répétés d’amélioration, de validation et de préparation à une utilisation réelle.

De nombreux développeurs considèrent encore MetaEditor comme un éditeur de texte avancé. Depuis des années, ils utilisent des méthodes de débogage manuelles : remplir les journaux avec des milliers d’instructions Print, passer des heures à inspecter visuellement les fichiers texte et deviner les causes des slippages, des faux signaux ou des boucles figées. Cette approche transforme le développement en un processus de recherche chaotique et non systématique où la ressource la plus précieuse — le temps — est constamment gaspillée. La fiabilité du code dans ce processus reste incertaine.

La mise en place d’un système de trading automatisé nécessite bien plus qu’un environnement de développement pratique et un langage de programmation puissant. Il requiert également des outils de débogage et d’étalonnage.

Le système de développement et de trading MetaTrader 5 offre une norme fondamentalement différente. La puissance de la plateforme réside non seulement dans l’expressivité du langage MQL5, hérité du C++ orienté objet, mais aussi dans la rapidité avec laquelle un développeur peut parcourir l’ensemble du flux de travail : « Détection des bugs → Correction des problèmes → Optimisation de la vitesse d’exécution → Protection de l’application .ex5 finale ».

Au cœur de ce processus se trouve MetaEditor, un environnement de développement intégré (IDE) complet qui couvre chaque étape du cycle de vie du développement d’applications MQL5. MetaEditor inclut des outils spécialisés pour chaque étape de la chaîne :

• débogage pas à pas à l’aide de ticks réels ;
• profilage matériel du temps d’exécution du code ;
• intégration directe avec les DLL C++ pour accélérer les calculs critiques en termes de performances ;
• protection cryptographique basée sur le cloud pour le code binaire.

Il ne s’agit pas simplement d’un ensemble de fonctionnalités pratiques, mais d’un écosystème de développement soigneusement conçu qui réduit le temps de développement et minimise le risque d’échec lors de la mise en œuvre d’idées de trading.

Dans cet article, nous allons parcourir le cycle de vie complet de la création d’un robot de trading : configuration du projet, débogage de la logique du programme, identification des goulots d’étranglement des performances, isolation des calculs mathématiques intensifs dans une DLL C++ et enfin protection de la propriété intellectuelle avec MQL5 Cloud Protector.

À titre d’exemple pratique, nous allons développer notre propre indicateur basé sur les Bandes de Bollinger, qui sont incluses dans le package du terminal MetaTrader 5. Nous ajouterons la visualisation des signaux, des paramètres interactifs et des calculs de performance des transactions virtuelles. Vous pourrez ensuite utiliser cet indicateur comme base pour tester vos propres idées.

Figure 1 : de l’idée au profit

Indicateur de test : exigences du projet

Nous allons développer un indicateur de test pour le débogage et le profilage. L’indicateur offrira les fonctionnalités suivantes :

• Affichage des flèches de signal d’achat/vente et des points de Stop Loss/Take Profit ;
• Utilisation de l’indicateur standard des Bandes de Bollinger (BB) pour générer des signaux ;
• Deux modes de signal pris en charge : l’inversion à partir des limites supérieures/inférieures des BB et la cassure des limites des BB.

Mode d’inversion :

• Si la barre clôture au-dessus de la limite supérieure des BB, génère un signal de vente, fixe le Take Profit à la ligne médiane des BB et le Stop Loss à la même distance que le Take Profit ;
• Si la barre clôture en dessous de la limite inférieure des BB, génère un signal d’achat, fixe le Take Profit à la ligne médiane des BB et fixe le Stop Loss à la même distance que le Take Profit.

Mode de cassure :

• Inverse les signaux d’achat et de vente, ainsi que les niveaux de Take Profit et de Stop Loss.

Un seul signal d’entrée peut rester actif jusqu’à ce que le Take Profit ou le Stop Loss soit atteint. Ensuite, le cycle de suivi du signal et d’affichage des flèches recommence.

Si un signal opposé apparaît à la clôture de la barre, la position doit s’inverser.

Conditions pratiques supplémentaires :

• Ignorer les premières heures d’une nouvelle journée de trading (nombre d’heures configurable) ;
• Ne pas effectuer de transactions durant la dernière heure avant la fermeture du marché ;
• Clôturer toutes les positions à la fin de la journée de trading (l’heure de clôture est configurable).

Affichage des signaux sur le graphique :

• Achat — flèche verte vers le haut ;
• Vente — flèche rouge vers le bas ;
• Stop Loss — croix jaune ;
• Take Profit — croix bleue.

Le résultat de l’exécution de l’indicateur est présenté ci-dessous :

Figure 2 : signaux de l’indicateur de test

Le code source complet de l’indicateur est disponible dans le fichier BB_Signal_Indicator.mq5 joint à cet article.

Configuration du projet : les fondements du développement et du débogage

Commençons par les bases : une bonne organisation du projet. Préparer l’environnement de développement à l’avance permet de gagner un temps considérable avant même d’exécuter votre premier test.

Tout projet sérieux ne commence pas par l’écriture de code, mais par la mise en place de l’environnement adéquat pour ce code. En tant qu’IDE complet, MetaEditor fournit des outils pour automatiser les tâches de routine, permettant aux développeurs de se concentrer sur la logique plutôt que sur les paramètres et les configurations des graphiques. Examinons les composantes clés qui constituent la base d’un développement efficace.

Création d’un projet : d’un fichier unique à un système

L’utilisation de fichiers .mq5 individuels est acceptable lors du prototypage, mais un développement sérieux nécessite un projet.

Un projet est un fichier distinct avec l’extension .mqproj qui stocke les paramètres du programme, les paramètres de compilation et les informations sur tous les fichiers associés. Pour une gestion de projet simplifiée, un onglet dédié est prévu dans le Navigateur. Tous les fichiers, tels que les fichiers inclus, les ressources, les headers et autres, sont classés par catégories dans cet onglet.

Comment créer un projet à partir d’un fichier source :

• dans la fenêtre Navigateur, sélectionnez le fichier MQ5 existant (BB_Signal_Indicator.mq5 dans notre cas)
• faites un clic droit et choisissez « Nouveau projet à partir de la source » dans le menu contextuel.

Un fichier .mqproj sera automatiquement créé dans le même répertoire :

Figure 3 : création d’un projet à partir d’un fichier source

Ce qu’un projet apporte :

• Une gestion centralisée de tous les fichiers du programme ;
• Un suivi automatique des dépendances (#include, #resource) ;
• Des paramètres de compilation distincts, indépendants du code source ;
• Un contrôle des versions et un suivi des modifications.

L’assistant vous permet également de créer des projets vides. Il s’agit d’une fonctionnalité utile pour les projets de développement non standard avec des structures de fichiers spécifiques pour lesquelles les modèles par défaut ne conviennent pas. Dans ce cas, seul un fichier de configuration .mqproj vide est créé. Les fichiers sources devront être ajoutés manuellement ultérieurement.

Notes

• Si le projet est créé à partir d’un fichier source existant, le nom du projet est hérité de ce fichier ; Si vous créez un nouveau projet, vous serez invité à spécifier manuellement son nom.
• Il est également recommandé de créer un répertoire dédié pour stocker tous les fichiers et dossiers du projet.

Propriétés du projet : configuration centralisée

Les paramètres du projet sont accessibles depuis le menu contextuel du projet, via Propriétés. Cette boîte de dialogue remplace la modification manuelle des directives #property dans le code source.

Figure 4 : propriétés du projet

Principales propriétés :

• Type de programme — définit le type de module exécutable généré lors de la compilation ;

• Projet CPU — permet de sélectionner soit le jeu d’instructions standard (X64 Regular), soit les jeux d’instructions CPU étendus utilisés lors de la compilation ;

• Droits d’auteur — informations relatives aux droits d’auteur, équivalent à #property copyright dans le code source ;
• Lien — un lien vers le site web du développeur, équivalent à #property link dans le code source ;
• Version — version du programme, équivalent à #property version dans le code source ;
• Icône — icône du programme, équivalent à #property icon dans le code source ;
• Description — description du programme, équivalent à #property description.

Paramètres d’optimisation et de performance :

• Optimisation maximale — les applications compilées sans optimisation compilent plus rapidement mais s’exécutent plus lentement. Désactivez l’optimisation pendant le débogage si nécessaire, mais activez-la pour les versions de production.
• Vérifier les diviseurs à virgule flottante — la désactivation des vérifications des diviseurs améliore légèrement les performances car les erreurs de division par zéro ne sont plus vérifiées lors de l’exécution.
• Utiliser le cache d’optimisation (pour les Expert Advisors) — pendant l’optimisation, le Testeur de Stratégie stocke les résultats dans un cache. Les résultats sont enregistrés pour chaque ensemble de paramètres d’entrée. Relancer l’optimisation avec des paramètres identiques permet à MetaTrader 5 de réutiliser les résultats mis en cache au lieu de les recalculer. L’exception concerne les calculs mathématiques, pour lesquels de nouveaux calculs peuvent être nécessaires indépendamment des entrées de cache existantes. Dans ce cas, désactivez l’option « Utiliser le cache d’optimisation » dans les paramètres du projet. Même lorsque la mise en cache est désactivée, les résultats des tests sont toujours stockés afin que tous les passages effectués restent disponibles dans les rapports du Testeur de Stratégie.

Propriétés de l’indicateur :

• « Calculer l’indicateur à chaque tick du testeur » — force les indicateurs à se calculer à chaque tick entrant. Cette option n’affecte que les opérations effectuées dans le Testeur de Stratégie. Dans un environnement réel de trading, les indicateurs sont systématiquement recalculés à chaque tick.

Toutefois, lors du test d’un Expert Advisor utilisant des indicateurs, le Testeur de Stratégie ne calcule les valeurs des indicateurs que lorsque l’EA demande explicitement des données de la mémoire tampon de l’indicateur. Cela accélère considérablement les tests et l’optimisation lorsque l’Expert Advisor n’a pas besoin des valeurs de l’indicateur à chaque tick. Si votre indicateur nécessite des calculs à chaque tick, activez cette option.

Les indicateurs sont également recalculés de force à chaque tick dans les cas suivants :

• le mode de test visuel est activé
• l’indicateur utilise EventChartCustom(), OnChartEvent() ou OnTimer()
• l’indicateur a été compilé avec une version antérieure à 1916

Note

Les propriétés du projet prévalent toujours sur les propriétés spécifiées dans le code source. Si des paramètres sont définis à la fois dans le projet et dans le code source (même avec des valeurs différentes), ce sont les paramètres du projet qui seront utilisés.

Gestion des fichiers de projet dans le Navigateur

Ajout automatique de fichiers :

• les fichiers inclus via #include apparaissent automatiquement sous Dépendances dans le Navigateur
• les fichiers d’en-tête apparaissent sous Headers
• les ressources (images, sons, etc.) incluses via #resource apparaissent sous Ressources.
• les fichiers sources MQ5 apparaissent sous Sources.

Ajout manuel de fichiers :

• il est également possible d’ajouter des fichiers manuellement via le menu contextuel du projet, en choisissant « Ajouter un fichier existant » ou « Ajouter un dossier existant ». La commande « Ajouter un dossier existant » vous permet d’ajouter en masse tous les fichiers compatibles d’un répertoire sélectionné au projet.

Figure 5 : ajout manuel de fichiers

Note

Lorsqu’un fichier est ajouté manuellement, il n’est pas automatiquement inclus dans le code du programme et n’est pas copié dans le répertoire du projet. Le fichier est simplement lié au projet afin qu’il apparaisse dans le Navigateur de projet.

Les fichiers peuvent être supprimés via le menu contextuel du projet en sélectionnant Effacer sur le fichier souhaité. Lors de la suppression d’un fichier du projet, le système propose deux options :

• « Enlever » — exclut le fichier du projet tout en le conservant sur le disque dur
• « Supprimer » — supprime définitivement le fichier du projet et du disque dur

Soyez prudent lorsque vous supprimez des fichiers. La suppression accidentelle d’un fichier source peut entraîner une perte définitive de code.

Sections supplémentaires :

• paramètres et fichiers — cette section permet d’ajouter des fichiers auxiliaires tels que des configurations de test ou des modèles de graphiques

Utilisation du modèle debug.tpl

De nombreux développeurs négligent le fichier nommé debug.tpl situé dans le répertoire du terminal \profiles\templates. Il s’agit d’une occasion manquée importante qui réduit l’efficacité du développement et des tests. Voici comment cela fonctionne : lorsque le débogage est lancé (touche F5), MetaEditor crée un graphique temporaire dans le terminal MetaTrader 5. Si un fichier debug.tpl existe dans le dossier des modèles, le terminal applique automatiquement ses paramètres à ce graphique.

L’avantage pratique est que vous pouvez préconfigurer ce modèle avec tous les indicateurs, niveaux, paramètres de grille et propriétés de graphique requis. Par exemple, si votre robot utilise les Bandes de Bollinger pour ses transactions, il vous suffit d’ajouter l’indicateur au modèle. À chaque lancement du débogage, le graphique sera déjà entièrement configuré et inclura l’indicateur, éliminant ainsi toute configuration manuelle.

Étant donné que l’appui sur la touche F5 pendant le débogage est une opération constante tout au long du développement, cela simplifie considérablement le flux de travail.

Préconfiguration de l’environnement de débogage

Les paramètres de l’environnement de débogage se trouvent dans MetaEditor, sous : « Outils → Options → Débogage/Profil ». Configurez les paramètres par défaut qui seront utilisés à chaque lancement du débogueur.

Figure 6 : paramètres de l’environnement de débogage

Principaux paramètres de débogage et de profilage :

• Symbole — spécifiez l’instrument de trading pour lequel votre application est conçue (par exemple, EURUSD) et la période utilisée par la stratégie (par exemple, H1 pour les systèmes à moyen terme) ;
• Date — lors du débogage sur les données historiques, vous pouvez définir directement l’intervalle de temps souhaité. Les tests visuels dans le Testeur de Stratégie seront exécutés sur cet intervalle ;
• Activer l’optimisation pendant le profilage — lors de la recherche de goulots d’étranglement, désactivez l’optimisation pour voir clairement quelles lignes de code consomment le plus de temps d’exécution. N’oubliez pas que les métriques de performance obtenues différeront des versions finales. Pour les tests de performance finaux, réactivez l’optimisation ;
• Activer l’intégration en ligne (« inlining ») lors du profilage — lorsque l’intégration en ligne est activée, le code de la fonction est inséré directement dans le point d’appel, ce qui améliore considérablement la vitesse d’exécution. Cependant, cela complique le profilage des fonctions. Pour obtenir des rapports de profilage plus propres, désactivez l’intégration ;
• Utiliser le mode visuel pour le débogage des données historiques — par défaut, le débogage historique s’exécute en mode non visuel dans le Testeur de Stratégie, mais cette option permet d’activer manuellement le mode visuel. Le profilage des données historiques est toujours effectué en mode non visuel.

Le profilage des données historiques en mode visuel est généralement inutile car la plupart des ressources système sont consacrées au rendu des graphiques plutôt qu’à l’exécution de la logique MQL. Pour tester les fonctionnalités graphiques (panneaux, objets, interfaces, etc.), le mode temps réel est généralement suffisant puisque le programme s’exécute directement sur un graphique normal.

• Utiliser les paramètres spécifiés — active ou désactive certains paramètres de débogage et de profilage. Lorsque cette option est activée, le programme est lancé avec le symbole et la période sélectionnés. Le débogage historique utilise également ces paramètres pour les tests visuels. Si cette option est désactivée, les champs ci-dessous ne seront plus modifiables.

Si aucun symbole ni période n’est spécifié dans l’onglet Débogage/Profil, MetaEditor utilise par défaut le premier symbole de la fenêtre du Market Watch et la période H1.

Compilation : erreurs et avertissements

Appuyer sur F7 compile le code source en un fichier exécutable .ex5. Lors de la compilation, l’onglet Boîte à Outils/Erreurs de MetaEditor peut afficher deux types de messages :

• Erreurs — problèmes critiques empêchant la création du fichier .ex5 ;
• Avertissements — sections de code susceptibles de provoquer des problèmes d’exécution (par exemple, l’utilisation d’une variable non initialisée). Le fichier .ex5 est toujours généré, mais des avertissements sont émis.

Il ne faut pas ignorer les avertissements. La meilleure pratique lors de l’utilisation de MetaEditor consiste à considérer un code comme prêt à être testé uniquement lorsque le nombre d’avertissements est égal à zéro (et naturellement, le nombre d’erreurs est également égal à zéro). Les options de compilation dans les paramètres du projet peuvent imposer cette discipline en traitant les avertissements comme des erreurs, obligeant ainsi les développeurs à éliminer les ambiguïtés du code avant l’exécution.

Une fois que tous les fichiers du projet sont correctement organisés, que les paramètres de débogage et de profilage sont configurés, que les modèles sont préparés et que le compilateur produit une version propre sans erreurs ni avertissements, il est temps de passer à l’étape la plus importante : identifier et corriger les erreurs logiques à l’aide du débogueur intégré.

Débogage pas à pas : examinez votre code au microscope

À l’étape précédente, nous avons créé la structure du projet et ajouté tous les fichiers nécessaires, mais la logique de l’algorithme n’existe encore qu’en théorie. Le débogage pas à pas dans MetaEditor vous permet d’examiner l’intérieur d’un programme en cours d’exécution, de suspendre l’exécution à tout moment et d’inspecter l’état actuel et les valeurs des variables. Voyons comment utiliser le débogueur intégré pour tester la logique d’un programme MQL5.

MetaEditor prend en charge deux modes de débogage : le débogage en temps réel et le débogage historique. Sa flexibilité provient de son intégration poussée avec le terminal de trading et le Testeur de Stratégie. Chaque mode résout des problèmes différents :

1. Débogage sur des données en temps réel

Ce mode se lance en appuyant sur F5 sur un graphique dédié dans le terminal MetaTrader 5, qui reçoit des ticks en direct du serveur du courtier. Le graphique s’ouvre automatiquement en utilisant les paramètres du modèle debug.tpl. Ce mode est idéal pour tester les réactions du robot ou de l’indicateur aux événements du marché en direct, pour vérifier la gestion des événements d’interface (OnChartEvent) ou pour tester les événements de minuterie (OnTimer).

En résumé, il s’agit du programme exécuté en direct. Vous observez en temps réel comment le code réagit aux ticks entrants. Il existe cependant un inconvénient : la vitesse de débogage est limitée par la vitesse réelle à laquelle arrivent les ticks du marché.

Lorsqu’un Expert Advisor est lancé dans ce mode, le mot « Débogage » apparaît à côté de son nom dans le coin supérieur droit du graphique, indiquant que le graphique fonctionne en mode débogage.

2. Débogage sur les données historiques

Ce mode se lance en utilisant Ctrl+F5 dans le Testeur de Stratégie. Les ticks historiques enregistrés sont transmis séquentiellement à l’Expert Advisor ou à l’indicateur, rejouant l’historique du marché sur l’intervalle sélectionné. Il s’agit du mode principal de validation de la logique de trading. Il vous permet d’exécuter des algorithmes sur des années de données historiques en quelques minutes et de détecter des situations rares (telles que des gaps ou des événements de forte volatilité).

Les paramètres de MetaEditor permettent également d’activer le mode visuel pour visualiser le graphique pendant le débogage en utilisant l’option « Utiliser le mode visuel pour le débogage des données historiques » située dans l’onglet Débogage/Profil.


Points d’arrêt : arrêtez-vous et réfléchissez

L’élément central du débogage est le point d’arrêt. Un point d’arrêt est un marqueur placé sur une ligne de code source indiquant à MetaEditor/MetaTrader 5 de suspendre l’exécution lorsque cette ligne est atteinte. Les points d’arrêt peuvent être activés ou désactivés en double-cliquant sur la marge grise à côté du numéro de ligne ou en appuyant sur F9 avec le curseur sur la ligne souhaitée.

Pourquoi utiliser des points d’arrêt ? Au lieu d’essayer de deviner plus tard où et pourquoi une erreur s’est produite, vous pouvez inspecter de manière proactive les sections critiques du code (telles que les calculs de taille de lot ou la génération de signaux de trading). L’exécution s’interrompt avant l’exécution de la ligne marquée, ce qui vous permet d’inspecter les variables d’entrée et les valeurs intermédiaires, de lire le contenu des chaînes de caractères, etc. Autrement dit, vous pouvez vérifier si les variables contiennent bien les valeurs attendues.

Navigation dans le code : exécution pas à pas

Une fois l’exécution suspendue, le développeur obtient un contrôle quasi total sur le programme. La seule chose impossible est de modifier le code à la volée. MetaEditor propose trois commandes principales pour l’exécution pas à pas :

• Entrer Dans — en appuyant sur F11. Exécute une ligne de code. Si la ligne contient un appel de fonction, le débogueur entre dans cette fonction et s’arrête à sa première ligne. Vous pouvez ensuite continuer à parcourir le corps de la fonction ligne par ligne en appuyant sur F10 ou F11.
• Passer — en appuyant sur F10. Exécute une ligne de code. Si la ligne contient un appel de fonction, le débogueur exécute la fonction entière sans y entrer et s’arrête à la ligne suivante.
• Sortir — en appuyant sur Shift+F11. Exécute la partie restante de la fonction en cours et s’arrête immédiatement après le retour au code appelant.

Outils d’analyse du code : pile d’appels et fenêtre d’observation

Suspendre l’exécution ne suffit pas. Vous devez également comprendre l’état actuel du programme. Cela se fait via l’onglet Debug de la Boîte à Outils.

Figure 7 : outils d’analyse du code

La pile d’appels (fenêtre Pile d’appels de la figure 7) affiche l’historique d’exécution du programme. Elle montre la chaîne de fichiers et de fonctions qui a mené au point d’arrêt actuel. L’entrée supérieure de la pile d’appels correspond à la fonction en cours d’exécution. Sur la figure 7, il s’agit de la fonction OnCalculate(). L’entrée inférieure correspond au point d’entrée. Sur la figure 7, il s’agit à nouveau de la fonction OnCalculate() — elles coïncident dans ce cas. La première colonne de la liste de la pile d’appels affiche le nom du fichier, tandis que la dernière colonne affiche le numéro de ligne.

Un double-clic sur n’importe quelle fonction dans la pile d’appels déplace instantanément le curseur de l’éditeur à la ligne où cette fonction a été appelée. C’est indispensable pour analyser des programmes complexes comportant des appels de fonctions profondément imbriqués.

La fenêtre d’observation (fenêtre Watch de la figure 5) permet de surveiller les valeurs des variables en temps réel. Pour ajouter une variable à la liste d’observation, sélectionnez-la dans le code et appuyez sur Shift+F9 (ou choisissez Ajouter un Espion dans le menu contextuel) : la variable est alors ajoutée à la liste. Après chaque pas d’exécution (F10 ou F11), les variables observées sont actualisées. Les valeurs modifiées sont mises en évidence pour plus de commodité.

Outre les valeurs et les noms, la fenêtre d’observation affiche également les types des variables. Pour les tableaux, la liste indique la dimension et l’attribut de série temporelle (Series), s’il est spécifié.

Vous pouvez saisir des expressions simples comme a+b directement dans la liste d’observation et voir immédiatement le résultat sans modifier le code source. Les listes extensibles permettent de visualiser le contenu des structures et des tableaux.

Le débogueur intégré de MetaEditor transforme le débogage en un processus analytique structuré. Vous contrôlez le temps (exécution historique ou en temps réel), gérez l’espace (via la pile d’appels) et visualisez l’état (via l’inspection des variables). Cela permet de trouver et de corriger beaucoup plus rapidement les erreurs logiques dans les programmes.

Mais une fois que le programme fonctionne correctement, une autre question se pose : Est-il assez rapide ? Si le code fonctionne mais que ses performances sont médiocres, l’outil suivant de l’arsenal de MetaEditor devient indispensable : le profileur.

Identifier les goulots d’étranglement avec le profileur, ou comment améliorer les performances d’un programme

Dans la plupart des cas, les problèmes de performance sont dus à un code inefficace. C’est là que le profileur devient indispensable : un outil qui mesure le temps d’exécution de chaque fonction, et même de chaque ligne de code.

Avant de profiler la vitesse d’exécution, assurez-vous que les optimisations du compilateur sont désactivées. Dans MetaEditor, ouvrez Outils/Options et accédez à l’onglet Débogage/Profil. Pourquoi est-ce important ? Par défaut, le compilateur optimise le code : il supprime les variables inutiles, fusionne des groupes d’opérations et applique l’intégration en ligne (inlining) des fonctions.

Si le profilage porte sur du code optimisé, les résultats deviennent difficiles à interpréter, car la structure et la séquence d’exécution réelles ne correspondent plus à ce que vous voyez dans l’éditeur. Le profileur doit travailler sur du code « honnête ».

Profilage sur les données en temps réel

Pour les programmes fonctionnant en temps réel, la vitesse d’exécution est d’une importance capitale. MetaEditor offre un moyen pratique d’évaluer le coût d’exécution de différentes sections de code. Pour ce faire, lancez le profilage du code et laissez le programme s’exécuter pendant un certain temps. Pour profiler un indicateur, quelques minutes suffisent généralement.

Le profilage est lancé sur un graphique spécial via le menu de MetaEditor : Debug/Lancer le profilage sur les données réelles. Cela permet d’évaluer la réactivité de l’interface ou le traitement des ticks entrants.

Notes

• Après le lancement, laissez le robot fonctionner assez longtemps pour que toutes les fonctions critiques soient exécutées : initialisation, calculs des indicateurs, opérations de trading. Si une fonction n’est jamais appelée, elle n’apparaîtra pas dans le rapport.

• Pour une précision maximale, il est recommandé de ne pas arrêter le débogage en appuyant sur Arrêter (Shift+F5). Supprimez plutôt l’Expert Advisor ou l’indicateur directement du graphique. Cela garantit l’arrêt correct de tous les processus et assure que les statistiques de profilage sont correctement enregistrées.

  

Profilage sur les données historiques

Le profilage sur l’historique est lancé via la commande de menu de MetaEditor : Debug/Lancer le profilage sur les données historiques. Dans ce mode, le profilage s’exécute au sein du Testeur de Stratégie. Il s’agit du mode principal de détection des goulots d’étranglement, car il permet de tester très rapidement le programme sur de larges intervalles historiques.

Analyse des résultats

Une fois le profilage terminé, les résultats apparaissent dans l’onglet Profiler de la Boîte à Outils. Deux métriques clés sont affichées pour chaque fonction :

• Activité CPU totale (Total CPU) — indique le pourcentage de temps passé par une fonction dans la pile d’appels. Cela inclut l’exécution de la fonction elle-même et le temps passé dans toutes les fonctions qu’elle appelle.
• Activité CPU propre (Self CPU) — indique le pourcentage de temps consacré à l’exécution des seules commandes de la fonction elle-même, hors appels imbriqués.

Figure 8 : résultats du profilage en temps réel — Fonctions par Appels

Comprendre les résultats du profilage

Examinons la figure 8. Les trois fonctions marquées de flèches vertes présentent les niveaux d’activité les plus élevés. Il s’agit de gestionnaires d’événements (identifiés par l’icône f→) utilisés par l’indicateur. Ce sont OnInit(), OnDeinit(), OnCalculate(). Les deux premières fonctions présentent des valeurs proches de zéro, tant pour l’activité totale que pour l’activité propre. C’est normal, car elles ne s’exécutent qu’à l’initialisation et à l’arrêt. Elles accomplissent des tâches relativement simples :

• OnInit() configure les tampons de l’indicateur et crée un handle pour l’indicateur standard Bandes de Bollinger ;
• OnDeinit() — libère le handle des Bandes de Bollinger et efface la chaîne de commentaire.

La troisième fonction, OnCalculate(), présente une activité totale de 99,9 %. C’est également normal. Une fois que OnInit() s’est terminé avec succès, l’indicateur passe la quasi-totalité de sa durée de vie à traiter les ticks entrants, le temps de traitement étant donc consacré à cette fonction.

Cependant, malgré son activité totale extrêmement élevée, OnCalculate() présente une activité propre très faible de 0,23 %. Cela nous indique que la fonction elle-même est rapide, mais qu’elle appelle en interne une autre fonction beaucoup plus lente. Donc, si une optimisation est nécessaire, il ne faut pas optimiser OnCalculate() elle-même, mais ce qu’elle appelle.

Pour approfondir l’analyse, basculez l’affichage du profileur sur « Fonctions par Lignes » :

Figure 9 : résultats du profilage en temps réel — Fonctions par Lignes

La figure 9 montre que la ligne présentant l’activité totale la plus élevée contient trois appels à la fonction standard de copie des tampons d’indicateur : CopyBuffer(...). Il s’agit d’une fonction système. Elle est rapide en elle-même, mais elle appelle en interne des fonctions du noyau du terminal. Nous ne pouvons pas optimiser l’implémentation interne du terminal, mais nous pouvons réduire la quantité de données transférées (barres). Dans notre cas, cependant, ce point est déjà optimisé, car seules les barres non traitées les plus récentes sont copiées.

Nous pouvons donc conclure que notre indicateur simple est déjà implémenté de manière assez efficace.

Exportation des données

Pour une analyse plus poussée, les résultats du profilage peuvent être exportés aux formats Open XML (Excel), HTML ou CSV. C’est utile pour comparer les performances de différentes versions d’un algorithme ou pour conserver un historique des optimisations du projet.

Mais que faire si vous identifiez dans le programme un goulot d’étranglement qui ne peut plus être optimisé avec MQL5 seul ? Par exemple, que faire si des calculs statistiques complexes ou des opérations cryptographiques prennent encore trop de temps, même après une optimisation poussée ? Dans ce cas, il est nécessaire de sortir du « bac à sable » de MetaEditor. Voyons comment intégrer la puissance du C++ directement dans un projet MQL5.

Intégration C++ : quand MQL5 cède la place au code natif

MQL5 permet de déplacer les composants critiques pour les performances dans des bibliothèques dynamiques (DLL) écrites en C++. Si nécessaire, vous pouvez transférer les parties critiques pour les performances vers du code C++ natif afin de gagner en vitesse d’exécution. C’est là que MetaEditor montre son caractère unique en tant qu’environnement de développement, en supprimant de fait la frontière entre les langages.

La migration vers le C++ ne doit pas devenir une fin en soi. Il s’agit d’un compromis entre la complexité de la maintenance et la vitesse d’exécution. Utilisez cette approche si :

• le profileur montre qu’une fonction consomme une quantité disproportionnée de ressources CPU et ne peut pas être simplifiée sur le plan algorithmique ;
• vous devez utiliser des solutions toutes faites (par exemple, des bibliothèques d’apprentissage automatique ou des packages mathématiques spécialisés) qui n’ont pas d’équivalent en MQL5.

Améliorons notre indicateur expérimental en y ajoutant le calcul et l’affichage de statistiques de trading virtuel. La date de début des calculs sera spécifiée via les paramètres d’entrée de l’indicateur. La version mise à jour de l’indicateur est présentée ci-dessous :

Figure 10 : indicateur de test avec calculs statistiques

Le code source complet est disponible dans le fichier BB_Signal_Stat_Indicator_V2.mq5 joint à cet article.

Passons maintenant l’indicateur au profileur :

Figure 11 : profilage de l’indicateur avec calculs statistiques sur l’historique

Une nouvelle fonction statistique apparaît : CalculateVirtualStats(). Supposons que nous décidions de la déplacer dans une DLL en vue d’extensions futures et de calculs plus avancés dans les versions commerciales de l’application. Dans ce cas, la mise à jour du moteur statistique nécessite uniquement le remplacement de la bibliothèque DLL sans avoir à recompiler l’intégralité du projet.

MetaEditor en tant qu’éditeur C++

De nombreux développeurs ignorent que MetaEditor ne se limite pas à MQL. Il peut travailler avec les fichiers source C++ (.cpp et .h) aussi facilement qu’avec les fichiers .mq5. Comment créer une bibliothèque dans MetaEditor :

• Créez un fichier .cpp dans le dossier de votre projet (par exemple, dans la section Libraries).
• Écrivez le code de la fonction. Il est important d’utiliser la convention d’appel __stdcall ou __cdecl afin que MQL5 puisse interagir correctement avec la bibliothèque.
• Appuyez sur F7 (Compiler). MetaEditor fait automatiquement appel à un compilateur externe et génère le fichier DLL. Pour la compilation C++, MetaEditor utilise Microsoft Visual Studio installé sur votre ordinateur (Visual Studio 2008 ou version ultérieure, y compris les éditions Express et Community).

L’architecture de Visual Studio doit correspondre à celle de votre installation de MetaEditor : vous avez donc besoin de la version 64 bits de Microsoft Visual Studio. MetaTrader 5 et MetaEditor ne prennent en charge que les systèmes d’exploitation Windows 64 bits.

Pour importer des fonctions d’une DLL dans du code MQL5, utilisez la déclaration suivante :

//+------------------------------------------------------------------+
//| Import function from DLL                                         |
//+------------------------------------------------------------------+
#import "StatsCalculator.dll"
   void CalculateStatsDLL(const TradeRecord &p_history[],int p_trade_count,double initial_balance,VStatResult &res);
#import

Ici, une seule fonction est importée : CalculateStatsDLL(). Cette fonction calcule les statistiques de trading à partir des transactions virtuelles fournies. Les résultats sont renvoyés via la structure VStatResult &res, qui est remplie en interne dans la DLL.

Dans le code de l’indicateur, la fonction statistique d’origine doit être remplacée par :

//+------------------------------------------------------------------+
//| Wrapper for DLL function call                                    |
//+------------------------------------------------------------------+
void CalculateVirtualStats(const TradeRecord &p_history[],int p_trade_count,double initial_balance,VStatResult &res)
  {
   //--- validate trade count (comparing arrays with NULL is prohibited in MQL5)
   if(p_trade_count<=0) return;
   CalculateStatsDLL(p_history,p_trade_count,initial_balance,res);
  }

Une vérification supplémentaire garantit que le tableau des transactions n’est pas vide, offrant ainsi une protection supplémentaire contre les erreurs d’exécution. Le code source complet de l’indicateur utilisant l’implémentation DLL est disponible dans le fichier BB_Signal_Stat_Indicator_DLL.mq5 joint à cet article.

Une fois l’algorithme débogué, ses performances optimisées et les composants critiques transférés en C++, la dernière étape commence : la protection du produit fini. Dans le trading algorithmique commercial, le code source de la stratégie est l’actif principal.

Protection du fichier EX5 final : un bouclier dans le cloud pour la propriété intellectuelle

Bien que le format exécutable EX5 soit déjà très résistant à la décompilation, la distribution commerciale nécessite des garanties supplémentaires. C’est là qu’intervient le service MQL5 Cloud Protector. Il offre un niveau de protection encore plus élevé.

Comment fonctionne la protection : une cryptographie sans compromis

De nombreux développeurs se méfient des services de protection dans le cloud, car ils craignent des fuites de code source. MQL5 Cloud Protector a été spécifiquement conçu pour éliminer entièrement ces risques.

• Compilation locale : Le programme est d’abord compilé en un fichier EX4/EX5 sur la machine locale de l’utilisateur. Une protection supplémentaire est appliquée uniquement au fichier exécutable compilé — le code source n’est jamais transmis nulle part.
• Transmission de données binaires uniquement : Seule la partie exécutable du fichier est envoyée via une connexion sécurisée au service en ligne, où elle est chiffrée à l’aide d’algorithmes asymétriques modernes et signée avec une clé privée unique.
• Compilation et chiffrement natifs : Côté serveur, un chiffrement asymétrique moderne est appliqué. Le code est transformé en code machine natif — le même type de protection que celui utilisé dans le MetaTrader Market. La seule différence est que le fichier obtenu n’est pas lié à un ordinateur spécifique. Il peut s’exécuter sur n’importe quelle machine, comme une application EX4/EX5 standard.

Ce niveau de protection rend la rétro-ingénierie et la modification du programme EX5 pratiquement impossibles.

Intégration de la protection dans le fichier exécutable : la norme commerciale

Pour créer un exécutable avec une protection supplémentaire, ouvrez le projet ou le fichier source MQL principal et exécutez Outils → MQL5 Cloud Protector. Cela lance une séquence automatique de compilation et de traitement dans le cloud. Le fichier exécutable final est créé dans le même répertoire que le projet ou que le fichier source MQ5 principal.

Figure 12 : intégration de la protection dans l’exécutable

MQL5 Cloud Protector répond à trois besoins majeurs liés à la distribution commerciale :

• prévention de la décompilation ;
• distribution flexible ;
• préservation, voire amélioration, des performances — contrairement aux techniques d’obfuscation, la compilation native dans le cloud maintient ou améliore la vitesse d’exécution grâce à une optimisation au niveau des instructions machine.

La protection du fichier exécutable final constitue la conclusion logique du cycle de développement décrit au début de cet article. Avec MQL5 Cloud Protector, votre produit évolue du prototype à une solution commerciale sécurisée, prête à être déployée à grande échelle.

Conclusion

Dans le trading algorithmique moderne — où la concurrence se mesure en millisecondes et où le coût d’une erreur peut égaler un dépôt entier — la qualité du développement dépend de la sophistication des outils maîtrisés par le programmeur et le trader algorithmique. Nous avons parcouru l’intégralité du cycle de vie d’une application MQL5 : de l’idée initiale à la protection cryptographique finale du produit fini.

La principale conclusion est claire : MetaEditor est un argument tout aussi convaincant en faveur du choix de MetaTrader 5 que le langage MQL5 lui-même. Un langage de programmation définit ce qui peut être construit. Un environnement de développement définit la rapidité, la fiabilité et l’efficacité avec lesquelles il peut être construit. MetaEditor apporte structure et discipline au processus de codage :

• le débogueur intégré remplace les conjectures interminables et l’analyse des journaux par une inspection précise des piles d’appels et des états/valeurs des variables ;
• le profileur fournit des métriques de performance objectives, remplaçant les impressions subjectives par des chiffres ;
• l’intégration avec le C++ via des DLL supprime les limitations d’un langage de haut niveau pour les tâches nécessitant d’importants calculs ;
• MQL5 Cloud Protector résout le problème de la protection de la propriété intellectuelle, rendant la distribution commerciale des algorithmes à la fois sûre et légitime.

Un développeur qui maîtrise tous ces outils raccourcit le chemin entre l’idée et sa mise en œuvre et acquiert un avantage concurrentiel significatif. Et l’ensemble du flux de travail se gère depuis une seule interface, celle de MetaEditor.

Ressources recommandées pour apprendre MetaEditor et MetaTrader 5 :

• Rubriques d’aide de MetaEditor : Débogage, Profilage, DLL C++ et Cloud Protector.
• Article : Comment développer et déboguer rapidement une stratégie de trading

Liste des pièces jointes :

Nom du fichier	Description
BB_Signal_Ind.mq5	Code d’un indicateur de test qui affiche les signaux sous forme de flèches sur un graphique
BB_Signal_Stat_Indicator_V1.mq5	Code d’un indicateur de test qui affiche les signaux sous forme de flèches ainsi que des statistiques de trading virtuel
BB_Signal_Stat_Indicator_V2.mq5	Code d’un indicateur de test qui affiche les signaux sous forme de flèches, des statistiques de trading virtuel et une courbe de solde
BB_Signal_Stat_Indicator_DLL.mq5	Code d’un indicateur de test qui affiche les signaux sous forme de flèches, des statistiques de trading virtuel et une courbe de solde, et qui utilise également une bibliothèque DLL
StatsCalculator.zip	Code de création d’une DLL de calcul des statistiques de trading virtuel dans Visual Studio 2019