MetaTrader 5 / Experts
English Русский 中文 Español Deutsch 日本語 Português 한국어 Italiano Türkçe
Assistant MQL5 : Comment Créer un Module de Suivi des Positions Ouvertes

Assistant MQL5 : Comment Créer un Module de Suivi des Positions Ouvertes

MetaTrader 5 — Experts | 12 janvier 2022, 14:25
202 0
MetaQuotes
MetaQuotes

Introduction

MetaTrader 5 dispose d'un outil puissant pour une vérification rapide des idées du trade. C'est le générateur de stratégies du trade MQL5 Wizard. L'utilisation de l'assistant MQL5 pour la création automatique du code source des Experts Advisors est décrite dans l'"Assistant MQL5 : Article ".Création des Expert Advisors sans Programmation". L'ouverture du système de génération de code permet de compléter les classesstandard avec des classes personnalisées de signaux de trade, des systèmes de gestion de fonds et des modules de suivi.

Cet article décrit les principes d'écriture des modules de position ouverte de suivi pour leur utilisation ultérieure dans l'assistant MQL5.

Un Expert Advisor créé à l'aide de l'assistantMQL5 Wizardest basé sur quatre classes de base:

Figure 1. Structure de la classe de base CExpert

Figure 1. Structure de la classe de base CExpert.


La classe CExpert (ou sa sous-classe) est le "moteur" principal du robot de trade. L'instance de la classe CExpert comporte des instances deCExpertSignal, CExpertMoney and CExpertTrailing classes (ou leur sous-classes):

  1. CExpertSignal- est le principal générateur de signaux de trade. L'instance de la sous-classe CExpertSignal comprise dans la classeCExpert fournit à l'Expert Advisor les informations sur les possibilités d'entrée sur le marché, les niveaux d'entrée et l’implémentation d'ordonnances conservatoires sur la base d'algorithmes internes. La décision finale sur laréalisation des opérations de tradeest prise par l'Expert Advisor. Vous pouvez lire comment écrire un module de signaux de trade dans l"Assistant MQL5 : Article Comment créer un module de signaux de trading".
  2. CExpertMoney est le principal système de gestion de fonds et des risques. L'instance de la sous-classe CExpertMoney calcule les volumes de position à ouvrir et les commandes en cours à émettre La décision finale sur les volumes est prise par l'Expert Advisor. Les principes d’élaboration des modules de fonds et de gestion des risques sont décrits dans le "MQL5 Wizard : Comment Créer un Module de Gestion de Fonds et des Risques". article.
  3. CExpertTrailingest le module principal de suivi des positions ouvertes. L'instance de la sous-classe CExpertTrailing indique à l'Expert Advisor s'il est nécessaire de modifier les ordonnances conservatoires d'une position. La décision finale sur la modification de la commande est prise par l'Expert Advisor.

En plus de cela, les instances de classe suivantes sont les membres de la classeCExpert  :

  • CExpertTrade (pour effectuer des opérations de trade)
  • CIndicators (pour la gestion des indicateurs et des séries chronologiques utilisés dans le travail de l'Expert Advisor)
  • CSymbolInfo (pour obtenir les informations sur un symbole)
  • CAccountInfo (pour obtenir des informations sur l'état du compte de trade)
  • CPositionInfo (pour obtenir des informations sur les positions)
  • COrderInfo(pour obtenir des informations sur les commandes en cours)

Plus loin dans ce texte, en parlant d’ "Expert Advisor", nous entendrons une instance de la classeCExpert de sa sous-classe.

Une description plus détaillée de la classe CExpert et du processus de travail avec elle sera fournie dans un article séparé.


1. Classe de base CExpertTrailing

LeCExpertTrailing est la base du module des positions ouvertes suivantes. Pour interagir avec "l'espace extra-atmosphérique", la classe CExpertTrailingdispose d'un ensemble de méthodes virtuelles publiques :

Initialisation

 Description

virtual Init

L'initialisation de l'instance de classe permet la synchronisation des données du module avec les données de l' EA

Paramètres de validation virtuels

Validation des paramètres réglés

virtual InitIndicators

Création et initialisation de tous les indicateurs et séries chronologiques nécessaires au fonctionnement du générateur de signaux de trade

Signaux de Modification de Positions

 

virtual CheckTrailingStopLong

Génération d'un signal de modification d'une longue position avec détermination du nouveau prix pour la commande Stop

virtual CheckTrailingStopShort

Génération d'un signal de modification d'une courte position avec détermination du nouveau prix pour la commande Stop

Description des Méthodes

1.1. Méthodes d'initialisation

1.1.1 Init

La méthode Init() est automatiquement appelée juste après l'ajout de l'instance de classe à l'Expert Advisor. Il n'est pas nécessaire de remplacer la méthode.

virtual bool Init(CSymbolInfo* symbol, ENUM_TIMEFRAMES period, double adjusted_point);

1.1.2 ValidationSettings

La méthode ValidationSettings() est appelée depuis l'Expert Advisor après la configuration de tous les paramètres. Il est nécessaire de surcharger la méthode s'il existe des paramètres de configuration. 

virtual bool ValidationSettings();

La méthode surchargée doit renvoyer true si tous les paramètres sont corrects (prêts à l’emploi). Si l'un des paramètres n'est pas valide, le paramètre doit retourner false (la poursuite de l'opération est impossible).

La classe de baseCExpertTrailing ne dispose pas de paramètres qui peuvent être définis, par conséquent, la méthode renvoie toujours true sans effectuer la moindre vérification

1.1.3 InitIndicators

La méthodeInitIndicators()crée et initialise tous les indicateurs et séries chronologiques nécessaires. Il est appelé depuis l'Expert Advisor une fois tous les paramètres définis et validés. La méthode doit être surchargée si le générateur de signaux de trade utilise au moins un indicateur ou une série chronologique.

virtual bool InitIndicators(CIndicators* indicators);

Les indicateurs et/ou les séries chronologiques doivent être utilisés via le correspondant de laBibliothèque Standard. Les pointeurs de tous les indicateurs et/ou séries chronologiques doivent être ajoutés à la collection d'indicateurs de l'Expert Advisor (pointeur vers lequel est transmis en paramètre).

La méthode surchargée doit retourner true, si toutes les manipulations avec les indicateurs et/ou les séries chronologiques ont abouti (ils peuvent être utilisés). Si au moins une opération avec les indicateurs et/ou les séries chronologiques a échoué, la méthode doit renvoyer false (la poursuite de l'opération est impossible).

La classe de baseCExpertTrailing n'utilise pas d'indicateurs et de séries chronologiques, par conséquent, la méthode de classe de base renvoie toujours true sans effectuer la moindre action.


1.2. Méthodes de Vérification du Signal de Modification de Position

1.2.1 CheckTrailingStopLong

La méthodeCheckTrailingStopLong() génère un signal de modification d'une longue position , définissant un nouveau prix de la commande Stop Loss (ainsi que pour la commande Take Profit si nécessaire). Il est appelé par l'Expert Advisor pour déterminer s'il est nécessaire de modifier une longue position . Il doit être remplacé si vous souhaitez générer un signal de modification de longue position 

virtual bool CheckTrailingStopLong(CPositionInfo* position,double& sl,double& tp)

Le procédé doit mettre en œuvre l'algorithme de vérification de la condition de modification de la position longue. Si la condition est satisfaite, la variable sl (ainsi que tp, si nécessaire) doit recevoir la valeur appropriée et la méthode doit renvoyer true. Les liens vers les variables sl et tp doivent être transmis en paramètres. Si la condition n'est pas satisfaite, la méthode doit renvoyer false.

La classe de baseCExpertTrailing n'a pas d'algorithme intégré pour générer un signal de modification de longue position , donc la méthode de classe de base renvoie toujours false.

1.2.2 CheckTrailingStopShort

La méthode CheckTrailingStopShort() génère un signal de modification de courte position , déterminant un nouveau prix de la commande Stop Loss (ainsi que la commande Take Profit, si nécessaire). Il est appelé par l'Expert Advisor pour déterminer s'il est nécessaire de modifier une courte position . La méthode doit être remplacée si vous souhaitez générer un signal de modification d’une courte position.

virtual bool CheckTrailingStopShort(CPositionInfo* position,double& sl,double& tp)

La méthode doit implémenter l'algorithme de vérification de la condition de modification d'une courte position. Si la condition est satisfaite, la variable sl (ainsi que tp, si nécessaire) doit recevoir la valeur appropriée et la méthode doit renvoyer true. Les liens vers les variables sl et tp doivent être transmis en paramètres. Si la condition n'est pas satisfaite, la méthode doit renvoyer false.

La classe de baseCExpertTrailing ne dispose pas d'algorithme intégré pour générer un signal de modification de courte position , donc la méthode de classe de base renvoie toujours false.


2. Écrire Votre Propre Module pour le Suivi des Positions Ouvertes

Maintenant, après avoir passé en revue la structure de la classe de baseCExpertTrailing , vous pouvez commencer à créer votre propre module pour le suivi des positions ouvertes.

Comme mentionné ci-dessus, la classe est CExpertTrailingun ensemble de "cordes" virtuelles publiques - méthodes, à l'aide desquelles l'Expert Advisor peut connaître l'opinion du module de suivi des positions ouvertes sur la nécessité de modifier les ordonnances conservatoires.

Par conséquent, notre objectif principal est de créer notre propre classe pour suivre les positions ouvertes, en la dérivant de la classeCExpertTrailing et en surchargeant les méthodes virtuelles appropriées, en implémentant les algorithmes nécessaires.

Notre deuxième objectif (qui n'est pas moins important) -est de rendre notre classe "visible" àMQL5 Wizard Mais, tout d'abord.

2.1. Création de la Classe de Générateur de signaux de trading

Commençons.

Tout d'abord, nous créons (par exemple, en utilisant le même)MQL5 Wizard un fichier d'inclusion avec l'extension mqh.

Dans le menu Fichier sélectionnez "Créer" (ou appuyez sur la combinaison de touches Ctrl+N) et indiquez la création d'un fichier inclus :

Figure 2. Créez un fichier d'inclusion à l'aide de l'assistant MQL5..

Figure 2. Créez un fichier d'inclusion à l'aide de l'assistant MQL5.

Il convient de noter que pour que le fichier soit ensuite "détecté" parMQL5 Wizard en tant que module de positions ouvertes suiveuses, il doit être créé dans le dossier Include\Expert\.

Afin de supprimer laBibliothèque Standard , créez notre propre dossier Include\Expert\Trailing\MyTrailing, dans lequel nous créons le fichier SampleTrailing.mqh, en indiquant ces paramètres dans МQL5 Wizard :

Figure 3. Définition de l'emplacement du fichier d'inclusion. .

Figure 3. Définition de l'emplacement du fichier d'inclusion.

À la suite deMQL5, nous obtenons le modèle suivant :

//+------------------------------------------------------------------+
//|                                               SampleTrailing.mqh |
//|                        Copyright 2010, MetaQuotes Software Corp. |
//|                                              https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2010, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
//+------------------------------------------------------------------+
//| defines                                                          |
//+------------------------------------------------------------------+
// #define MacrosHello   "Hello, world!"
// #define MacrosYear    2010
//+------------------------------------------------------------------+
//| DLL imports                                                      |
//+------------------------------------------------------------------+
// #import "user32.dll"
//   int      SendMessageA(int hWnd,int Msg,int wParam,int lParam);
// #import "my_expert.dll"
//   int      ExpertRecalculate(int wParam,int lParam);
// #import
//+------------------------------------------------------------------+
//| EX5 imports                                                      |
//+------------------------------------------------------------------+
// #import "stdlib.ex5"
//   string ErrorDescription(int error_code);
// #import
//+------------------------------------------------------------------+

Ce qui suit n'est qu'un travail "manuel". Supprimez les parties inutiles et ajoutez ce qui est nécessaire (incluez le fichier ExpertTrailing.mqh de la Bibliothèque Standard et une description de classe qui est maintenant vide).

//+------------------------------------------------------------------+
//|                                               SampleTrailing.mqh |
//|                        Copyright 2010, MetaQuotes Software Corp. |
//|                                              https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2010, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
//+------------------------------------------------------------------+
//| include files                                                    |
//+------------------------------------------------------------------+
#include <Expert\ExpertTrailing.mqh>
//+------------------------------------------------------------------+
//| Class CSampleTrailing.                                           |
//| Purpose: Class for trailing of open positions.                   |
//|             Is derived from the CExpertTrailing class.          |
//+------------------------------------------------------------------+
class CSampleTrailing : public CExpertTrailing
  {
  };
//+------------------------------------------------------------------+

Maintenant, il faut choisir les algorithmes.

Prenons l'algorithme suivant comme base de notre module de positions ouvertes suiveuses : déplacez la commande Stop à un niveau sans perte, si le prix va dans une direction requise sur une distance indiquée. Reflétez cela dans notre fichier.

//+------------------------------------------------------------------+
//|                                               SampleTrailing.mqh |
//|                        Copyright 2010, MetaQuotes Software Corp. |
//|                                              https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2010, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
//+------------------------------------------------------------------+
//| include files                                                    |
//+------------------------------------------------------------------+
#include <Expert\ExpertTrailing.mqh>
//+------------------------------------------------------------------+
//| Class CSampleTrailing.                                           |
//| Purpose: Class for trailing of open positions by                 |
//|             moving the Stop order "to the loseless level".       |
//|             Is derived from the CExpertTrailingclass.            |
//+------------------------------------------------------------------+
class CSampleTrailing : public CExpertTrailing
  {
  };
//+------------------------------------------------------------------+

Non, définissons quelles données sont nécessaires pour prendre des décisions concernant la modification des ordonnances conservatoires Dans notre cas - c'est le bénéfice d'une position modifiée en points.

Définissez la liste des paramètres d’implémentation de notre module pour le suivi des postes ouverts. Nous avons besoin de deux paramètres :

  1. Nombre de points de bénéfice de position nécessaire pour suggérer de déplacer la commande Stop à un niveau sans perte.
  2. Le niveau sans perte, c'est-à-dire le nombre de points de bénéfice que nous fixons par la commande déplacée Stop

Les paramètres du module seront stockés sur les membres de classe dont les données sont protégées. L'accès aux paramètres sera implémenté par des méthodes publiques appropriées.

Incluons ces changements dans notre fichier :

//+------------------------------------------------------------------+
//|                                               SampleTrailing.mqh |
//|                        Copyright 2010, MetaQuotes Software Corp. |
//|                                              https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2010, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
//+------------------------------------------------------------------+
//| include files                                                    |
//+------------------------------------------------------------------+
#include <Expert\ExpertTrailing.mqh>
//+------------------------------------------------------------------+
//| Class CSampleTrailing.                                           |
//| Purpose: Class for trailing of open positions                    |
//|             by moving Stop order to a lossless level.            |
//|             Is derived from the CExpertTrailing class.           |
//+------------------------------------------------------------------+
class CSampleTrailing : public CExpertTrailing
  {
protected:
   int                m_profit;             //threshold level of profit
   int                m_stop_level;         // lossless level

public:
   //--- methods of setting adjustable parameters
   void               Profit(int value)       { m_profit=value;     }
   void               StopLevel(int value)    { m_stop_level=value; }
  };
//+------------------------------------------------------------------+

Pour initialiser les paramètres ajustables avec les valeurs par défaut, nous devons ajouter le constructeur de classe.

Pour valider les paramètres, remplacez la méthode virtuelleValidationSettings(selon la description de la classe de base).

Descriptif de la classe :

//+------------------------------------------------------------------+
//|                                               SampleTrailing.mqh |
//|                        Copyright 2010, MetaQuotes Software Corp. |
//|                                              https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2010, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
//+------------------------------------------------------------------+
//| include files                                                    |
//+------------------------------------------------------------------+
#include <Expert\ExpertTrailing.mqh>
//+------------------------------------------------------------------+
//| Class CSampleTrailing.                                           |
//| Purpose: Class for trailing of open positions                    |
//|             by moving Stop order to a lossless level.            |
//|             Is derived from the CExpertTrailing class.           |
//+------------------------------------------------------------------+
class CSampleTrailing : public CExpertTrailing
  {
protected:
   int                m_profit;             // threshold level of profit
   int                m_stop_level;         // lossless level

public:
                      CSampleTrailing();
   //--- methods of setting adjustable parameters
   void               Profit(int value)       { m_profit=value;     }
   void               StopLevel(int value)    { m_stop_level=value; }
   //--- method of validating the adjustable parameters
   virtual bool        ValidationSettings();
  };
//+------------------------------------------------------------------+

Implémentation de la méthode ValidationSettings() :

//+------------------------------------------------------------------+
//| Validation of adjustable parameters.                             |
//| INPUT:  no.                                                      |
//| OUTPUT: true if parameter are correct, false - if not.           |
//| REMARK: no.                                                      |
//+------------------------------------------------------------------+
bool CSampleTrailing::ValidationSettings()
  {
   if(!CExpertTrailing::ValidationSettings())
      return(false);
//--- check wheter the Init method is called
   if(m_symbol==NULL) return(false);
//--- check parameters
   if((m_profit-m_stop_level)*m_adjusted_point<=m_symbol.StopsLevel()*m_symbol.Point() && m_profit!=0.0)
     {
      printf(__FUNCTION__+": threshold level of profit must be greater than the level of  setting of orders");
      return(false);
     }
//--- ok
   return(true);
  }

Tous les travaux préparatoires sont achevés.

Examinons à nouveau nos algorithmes plus en détail.

1. Un signal de modification d'une longue position apparaît lorsque les conditions suivantes sont remplies :

  • Les paramètres des réglages du module impliquent que la position doit être modifiée (si vous définissez Bénéfice=0, la modification ne sera pas effectuée) ;
  • La position n'a pas encore été modifiée (la commande Stop n'est pas déplacée à un niveau sans perte) ;
  • Le bénéfice de la position a dépassé un seuil défini dans les paramètres.

Dans ce cas, suggérez de modifier la commande Stop en fonction des paramètres. Pour cela, redéfinissez la méthode virtuelle CheckTrailingStopLong et remplissez-la avec la fonctionnalité correspondante.

2. Un signal de modification de courte position apparaît lorsque les conditions suivantes sont remplies :

  • Les paramètres des réglages du module impliquent que la position doit être modifiée (si vous définissez Bénéfice=0, la modification ne sera pas effectuée) ;
  • La position n'a pas encore été modifiée (la commande Stop n'est pas déplacée à un niveau sans perte) ;
  • Le bénéfice de la position a dépassé un seuil défini dans les paramètres.

Dans ce cas, suggérez de modifier la commande Stop en fonction des paramètres. Pour cela, redéfinissez la méthode virtuelleCheckTrailingStopShortet remplissez-la avec la fonctionnalité correspondante.

Descriptif de la classe :

class CSampleTrailing : public CExpertTrailing
  {
protected:
   int                m_profit;             // threshold level of profit
   int                m_stop_level;         // lossless level

public:
                      CSampleTrailing();
   //--- methods of setting adjustable parameters
   void               Profit(int value)       { m_profit=value;     }
   void               StopLevel(int value)    { m_stop_level=value; }
   //--- method of validation of adjustable parameters
   virtual bool       ValidationSettings();
   //--- methods of generation of position modification signals
   virtual bool       CheckTrailingStopLong(CPositionInfo* position,double& sl,double& tp);
   virtual bool       CheckTrailingStopShort(CPositionInfo* position,double& sl,double& tp);
  };

Implémentation des méthodes CheckTrailingStopLong et CheckTrailingStopShort :

//+------------------------------------------------------------------+
//| Check for modification of stop orders of a long position.        |
//| INPUT:  position - pointer to a position object,                 |
//|         sl       - link for a new price of stop loss order,      |
//|         tp       - link for a new price of take profit order.    |
//| OUTPUT: true if condition is satisfied, false - if not.          |
//| REMARK: no.                                                      |
//+------------------------------------------------------------------+
bool CSampleTrailing::CheckTrailingStopLong(CPositionInfo* position,double& sl,double& tp)
  {
//--- check of pointer
   if(position==NULL) return(false);
//--- check of parameter
   if(m_profit==0.0)  return(false);
//--- already in a lossless zone?
   double open=position.PriceOpen();
   if(position.StopLoss()>=open) return(false);
//--- check of profit
   sl=EMPTY_VALUE;
   tp=EMPTY_VALUE;
   if(m_symbol.Bid()-open>m_profit*m_adjusted_point)
      sl=m_symbol.NormalizePrice(open+m_stop_level*m_adjusted_point);
//---
   return(sl!=EMPTY_VALUE);
  }
//+------------------------------------------------------------------+
//| Check for modification of stop orders of a short position.       |
//| INPUT:  position - pointer to a position object,                 |
//|         sl       - link to a new price of stop loss order,       |
//|         tp       - link to a new price of take profit order.     |
//| OUTPUT: true if condition is satisfied, false - if not.          |
//| REMARK: нет.                                                     |
//+------------------------------------------------------------------+
bool CSampleTrailing::CheckTrailingStopShort(CPositionInfo* position,double& sl,double& tp)
  {
//--- check of pointer
   if(position==NULL) return(false);
//--- check of parameter
   if(m_profit==0.0)  return(false);
//--- already in a lossless zone?
   double open=position.PriceOpen();
   if(position.StopLoss()<=open) return(false);
//--- check of profit
   sl=EMPTY_VALUE;
   tp=EMPTY_VALUE;
   if(open-m_symbol.Ask()>m_profit*m_adjusted_point)
      sl=m_symbol.NormalizePrice(open-m_stop_level*m_adjusted_point);
//---
   return(sl!=EMPTY_VALUE);
  }

2.2. Rédaction d'une description de la classe créée des signaux de trading pour MQL5 Wizard

Passons maintenant à la résolution du deuxième problème. Notre module de suivi des positions ouvertes doit être "reconnu" par le générateur de stratégies de trading MQL5 Wizard.

Nous avons accompli la première condition nécessaire : nous avons placé le fichier là où il sera « trouvé » par l'assistant MQL5. Mais ce n'est pas assez. L'assistant MQL5 doit non seulement "trouver" le fichier, mais aussi le "reconnaître". Pour le faire, nous devons ajouter au texte original le descripteur de classe pour le MQL5 Wizard.

Un descripteur de classe est un bloc de commentaires composé conformément à certaines règles.

Examinons ces règles.

1. Le bloc de commentaires doit commencer par les lignes suivantes :

// wizard description start
//+------------------------------------------------------------------+
//| Description of the class                                         |

2. La ligne suivante est un descripteur de texte (ce que nous verrons dans l'assistant MQL5 lors du choix du signal) au format "//| Title=<Text> |". Si le texte est volumineux pour une ligne, vous pouvez en ajouter une ligne (mais pas plus) après. </p>

Dans notre cas, nous disposons des éléments suivants :

//| Title=Signal on the crossing of a price and the MA               |
//| entering on its back movement                                    |

3. Vient ensuite une ligne avec le type de classe indiqué au format "//| Type=<Type> |". Le champ <Type> doit disposer de la valeur Signal (en plus des signaux, l'assistant MQL5 connaît d'autres types de classes).

Écrivez:

//| Type=Trailing                                                    |

4. La ligne suivante au format "//| Name=<Name> |" est le nom bref du signal (il est utilisé par l'assistant MQL5 pour générer les noms des variables globales de l'expert).

Nous obtenons ce qui suit :

//| Name=BreakEven                                                   |

5. Le nom d'une classe est un élément important de la description. Dans la ligne au format "//| Class=<ClassNameа> |", le paramètre <ClassName> doit correspondre au nom de notre classe :

//| Class=CSampleTrailing                                            |

6. Nous ne remplissons pas cette ligne, mais elle doit être présente (il s'agit d'un lien vers la section deréférence de langue ) :

//| Page=                                                            |

7. En outre, il existe des descriptions des paramètres des réglages du module.

Il s'agit d'un ensemble de lignes (le nombre de lignes est égal au nombre de paramètres).

Le format de chaque ligne est "//| Parameter=<NameOfMethod>,<TypeOfParameter>,<DefaultValue> |".

Voici notre ensemble de paramètres :

//| Parameter=Profit,int,20                                          |
//| Parameter=StopLevel,int,0                                        |

8. Le bloc de commentaire doit se terminer par les lignes suivantes :

//+------------------------------------------------------------------+
// wizard description end

Ajoutons le descripteur au code source.

//+------------------------------------------------------------------+
//|                                               SampleTrailing.mqh |
//|                        Copyright 2010, MetaQuotes Software Corp. |
//|                                              https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2010, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
//+------------------------------------------------------------------+
//| include files                                                    |
//+------------------------------------------------------------------+
#include <Expert\ExpertTrailing.mqh>
// wizard description start
//+------------------------------------------------------------------+
//| Description of the class                                         |
//| Title=Moving a position to a lossless level                      |
//| Type=Trailing                                                    |
//| Name=BreakEven                                                   |
//| Class=CSampleTrailing                                            |
//| Page=                                                            |
//| Parameter=Profit,int,20                                          |
//| Parameter=StopLevel,int,0                                        |
//+------------------------------------------------------------------+
// wizard description end
//+------------------------------------------------------------------+
//| Class CSampleTrailing.                                           |
//| Purpose: Class for trailing of open positions                    |
//|             by moving Stop order to a lossless level.            |
//|             Is derived from the CExpertTrailing class.           |
//+------------------------------------------------------------------+
class CSampleTrailing : public CExpertTrailing
  {
protected:
   int                m_profit;             // threshold level of profit
   int                m_stop_level;         // lossless level

public:
                      CSampleTrailing();
   //--- method of setting adjustable parameters
   void               Profit(int value)       { m_profit=value;     }
   void               StopLevel(int value)    { m_stop_level=value; }
   //--- method of validation of adjustable settings
   virtual bool       ValidationSettings();
   //--- methods of generation of position modification signals
   virtual bool       CheckTrailingStopLong(CPositionInfo* position,double& sl,double& tp);
   virtual bool       CheckTrailingStopShort(CPositionInfo* position,double& sl,double& tp);
  };
//+------------------------------------------------------------------+
//| Constructor CSampleTrailing.                                     |
//| INPUT:  no.                                                      |
//| OUTPUT: no.                                                      |
//| REMARK: no.                                                      |
//+------------------------------------------------------------------+
void CSampleTrailing::CSampleTrailing()
  {
//--- setting default values
   m_profit    =20;
   m_stop_level=0;
  }
//+------------------------------------------------------------------+
//| Check of adjustable parameters.                                  |
//| INPUT:  no.                                                      |
//| OUTPUT: true if the parameters are correct, false if not.        |
//| REMARK: no.                                                      |
//+------------------------------------------------------------------+
bool CSampleTrailing::ValidationSettings()
  {
//--- what if the Init has not been called?
   if(m_symbol==NULL) return(false);
//--- check of parameters
   if((m_profit-m_stop_level)*m_adjusted_point<=m_symbol.StopsLevel()*m_symbol.Point() && m_profit!=0.0)
     {
      printf(__FUNCTION__+": threshold level of profit must be greater than the level of setting stop orders");
      return(false);
     }
//--- ok
   return(true);
  }
//+------------------------------------------------------------------+
//| Check for modification of stop orders of a long position.        |
//| INPUT:  position - pointer to a position object,                 |
//|         sl       - link for a new price of stop loss order,      |
//|         tp       - link for a new price of take profit order.    |
//| OUTPUT: true if condition is satisfied, false if not.            |
//| REMARK: no.                                                      |
//+------------------------------------------------------------------+
bool CSampleTrailing::CheckTrailingStopLong(CPositionInfo* position,double& sl,double& tp)
  {
//--- check of pointer
   if(position==NULL) return(false);
//--- check of parameters
   if(m_profit==0.0)  return(false);
//--- already in a lossless zone?
   double open=position.PriceOpen();
   if(position.StopLoss()>=open) return(false);
//--- check of profit
   sl=EMPTY_VALUE;
   tp=EMPTY_VALUE;
   if(m_symbol.Bid()-open>m_profit*m_adjusted_point)
      sl=m_symbol.NormalizePrice(open+m_stop_level*m_adjusted_point);
//---
   return(sl!=EMPTY_VALUE);
  }
//+------------------------------------------------------------------+
//| Check for modification of stop orders of a short position.       |
//| INPUT:  position - pointer to a position object,                 |
//|         sl       - link for a new price of stop loss order,      |
//|         tp       - link for a new take profit order.             |
//| OUTPUT: true if condition is satisfied, false if not.            |
//| REMARK: no.                                                      |
//+------------------------------------------------------------------+
bool CSampleTrailing::CheckTrailingStopShort(CPositionInfo* position,double& sl,double& tp)
  {
//--- check of pointer
   if(position==NULL) return(false);
//--- check of parameters
   if(m_profit==0.0)  return(false);
//--- already in a lossless zone?
   double open=position.PriceOpen();
   if(position.StopLoss()<=open) return(false);
//--- check of profit
   sl=EMPTY_VALUE;
   tp=EMPTY_VALUE;
   if(open-m_symbol.Ask()>m_profit*m_adjusted_point)
      sl=m_symbol.NormalizePrice(open-m_stop_level*m_adjusted_point);
//---
   return(sl!=EMPTY_VALUE);
  }
//+------------------------------------------------------------------+

Eh bien voilà tout. Le module de trailing est prêt à l'emploi.

Pour que legenerator of trade strategies MQL5 Wizard puisse utiliser notre module, nous devons redémarrer MetaEditor (l'assistant MQL5 analyse le dossier Include\Expert uniquement au démarrage).

Après avoir redémarréMetaEditor, le module créé de gestion des positions ouvertes peut être utilisé dans l'assistant MQL5 :

Figure 5. Le module créé de gestion des positions ouvertes sur l'assistant MQL5.

Figure 5. Le module créé de gestion des positions ouvertes sur l'assistant MQL5.

Les paramètres d'entrée précisés dans la section de description des paramètres du module de gestion des positions ouvertes sont désormais disponibles :

Figure 6. Les paramètres d'entrée du module créé de gestion des positions ouvertes dans l'assistant MQL5.

Figure 6. Les paramètres d'entrée du module créé de gestion des positions ouvertes dans l'assistant MQL5.

Les meilleures valeurs des paramètres d'entrée de la stratégie de trading mise en œuvre peuvent être trouvées à l'aide duStrategy Tester duMetaTrader 5 terminal.


Conclusion

Le générateur de stratégies de trading du MQL5 Wizard simplifie considérablement le test des idées de trading. Le code de l'expert généré est basé sur les classes de stratégies de trading de la bibliothèque standard, qui sont utilisées pour créer certaines implémentations de classes de signaux de trading, de classes de gestion des fonds et des risques et de classes de support de position. 

L'article explique comment écrire et se connecter au générateur de stratégies de tradeMQL5 Assistant votre propre classe de gestion des positions ouvertes en déplaçant le niveau Stop Loss vers une zone sans perte lorsque le prix va dans le sens de la position, permettant de diminuer les prélèvements lors de l’activité de trading. Il indique également la structure et le format de la description de la classe créée pour l'assistant MQL5.

Traduit du russe par MetaQuotes Ltd.
Article original : https://www.mql5.com/ru/articles/231

Fichiers joints |
Télécharger ZIP
sampletrailing.mqh (6.46 KB)
Avertissement: Tous les droits sur ces documents sont réservés par MetaQuotes Ltd. La copie ou la réimpression de ces documents, en tout ou en partie, est interdite.

Autres articles par cet auteur

Aller à la discussion
L’implémentation d'un mode multi-devises dans MetaTrader 5 L’implémentation d'un mode multi-devises dans MetaTrader 5
Pendant longtemps, l'analyse multi-devises et le trading multi-devises ont été d’un grand intérêt pour les gens. L'opportunité d’implémenter un régime multi-devises à part entière n'est devenue possible qu'avec la sortie publique de MetaTrader 5 et du langage de programmation MQL5. Dans cet article, nous proposons un moyen d'analyser et de traiter tous les ticks entrants pour plusieurs symboles. A titre d'illustration, examinons un indicateur RSI multi-devises de l'indice USDx dollar.
Assistant MQL5 : Comment Créer un Module de Gestion des Risques et de fonds Assistant MQL5 : Comment Créer un Module de Gestion des Risques et de fonds
Le générateur de stratégies de trading de l'assistant MQL5 simplifie considérablement le test des idées de trading. L'article décrit comment élaborer un module de gestion des risques et de fonds personnalisé et l'activer dans l'assistant MQL5. À titre d'exemple, nous avons examiné un algorithme de gestion de l'argent, dans lequel la taille du volume de trade est déterminée par les résultats du deal précédent. La structure et le format de description de la classe créée pour l'Assistant MQL5 sont également abordés dans l'article.
Connecter les NeuroSolutions Réseaux Neuronaux Connecter les NeuroSolutions Réseaux Neuronaux
En plus de la création de réseaux neuronaux, la suite logicielle NeuroSolutions permet de les exporter sous forme de DLL. Cet article décrit le processus de création d'un réseau neuronal, de génération d'une DLL et de connexion à un Expert Advisor pour le trading dans MetaTrader 5.
Tableaux Électroniques en MQL5 Tableaux Électroniques en MQL5
L'article décrit une classe de tableau dynamique à deux dimensions qui comporte des données de différents types dans sa première dimension. Le stockage des données sous la forme d'un tableau est pratique pour résoudre un large éventail de problèmes d'agencement, de stockage et d'exploitation avec des informations liées de différents types. Le code source de la classe qui implémente la fonctionnalité de travail avec des tableaux est joint à l'article.