L'utilisation des bibliothèques MQL5 Standard de Cours de Trade dans la rédaction d'un Expert Advisor
791
0
Introduction
Le nouveau programme MQL5 est livré avec beaucoup de bibliothèques de classe standard intégrées destinées à rendre le développement de MQL5 Expert Advisors, Indicateurs et Scripts aussi simples que possible pour les traders et développeurs
Ces bibliothèques de classes sont disponibles dans le dossier \Include\ situé dans le dossier MQL5 du dossier du terminal client MetaTrader 5. Les bibliothèques de cours sont divisées en différentes catégories - tableaux, ObjetsGraphiques, Graphiques, Fichiers, Indicateurs, strings et Trade classes.
Dans cet article, nous décrirons dans le détail comment nous pouvons utiliser les classes de trade intégrés pour rédiger un conseiller expert. L'Expert Advisor sera basé sur une stratégie qui comprendra la clôture et la modification des positions ouvertes lorsqu'une condition stipulée est remplie.
Si vous avez déjà une idée de quels sont les classes et comment elles peuvent être utilisés, alors vous êtes le bienvenu dans un autre monde d'opportunités que le nouveau langage MQL5 peut offrir.
Si, d’autre part, vous êtes complètement nouveau sur MQL5; alors je vous suggère de lire ces deux articles pour commencer Guide pas à pas pour écrire un expert conseiller en MQL5 pour les débutants, rédiger un expert conseiller en utilisant l'approche de programmation orientée-objet MQL5 ou tout autre article qui vous proposera une introduction au nouveau langage MQL5. Il y a beaucoup d'articles qui ont été écrits qui vous apporteront les connaissances nécessaires.
1. Les classes de Trade
Le dossier des classes de trade se compose de différents classes destinés à faciliter la vie des traders. qui souhaitent élaborer une EA pour un usage personnel ou pour les programmeurs qui ne doivent réinventer la roue lors de l’élaboration de leurs Expert Advisors (EA).
En utilisant un cours, vous n'avez pas besoin de connaître les fonctionnement interne du cours (c'est-à-dire comment il accomplit ce que le développeur dit que oui), tout ce sur quoi vous devez vous concentrer est de savoir comment le cours peut être utilisé pour résoudre votre problème. C'est pourquoi l'utilisation d'une bibliothèque de cours intégrée rend les choses assez facile pour quiconque souhaite les utiliser. Dans cet article, nous examinerons les principaux classes qui seront nécessaires au processus de l'élaboration d'un Expert Advisor
En discutant des classes, nous ne nous embêterons pas avec les détails internes des classes, mais nous discuterons en détail de ce que le cours peut faire et comment nous pouvons l'utiliser pour accomplir notre mission en élaborant un EA très rentable. Discutons-les l'un après l'autre.
1.1 The СAccountInfo Class
Le CAccountInfo est un cours qui permet à l'utilisateur d'accéder facilement à tous les comptes les propriétés ou les informations du compte trade actuellement ouvert dans le terminal client.
pour mieux comprendre, nous examinerons les principales fonctions membres de ce cours que nous pouvons probablement utiliser dans notre EA. Avant de pouvoir utiliser une classe, nous devons tout d'abord créer un objet de cette classe, pour utiliser le CAccountInfo classe, nous devons créer un objet de la classe.
Appelons cela myaccount :
//--- The AccountInfo Class Object
CAccountInfo myaccount;
N'oubliez pas que pour créer un objet d'une classe, vous utiliserez le nom de la classe suivi du nom que vous souhaitez attribuer à l’objet
Nous pouvons maintenant utiliser notre objet myaccount pour accéder aux membres publics de fonction de la classe CAccountInfo.
| Méthode | Description | Exemple d'utilisation |
|---|---|---|
| myaccount.Login() | Cette fonction est utilisée lorsque vous souhaitez obtenir le numéro de compte pour le trade ouvert dans le terminal. | // returns account number, example 7770 long accountno = myaccount.Login() |
| myaccount.TradeModeDescription() | Cette fonction permet d'obtenir la description du mode de trade du compte actuellement actif sur le terminal. | // returns Demo trading account, // or Real trading account or Contest trading account string acc_trading_mode = myaccount.TradeModeDescription(); |
| myaccount.Leverage() | Cette fonction est utilisée pour obtenir la description du mode trade pour l'actuel compte actif sur le terminal. | // returns leverage given to the active account long acc_leverage = myaccount.Leverage(); |
| myaccount.TradeAllowed() | Cette fonction est utilisée pour vérifier si le trade est autorisé sur le compte actif sur le terminal. Si le trade n'est pas autorisé, le compte ne peut pas trader. | if (myaccount.TradeAllowed()) { // trade is allowed } else { // trade is not allowed } |
| myaccount.TradeExpert() | Cette fonction est utilisée pour vérifier si les Expert Advisors sont autorisés à trader pour le compte actuellement actif dans le terminal. | if (myaccount.TradeExpert()) { // Expert Advisor trade is allowed } else { // Expert Advisor trade is not allowed } |
| myaccount.Solde() | Cette fonction donne le solde du compte actif sur le terminal. | // returns account balance in the deposit currency double acс_balance = myaccount.Balance(); |
| myaccount.Bénéfice() | Cette fonction est utilisée pour obtenir le bénéfice courant du compte actif sur le terminal. | // returns account profit in deposit currency double acс_profit = myaccount.Profit(); |
| myaccount.MargeLibre() | Cette fonction est utilisée pour obtenir la marge libre du compte actif sur le terminal. | // returns free margin for active account double acс_free_margin = myaccount.FreeMargin(); |
| myaccount.Monnaie() | Cette fonction est utilisée pour obtenir la monnaie de dépôt pour le compte actif sur le terminal. | string acс_currency = myaccount.Currency(); |
| myaccount.OrderProfitCheck(const string symbole, ENUM_ORDER_TYPE opération de _trade, double volume, double prix_ouvert, double prix_clôs) | Cette fonction obtient le bénéfice évalué, en fonction des paramètres passés. Les paramètres d'entrée sont : le symbole, le type d'opération de trading, le volume et les prix d'ouverture/de clôture. | double op_profit=myaccount.OrderProfitCheck(_Symbol,ORDER_TYPE_BUY, 1.0,1.2950,1.3235); Print("The amount of Profit for deal buy EURUSD", "at 1.2950 and sell at 1.3235 is: ",op_profit); |
| myaccount.MarginCheck(const string symboleENUM_ORDER_TYPE opération de_trade,double volume,double prix) | Cette fonction est utilisée pour obtenir la marge nécessaire pour ouvrir une commande. Cette fonction dispose de quatre paramètres d'entrée qui sont : le symbole (monnaie-paire), le type de commande, les lots (ou volume) à trader et le prix de la commande. Cette fonction est très importante lorsque on place un trade. | // depending on the type of position to open - in our case buy double price=SymbolInfoDouble(_Symbol,SYMBOL_ASK); double margin_req=myaccount.MarginCheck(_Symbol,ORDER_TYPE_BUY,LOT,price); |
| myaccount.FreeMarginCheck(const string symbole,ENUM_ORDER_TYPE opération de _trade,double volume,double prix) | Cette fonction est utilisée pour obtenir la quantité de marge libre laissée dans ce compte actif lorsqu'une commande est placée. Il a quatre paramètres d'entrée qui sont : le symbole (monnaie-paire), le type de commande, les lots (ou volume) à trader et le prix de la commande. | double acс_fm=myaccount.FreeMarginCheck(_Symbol,ORDER_TYPE_BUY,LOT,price); |
| myaccount.MaxLotCheck(const string symbole,ENUM_ORDER_TYPE opération de _trade,double prix, | Cette fonction est utilisée pour obtenir le lot maximum possible de passer une commande pour le compte actif sur le terminal. Il a trois paramètres d'entrée qui sont : le symbole, le type de commande et le prix d'ouverture de la commande. | double max_lot=myaccount.MaxLotCheck(_Symbol,ORDER_TYPE_BUY,price); |
1.2 La classe СSymbolInfo
The CSymbolInfo classe facilite à l’utilisateur l’accès à toutes les propriétés du symbole actuel.
Pour utiliser la classe, il faut créer un objet de la classe, dans ce cas, nous l'appellerons mysymbol.
// the CSymbolInfo Class object CSymbolInfo mysymbol;
Jetons un coup d'œil à la plupart des fonctions de cette classe qui peuvent être utilisées dans le processus de rédaction de notre Expert Advisor :
| Méthode | Description | Exemple d'utilisation |
|---|---|---|
| mysymbol.Nom(string nom) | Cette fonction est utilisée pour définir le symbole de l'objet de classe. Il prend le symbole nom comme paramètre d'entrée. | // set the symbol name for our CSymbolInfo class Object mysymbol.Name(_Symbol); |
| mysymbol.Refresh() | Cette fonction est utilisée pour actualiser toutes les données de symbole. On l'appelle aussi automatiquement lorsque vous définissez un nouveau nom de symbole pour la classe. | mysymbol.Refresh(); |
| mysmbol.RefreshRates() | Cette fonction est utilisée pour vérifier les dernières données de cotations. Il renvoie vrai en cas de succès et faux en cas d'échec. C'est une fonction utile dont vous ne pouvez pas vous passer. | //--- Get the last price quote using the CSymbolInfo // class object function if (!mysymbol.RefreshRates()) { // error getting latest price quotes } |
| mysymbol.IsSynchronized() | Cette fonction est utilisée pour vérifier si les données actuelles du symbole défini sur le terminal est synchronisé avec les données sur le serveur. Il renvoie vrai si les données sont synchronisées et faux sinon | // check if symbol data are synchronized with server if (!mysymbol.IsSynchronized()) { // error! Symbol data aren't synchronized with server } |
| mysymbol.VolumeHigh() | Cette fonction est utilisée pour obtenir le volume maximum de la journée pour le symbole défini. | long max_vol = mysymbol.VolumeHigh(); |
| mysymbol.VolumeLow() | Cette fonction est utilisée pour obtenir le volume minimum de la journée pour le symbole défini. | long min_vol = mysymbol.VolumeLow(); |
| mysymbol.Time() | Cette fonction est utilisée pour obtenir l'heure de la dernière cotation de prix pour le symbole défini. | datetime qtime = mysymbol.Time(); |
| mysymbol.Spread() | Cette fonction est utilisée pour obtenir la valeur de propagation actuelle (en points) pour le symbole défini. | int spread = mysymbol.Spread(); |
| mysymbol.StopsLevel() | Cette fonction est utilisée pour obtenir le niveau minimal (en points) du prix de clôture actuel pour lequel un arrêt de perte peut être placé pour le symbole défini. Une fonction très utile à utiliser si vous envisagez d'utiliser l’Arrêt de Traîne ou la modification de commande/position. | int stp_level = mysymbol.StopsLevel(); |
| mysymbol.FreezeLevel() | Cette fonction est utilisée pour obtenir la distance (en points) de l'opération de gel du trade pour le symbole défini | int frz_level = mysymbol.FreezeLevel(); |
| mysymbol.Bid() | Cette fonction est utilisée pour obtenir le prix actuel du BID pour le symbole défini. | double bid = mysymbol.Bid(); |
| mysymbol.BidHigh() | Cette La fonction est utilisée pour obtenir le prix maximum/le plus élevé du BID pour la journée. | double max_bid = mysymbol.BidHigh(); |
| mysymbol.BidLow() | Cette fonction est utilisée pour obtenir le prix minimum/le plus bas du BID pour le jour pour l'ensemble du Symbole | double min_bid = mysymbol.BidLow(); |
| msymbol.Ask() | Cette fonction est utilisée pour obtenir le prix actuel du ASK pour le symbole défini. | double ask = mysymbol.Ask(); |
| mysymbol.AskHigh() | Cette fonction est utilisée pour obtenir le prix maximum/le plus élevé du ASK pour la journée pour l'ensemble du Symbole | double max_ask = mysymbol.AskHigh(); |
| mysymbol.AskLow() | Cette fonction est utilisée pour obtenir le prix minimum/le plus bas du ASK pour la journée. | double min_ask = mysymbol.AskLow(); |
| mysymbol.CurrencyBase() | Cette fonction est utilisée pour obtenir la monnaie de base du symbole défini. | // returns "USD" for USDJPY or USDCAD string base_currency = mysymbol.CurrencyBase(); |
| mysymbol.ContractSize() | Cette fonction est utilisée pour obtenir le montant de la taille du contrat pour trader l'ensemble du Symbole | double cont_size = mysymbol.ContractSize(); |
| mysymbol.Digits() | Cette fonction est utilisée pour obtenir le nombre de chiffres après la virgule pour le symbole défini | int s_digits = mysymbol.Digits(); |
| mysymbol.Point() | Cette fonction est utilisée pour obtenir la valeur d'un point pour le symbole défini. | double s_point = mysymbol.Point(); |
| mysymbol.LotsMin() | Cette fonction est utilisée pour obtenir le volume minimum requis pour conclure un deal pour le Symbole | double min_lot = mysymbol.LotsMin(); |
| mysymbol.LotsMax() | Cette est utilisée pour obtenir le volume maximum requis pour conclure un deal pour le Symbole | double max_lot = mysymbol.LotsMax(); |
| mysymbol.LotsStep() | Cette fonction est utilisée pour obtenir le pas minimum de changement de volume pour conclure une deal pour le symbole. | double lot_step = mysymbol.LotsStep(); |
| mysymbol.NormalizePrice(double prix) | Cette fonction est utilisée pour obtenir un prix normalisé aux chiffres corrects de l'ensemble du Symbole | // A normalized current Ask price double n_price = mysymbol.NormalizePrice(mysymbol.Ask()); |
| mysymbol.Select() | Cette fonction est utilisée pour déterminer si un symbole a été sélectionné dans la veille du marché la fenêtre. Il renvoie vrai si le symbole a été sélectionné sinon il renvoie faux. | if (mysymbol.Select()) { //Symbol successfully selected } else { // Symbol could not be selected } |
| mysymbol.Select(bool sélectionner) | Cette fonction est utilisée pour sélectionner un symbole dans la fenêtre de la Veille du Marché ou pour supprimer un symbole dans la fenêtre de veille du marché. Il convient de noter que la suppression d'un symbole de la fenêtre de veille du marché lorsque le graphique est ouvert ou lorsqu'il dispose déjà une position ouverte s’avèrera faux. | if (!mysymbol.Select()) { //Symbol not selected, Select the symbol mysymbol.Select(true); } else { // Symbol already selected, // remove Symbol from market watch window mysymbol.Select(false); } |
| mysymbol.MarginInitial() | Cette fonction est utilisée pour obtenir le montant requis pour ouvrir une position avec volume d'un lot dans la monnaie de marge. | double init_margin = mysymbol.MarginInitial() ; |
| mysymbol.TradeMode() | Cette fonction est utilisée pour obtenir le type d'exécution de commande autorisé pour le symbole. | if (mysymbol.TradeMode() == SYMBOL_TRADE_MODE_FULL) { // Full trade allowed for this symbol, // no trade restrictions } |
| mysymbol.TradeModeDescription() | Cette fonction est utilisée pour obtenir la description du type d'exécution de commande autorisé pour le symbole. | Print("The trade mode for this symbol is", mysymbol.TradeModeDescription()); |
1.3 La Classe СHistoryOrderInfo
Le CHstoryOrderInfo est une autre classe qui permet de gérer très facilement les propriétés de l'historique des commandes.
Une fois que nous créons un objet de cette classe, nous pouvons ensuite utiliser l'objet pour accéder aux importantes fonctions des membres publics dont nous avons besoin pour résoudre un problème immédiat.
Nommons l'objet de la classe myhistory.
// The CHistoryOrderInfo Class object
CHistoryOrderInfo myhistory; Regardons quelques-uns des principales fonctions de cette classe.
En utilisant cette classe pour obtenir les détails des commandes dans l'historique, nous devons tout d'abord obtenir le total des commandes dans l’historique, puis transmettez le ticket de commande à notre objet de classe, myhistory.
//Select all history orders within a time period if (HistorySelect(0,TimeCurrent())) // get all history orders { // Get total orders in history int tot_hist_orders = HistoryOrdersTotal();
Nous allons maintenant parcourir le historique total des commandes disponibles et obtenez les détails de chaque historique des commandes avec notre objet de classe.
ulong h_ticket; // Order ticket for (int j=0; j<tot_hist_orders; j++) { h_ticket = HistoryOrderGetTicket(j)); if (h_ticket>0) { // First thing is to now set the order Ticket to work with by our class object
| Méthode | Description | Exemple d'utilisation |
|---|---|---|
| myhistory.Ticket (ulong ticket) | Cette fonction permet de sélectionner le bon de commande dont on veut obtenir les propriétés ou détails. | myhistory.Ticket(h_ticket); |
| myhistory.Ticket() | Cette fonction permet d'obtenir le bon de commande pour une commande. | ulong o_ticket = myhistory.Ticket(); |
| myhistory.TimeSetup() | Cette fonction permet d'obtenir l'Heure d'exécution ou de configuration de la commande. | datetime os_time = myhistory.TimeSetup(); |
| myhistory.OrderType() | Cette fonction est utilisée pour obtenir le type de commande (ORDER_TYPE_BUY, etc.). | if (myhistory.OrderType() == ORDER_TYPE_BUY) { // This is a buy order } |
| myhistory.State() | Cette fonction est utilisée pour obtenir l'état actuel de la commande. Si la commande a été annulée, acceptée, rejetée ou placée, etc. | if(myhistory.State() == ORDER_STATE_REJECTED) { // order was rejected, not placed. } |
| myhistory.TimeDone() | Cette fonction est utilisée pour obtenir l'heure à laquelle la commande a été passée, annulée ou rejetée. | datetime ot_done = myhistory.TimeDone(); |
| myhistory.Magic() | Cette fonction est utilisée pour obtenir l'identifiant de l'Expert Advisor qui a engager la commande. | long o_magic = myhistory.Magic(); |
| myhistory.PositionId() | Cette fonction est utilisée pour obtenir l'identifiant de la position vers laquelle la commande était incluse une fois placée. | long o_posid = myhistory.PositionId(); |
| myhistory.PriceOpen() | Cette fonction est utilisée pour obtenir le prix d'ouverture de la commande. | double o_price = myhistory.PriceOpen(); |
| myhistory.Symbole() | Cette fonction est utilisée pour obtenir la propriété du symbole (paire de monnaie) de la commande. | string o_symbol = myhistory.Symbol();
|
N'oubliez pas que nous avons utilisé ces fonctionne dans une boucle de commandes totales dans l'histoire.
1.4 La classe OrderInfo
Cette COrderInfo est une classe qui fournit un accès facile à toutes les propriétés de la commande en cours Une fois un objet de cette classe a été créé, il peut être utilisé pour le les fonctions du membre public de cette classe.
L'utilisation de cette classe est quelque peu similaire à la Classe CHistoryOrderInfo décrite ci-dessus.
Créons un objet de classe, nous l'appellerons myorder.
// The OrderInfo Class object
COrderInfo myorder; Pour pouvoir utiliser cette classe pour obtenir les détails d'une commande en cours, nous devons d'abord obtenir le total des commandes disponibles, puis sélectionnez-les par le bon de commande.
// Select all history orders within a time period if (HistorySelect(0,TimeCurrent())) // get all history orders { // get total orders int o_total = OrdersTotal();
Nous allons parcourir le total des commandes et obtenir leurs propriétés correspondantes en utilisant l'objet que nous avons Créé
for (int j=0; j<o_total; j++) { // we must confirm if the order is available for us to get its details using the Select function of the COrderInfo Class
| Méthode | Description | Exemple d'utilisation |
|---|---|---|
| myorder.Select(ulong ticket) | Cette fonction est utilisée pour sélectionner une commande par numéro de ticket afin que la commande puisse être facilement manipulée. | if (myorder.Select(OrderGetTicket(j)) { // order has been selected and can now be manipulated. } |
| myorder.Ticket() | Cette fonction permet d'obtenir le ticket de commande pour la commande sélectionnée. | ulong o_ticket = myorder.Ticket(); |
| myorder.TimeSetup() | Cette fonction est utilisée pour obtenir l'heure à laquelle cette commande a été configurée. | datetime o_setup = myorder.TimeSetup(); |
| myorder.Type() | Cette fonction est utilisée pour obtenir le type de commande comme ORDER_TYPE_BUY_STOP, etc. | if (myorder.Type() == ORDER_TYPE_BUY_LIMIT) { // This is a Buy Limit order, etc } |
| myorder.Etat() | Cette fonction est utilisée pour obtenir l'état de la commande. Si la commande a été annulée, acceptée, rejetée ou placée, etc. | if (myorder.State() ==ORDER_STATE_STARTED) { // order has been checked // and may soon be treated by the broker } |
| myorder.TimeDone() | Cette fonction est utilisée pour obtenir l'heure à laquelle la commande a été passée, rejetée ou annulée. | datetime ot_done = myorder.TimeDone(); |
| myorder.Magie() | Cette fonction est utilisée pour obtenir l'identifiant de l'Expert Advisor qui a engagé la commande. | long o_magic = myorder.Magic(); |
| myorder.PositionId() | Cette fonction est utilisée pour obtenir l'identifiant de la position à laquelle la commande est incluse une fois placée. | long o_posid = myorder.PositionId(); |
| myorder.PriceOpen() | Cette fonction est utilisée pour obtenir le prix d'ouverture de la commande. | double o_price = myorder.PriceOpen(); |
| myorder.StopLoss() | Cette fonction est utilisée pour obtenir le Stop loss de la commande. | double s_loss = myorder.StopLoss(); |
| myorder.TakeProfit() | Cette fonction est utilisée pour obtenir le Take Profit de la commande | double t_profit = myorder.TakeProfit(); |
| myorder.PriceCurrent() | Cette fonction est utilisée pour obtenir le prix actuel du symbole dans lequel la commande a été placée. | double cur_price = myorder.PriceCurrent(); |
| myorder.Symbol() | Cette La fonction est utilisée pour obtenir le nom du symbole dans lequel la commande a été passée. | string o_symbol = myorder.Symbol(); |
| myorder.StoreState() | Cette fonction est utilisée pour enregistrer ou stocker le détail actuel de la commande afin que nous puissions comparer si quelque chose a changé plus tard. | myorder.StoreState(); |
| myorder.CheckState() | Cette fonction est utilisée pour vérifier si le détail de la commande qui a été enregistré ou stocké a changé. | if (myorder.CheckState() == true) { // Our order status or details have changed } |
1.5 La classe CDealInfo
La classe CDealInfo donne accès à tout l'historique des propriétés ou des informations du deal. Une fois que nous avons créé un objet de cette classe, nous l'utiliserons ensuite pour obtenir toutes les informations sur les deals dans l'historique, d'une manière similaire à la classe CHistoryOrderInfo.
Alors, la première chose nous souhaitons faire est de créer un objet de cette classe et de le nommer mydeal.
// The DealInfo Class object
CDealInfo myinfo;
Nous commencerons par obtenir le total des deals dans l’historique
if (HistorySelect(0,TimeCurrent())) { // Get total deals in history int tot_deals = HistoryDealsTotal();
Nous allons maintenant parcourir le historique total des commandes disponibles et obtenez les détails de chaque historique des commandes avec notre objet de classe.
ulong d_ticket; // deal ticket for (int j=0; j<tot_deals; j++) { d_ticket = HistoryDealGetTicket(j); if (d_ticket>0) { // First thing is to now set the deal Ticket to work with by our class object
| Méthode | Description | Exemple d'utilisation |
|---|---|---|
| mydeal.Ticket(ulong ticket) | Cette fonction est utilisée pour définir le ticket de deal pour une utilisation ultérieure par l'objet que nous avons Créé | mydeal.Ticket(d_ticket); |
| mydeal.Ticket() | Cette fonction permet d'obtenir le ticket de deal | ulong deal_ticket = mydeal.Ticket(); |
| mydeal.Order() | Cette fonction est utilisée pour obtenir le ticket de commande pour la commande dans lequel le deal a été réalisé | long deal_order_no = mydeal.Order(); |
| mydeal.Time() | Cette fonction est utilisée pour obtenir l'heure à laquelle le deal a été exécuté | datetime d_time = mydeal.Time(); |
| mydeal.Type() | Cette fonction est utilisée pour obtenir le type de transaction, s'il s'agissait d'un DEAL_TYPE_SELL, etc. | if (mydeal.Type() == DEAL_TYPE_BUY) { // This deal was executed as a buy deal type } |
| mydeal.Entry() | Cette fonction est utilisée pour obtenir la direction du deal qu’il soit DEAL_ENTRY_IN or DEAL_ENTRY_OUT, etc. | if (mydeal.Entry() == DEAL_ENTRY_IN) { // This was an IN entry deal } |
| mydeal.Magic() | Cette fonction est utilisée pour obtenir l'identifiant de l'Expert Advisor qui a exécuté le deal. | long d_magic = mydeal.Magic(); |
| mydeal.PositionId() | Cette fonction est utilisée pour obtenir l'identifiant de position unique pour la position dont le deal faisait partie. | long d_post_id = mydeal.PositionId(); |
| mydeal.Price() | Cette fonction est utilisée pour obtenir le prix auquel le deal a été exécuté | double d_price = mydeal.Price(); |
| mydeal.Volume() | Cette fonction est utilisée pour obtenir le volume (lot) du deal | double d_vol = mydeal.Volume(); |
| mydeal.Symbol() | Cette fonction est utilisée pour obtenir le symbole (paire-monnaie) pour lequel le deal a été réalisé | string d_symbol = mydeal.Symbol(); |
1.6 The CPositionInfo Classe
La CPositionInfo classe offre un accès facile aux propriétés de la position actuelle. Nous devons créer un objet de cette classe pour pouvoir l'utiliser pour obtenir les propriétés de la position.
Créons un objet de cette classe et appelez-la myposition.
// The object of the CPositionInfo class
CPositionInfo myposition; Nous allons maintenant utiliser cet objet pour obtenir les détails des positions ouvertes. Nous commencerons par obtenir le total des positions ouvertes disponibles:
int pos_total = PositionsTotal();
Il est maintenant temps de passer en revue toutes les positions ouvertes pour obtenir leurs détails.
for (int j=0; j<pos_total; j++) {
| Méthode | Description | Exemple d'utilisation |
|---|---|---|
| myposition.Select(const string symbole) | Cette fonction permet de sélectionner le symbole correspondant à l'ouverture actuelle de la position afin qu'elle puisse être examinée. | if (myposition.Select(PositionGetSymbol(j))) { // symbol successfully selected, we can now work // on the current open position for this symbol } OR // when dealing with the current symbol/chart only if (myposition.Select(_Symbol)) { // symbol successfully selected, we can now work // on the current open position for this symbol } |
| myposition.Time() | Cette fonction est utilisée pour obtenir l'heure à laquelle la position a été ouverte. | datetime pos_time = myposition.Time(); |
| myposition.Type() | Cette fonction est utilisée pour obtenir le type de position ouverte. | if (myposition.Type() == POSITION_TYPE_BUY) { // This is a buy position } |
| myposition.Magic() | Cette fonction est utilisée pour obtenir l'identifiant de l'Expert Advisor qui a ouvert la position. | long pos_magic = myposition.Magic(); |
| myposition.Volume() | Cette fonction est utilisée pour obtenir le volume (lots) de la position ouverte. | double pos_vol = myposition.Volume(); // Lots |
| myposition.PriceOpen() | Cette fonction est utilisée pour obtenir le prix auquel la position a été ouverte - le Prix d'ouverture d'une position | double pos_op_price = myposition.PriceOpen(); |
| myposition.StopLoss() | Cette fonction est utilisée pour obtenir le prix Arrêt de Perte pour la position ouverte. | double pos_stoploss = myposition.StopLoss(); |
| myposition.TakeProfit() | Cette fonction est utilisée pour obtenir le prix Prise de Bénéfice pour la position ouverte. | double pos_takeprofit = myposition.TakeProfit(); |
| maposition.StoreState() | Cette fonction est utilisée pour stocker l'état actuel de la position. | // stores the current state of the position
myposition.StoreState(); |
| myposition.CheckState() | Cette fonction est utilisée pour vérifier si l'état de la position ouverte a changé. | if (!myposition.CheckState()) { // position status has not changed yet } |
| myposition.Symbol() | Cette fonction est utilisée pour obtenir le nom du symbole dans lequel la position a été ouverte. | string pos_symbol = myposition.Symbol(); |
1.7 La classe CTrade
La classe CTrade offre un accès facile aux opérations de trade dans MQL5. Pour utiliser cette classe, nous devons créer un objet de la classe, puis l'utiliser pour effectuer les opérations de trade nécessaires.
Nous allons créer un objet de cette classe et nommez-la mytrade :
//An object of the CTrade class
CTrade mytrade; La première étape consiste à définir le plus des paramètres que l'objet utilisera dans l'opération de trade.
| Méthode | Description | Exemple d'utilisation |
|---|---|---|
| mytrade.SetExpertMagicNumber(ulong magic | Cette fonction est utilisée pour définir l'identifiant expert (numéro magique) que la classe utilisera pour opérations de trade. | ulong Magic_No=12345; mytrade.SetExpertMagicNumber(Magic_No); |
| mytrade.SetDeviationInPoints(ulong déviation) | Cette fonction est également utilisée pour définir la valeur de déviation (en points) à utiliser lorsque nous plaçons un trade. | ulong Deviation=20; mytrade.SetDeviationInPoints(Deviation); |
| mytrade.OrderOpen(const string symbole, ENUM_ORDER_TYPE commande_type,double volume, double prix_limite,double prix,double sl, double tp,ENUM_ORDER_TYPE_TIME type_time, datetime expiration,const string comment="") | Cette fonction est utilisée pour passer une commande en cours. pour utiliser cette fonction, il faut d'abord préparer les paramètres puis passer à cette fonction. | // define the input parameters double Lots = 0.1; double SL = 0; double TP = 0; // latest Bid price using CSymbolInfo class object double Oprice = mysymbol.Bid()-_Point*550; // place (BuyStop) pending order mytrade.OrderOpen(_Symbol,ORDER_TYPE_SELLSTOP,Lots,0.0,Oprice, SL,TP,ORDER_TIME_GTC,0); |
| mytrade.OrderModify(ulong ticket,double prix, double sl,double tp,ENUM_ORDER_TYPE_TIME type_time,datetime expiration) | Cette fonction est utilisée pour modifier une commande existante en cours . | // Select total orders in history and get total pending orders // (as shown within the COrderInfo class section). // Use the CSymbolInfo class object to get the current ASK/BID price int Stoploss = 400; int Takeprofit = 550; for(int j=0; j<OrdersTotal(); j++) { ulong o_ticket = OrderGetTicket(j); if(o_ticket != 0) { // Stoploss must have been defined double SL = mysymbol.Bid() + Stoploss*_Point; // Takeprofit must have been defined double TP = mysymbol.Bid() - Takeprofit*_Point; // lastest ask price using CSymbolInfo class object double Oprice = mysymbol.Bid(); // modify pending BuyStop order mytrade.OrderModify(o_ticket,Oprice,SL,TP,ORDER_TIME_GTC,0); } } |
| mytrade.OrderDelete(ulong billet) | Cette fonction est utilisée pour supprimer une commande en cours. | // Select total orders in history and get total pending orders // (as shown within the COrderInfo class section). int o_total=OrdersTotal(); for(int j=o_total-1; j>=0; j--) { ulong o_ticket = OrderGetTicket(j); if(o_ticket != 0) { // delete the pending Sell Stop order mytrade.OrderDelete(o_ticket); } } |
| mytrade.PositionOpen(const string symbole,ENUM_ORDER_TYPE order_type,double volume,double prix,double sl,double tp,const string comment="") | Cette fonction est utilisée pour ouvrir une position ACHAT ou VENTE. Pour utiliser cette fonction, tous les paramètres requis doivent d'abord être préparés puis transmis à cette fonction | // define the input parameters and use the CSymbolInfo class // object to get the current ASK/BID price double Lots = 0.1; // Stoploss must have been defined double SL = mysymbol.Ask() – Stoploss*_Point; //Takeprofit must have been defined double TP = mysymbol.Ask() + Takeprofit*_Point; // latest ask price using CSymbolInfo class object double Oprice = mysymbol.Ask(); // open a buy trade mytrade.PositionOpen(_Symbol,ORDER_TYPE_BUY,Lots, Oprice,SL,TP,"Test Buy"); |
| mytrade.PositionModify(const symbole de string, double sl,double tp) | Cette fonction est utilisée pour modifier l’ ArrêtPerte et/ou la PriseBénéfice d'une position existante ouverte Pour utiliser cette fonction, il faut tout d'abord sélectionner la position à modifier à l'aide de l'objet classe CPositionInfo, utilisez l'objet classe CSymbolInfo pour obtenir le prix actuel du BID/ASK. | if (myposition.Select(_Symbol)) { int newStoploss = 250; int newTakeprofit = 500; double SL = mysymbol.Ask() – newStoploss*_Point; double TP = mysymbol.Ask() + newTakeprofit*_Point; //modify the open position for this symbol mytrade.PositionModify(_Symbol,SL,TP); } |
| mytrade.PositionClose(const symbole de string, ulong déviation=ULONG_MAX) | Cette fonction est utilisée pour fermer une position ouverte existante. | if (myposition.Select(_Symbol)) { //close the open position for this symbol mytrade.PositionClose(_Symbol); } |
| mytrade.Buy(double volume,const string symbol=NULL,double price=0.0,double sl=0.0,double tp=0.0,const string comment="") | Cette fonction est utilisée pour ouvrir une transaction d'achat. Il est recommandé de régler le volume (ou lots) à trader lors de l'utilisation de cette fonction. Alors que le tp (prise profit) et sl (arrêt bénéfice) peut être réglé plus tard en modifiant la position ouverte, il utilise l’actuel Demandez le prix pour ouvrir le trade. | double Lots = 0.1; // Stoploss must have been defined double SL = mysymbol.Ask() – Stoploss*_Point; //Takeprofit must have been defined double TP = mysymbol.Ask() +Takeprofit*_Point; // latest ask price using CSymbolInfo class object double Oprice = mysymbol.Ask(); // open a buy trade mytrade.Buy(Lots,NULL,Oprice,SL,TP,“Buy Trade”); //OR mytrade.Buy(Lots,NULL,0.0,0.0,0.0,“Buy Trade”); // modify position later |
| mytrade.vente(double volume,const string symbol=NULL,double price=0.0,double sl=0.0,double tp=0.0,const string comment="") | Cette fonction est utilisée pour ouvrir un trade de vente Il est recommandé de régler le volume (ou lots) à trader lors de l'utilisation de cette fonction. Alors que le tp (prise profit) et sl (arrêt bénéfice) peut être réglé plus tard en modifiant la position ouverte, il utilise le prix actuel de la soumission pour ouvrir le trade. | double Lots = 0.1; // Stoploss must have been defined double SL = mysymbol.Bid() + Stoploss*_Point; //Takeprofit must have been defined double TP = mysymbol.Bid() - Takeprofit*_Point; // latest bid price using CSymbolInfo class object double Oprice = mysymbol.Bid(); // open a Sell trade mytrade.Sell(Lots,NULL,Oprice,SL,TP,“Sell Trade”); //OR mytrade.Sell(Lots,NULL,0.0,0.0,0.0,“Sell Trade”); //(modify position later) |
| mytrade.BuyStop(double volume,double price,const string symbol=NULL,double sl=0.0,double tp=0.0, ENUM_ORDER_TYPE_TIME type_time=ORDER_TIME_GTC,datetime expiration=0,const string comment="") | Cette fonction est utilisée pour passer une commande en cours BuyStop. Le défaut L'heure du type de commande est ORDER_TIME_GTC et l'expiration est 0. Il n'y a pas besoin d’indiquer ces deux variables si vous avez le même type de commande temps à l’esprit | double Lot = 0.1; //Buy price = bar 1 High + 2 pip + spread int sprd=mysymbol.Spread(); double bprice =mrate[1].high + 2*_Point + sprd*_Point; //--- Buy price double mprice=NormalizeDouble(bprice,_Digits); //--- Stop Loss double stloss = NormalizeDouble(bprice - STP*_Point,_Digits); //--- Take Profit double tprofit = NormalizeDouble(bprice+ TKP*_Point,_Digits); //--- open BuyStop order mytrade.BuyStop(Lot,mprice,_Symbol,stloss,tprofit); |
| mytrade.SellStop(double volume,double price,const string symbol=NULL,double sl=0.0,double tp=0.0, ENUM_ORDER_TYPE_TIME type_time=ORDER_TIME_GTC,datetime expiration=0,const string comment="") | Cette fonction est utilisée pour passer une commande en cours SellStop avec les paramètres définis. L’heure par défaut de type de commande est ORDER_TIME_GTC et expiration est 0. Pas besoin d’indiquer ces deux variables si vous avez le même type de commande en tête. | double Lot = 0.1; //--- Sell price = bar 1 Low - 2 pip //--- MqlRates mrate already declared double sprice=mrate[1].low-2*_Point; //--- SellStop price double slprice=NormalizeDouble(sprice,_Digits); //--- Stop Loss double ssloss=NormalizeDouble(sprice+STP*_Point,_Digits); //--- Take Profit double stprofit=NormalizeDouble(sprice-TKP*_Point,_Digits); //--- Open SellStop Order mytrade.SellStop(Lot,slprice,_Symbol,ssloss,stprofit); |
| mytrade.BuyLimit(double volume,double price,const string symbol=NULL,double sl=0.0,double tp=0.0, ENUM_ORDER_TYPE_TIME type_time=ORDER_TIME_GTC,datetime expiration=0,const string comment="") | Cette fonction est utilisée pour passer une commande BuyLimit avec les paramètres définis. | Usage: //--- Buy price = bar 1 Open - 5 pip + spread double Lot = 0.1; int sprd=mysymbol.Spread(); //--- symbol spread double bprice = mrate[1].open - 5*_Point + sprd*_Point; //--- MqlRates mrate already declared double mprice=NormalizeDouble(bprice,_Digits); //--- BuyLimit price //--- place buyLimit order, modify stoploss and takeprofit later mytrade.BuyLimit(Lot,mprice,_Symbol); |
| mytrade.SellLimit (double volume,double price,const string symbol=NULL,double sl=0.0,double tp=0.0, ENUM_ORDER_TYPE_TIME type_time=ORDER_TIME_GTC,datetime expiration=0,const string comment="") | Cette fonction est utilisée pour passer une commande de vente limité avec les paramètres définis. | //--- Sell Limit price = bar 1 Open + 5 pip double Lot = 0.1; //--- MqlRates mrate already declared double sprice = mrate[1].open + 5*_Point; //--- SellLimit double slprice=NormalizeDouble(sprice,_Digits); //place SellLimit order, modify stoploss and takeprofit later mytrade.SellLimit(Lot,slprice,_Symbol); |
| FONCTIONS DE RÉSULTAT DU TRADE | ||
| mytrade.ResultRetcode() | Cette fonction est utilisée pour obtenir le code de résultat d'une opération commerciale. | // a trade operation has just been carried out int return_code = mytrade.ResultRetcode(); |
| mytrade.ResultRetcodeDescription() | Cette fonction est utilisée pour obtenir la description complète ou l'interprétation du code retourné d'une opération de trade. | string ret_message = ResultRetcodeDescription(); // display it Alert("Error code - " , mytrade.ResultRetcode() , "Error message - ", ret_message); |
| mytrade.ResultDeal() | Cette fonction est utilisée pour obtenir le ticket de deal pour la position ouverte. | long dl_ticket = mytrade.ResultDeal(); |
| mytrade.ResultOrder() | Cette fonction est utilisée pour obtenir le ticket de commande pour la position ouverte. | long o_ticket = mytrade.ResultOrder(); |
| mytrade.ResultVolume() | Cette fonction est utilisée pour obtenir le volume (Lots) de commande pour la position ouverte. | double o_volume = mytrade.ResultVolume(); |
| mytrade.ResultPrice() | Cette fonction est utilisée pour obtenir le prix du deal pour la position ouverte. | double r_price = mytrade.ResultPrice(); |
| mytrade.ResultBid() | Cette fonction est utilisée pour obtenir le prix BID du marché actuel (prix de re-cotation). | double rq_bid = mytrade.ResultBid; |
| mytrade.ResultAsk() | Cette fonction est utilisée pour obtenir le prix ASK du marché actuel (prix de re-cotation). | double rq_ask = mytrade.ResultAsk; |
| mytrade.PrintRequest() / mytrade.PrintResult() | Ces deux fonctions peuvent être utilisées pour imprimer, dans l'onglet Journal, les paramètres de la requête de trade et les paramètres de résultat respectivement. | // after a trade operation // prints the trade request parameters mytrade.PrintRequest(); //prints the trade results mytrade.PrintResult(); |
| FONCTIONS DE requête DE TRADE | ||
| mytrade.RequestAction() | Cette fonction permet d'obtenir le type d'opération de trade pour la dernière requête de trade qui vient d'être envoyée. | //determine the Trade operation type for the last Trade request if (mytrade.RequestAction() == TRADE_ACTION_DEAL) { // this is a market order for an immediate execution } else if (mytrade.RequestAction() == TRADE_ACTION_PENDING) { // this is a pending order. } |
| mytrade.RequestMagic() | Cette fonction est utilisée pour obtenir le numéro Expert Magic qui a été utilisé dans le dernier requête | ulong mag_no = mytrade. RequestMagic(); |
| mytrade.RequestOrder() | Cette fonction est utilisée pour obtenir le ticket de commande qui a été utilisé lors de la dernière requête. Il s'agit principalement de modification de commandes en cours. | ulong po_ticket = mytrade.RequestOrder(); |
| mytrade.RequestSymbol() | Cette est utilisée pour obtenir le symbole ou la paire de monnaie qui a été utilisée dans le Dernière requête. | string symb = mytrade.RequestSymbol(); |
| mytrade.RequestVolume() | Cette fonction est utilisée pour obtenir le volume d'échange (en lots) placé dans le dernier requête | double Lot = mytrade.RequestVolume(); |
| mytrade.RequestPrice() | Cette fonction est utilisée pour obtenir le prix de la commande utilisé dans la dernière requête. | double oprice = mytrade.RequestPrice(); |
| mytrade.RequestStopLimit() | Cette fonction est utilisée pour obtenir l’Arrêt de Perte prix utilisé dans la dernière requête. | double limitprice = mytrade.RequestStopLimit(); |
| mytrade.RequestSL() | Cette fonction est utilisée pour obtenir l’Arrêt de Perte prix utilisé dans la dernière requête. | double sloss = mytrade.RequestSL(); |
| mytrade.RequestTP() | Cette fonction est utilisée pour obtenir le prix Prise de Bénéfice utilisé dans la dernière requête. | double tprofit = mytrade.RequestTP(); |
| mytrade.RequestDeviation() | Cette fonction est utilisée pour obtenir l'écart utilisé dans la dernière requête. | ulong dev = mytrade.RequestDeviation(); |
| mytrade.RequestType() | Cette fonction est utilisée pour obtenir le type de commande qui a été passée dans la dernière requête | if (mytrade.RequestType() == ORDER_TYPE_BUY) { // market order Buy was placed in the last request. } |
| mytrade.RequestTypeDescription() | Cette La fonction permet d'obtenir la description du type de commande passée dans la dernière requête | Print("The type of order placed in the last request is :", mytrade.RequestTypeDescription()); |
| mytrade.RequestActionDescription() | Cette La fonction est utilisée pour obtenir la description de l'action de requête utilisée dans le dernier requête | Print("The request action used in the last request is :", mytrade.RequestTypeDescription()); |
| mytrade.RequestTypeFillingDescription() | Cette fonction est utilisée pour obtenir le type de politique de remplissage des commandes utilisé dans la dernière requête | Print("The type of order filling policy used", " in the last request is :", RequestTypeFillingDescription()); |
Les fonctions de requête de classe de trade sont très utiles pour identifier les erreurs associées à la passation de commandes. Il y a des moments où nous recevons des messages d'erreur lors de la passation d'une commande et cela devient un peu déroutant lorsque nous ne pouvons pas identifier immédiatement ce qui s'est mal passé. En utilisant les fonctions de requête de classe commerciale, nous pouvons être en mesure d'identifier ce que nous avons fait de mal en imprimant certains des paramètres de requête qui ont été envoyés au serveur commercial. Un exemple d'une telle utilisation sera similaire au code ci-dessous :
//--- open Buy position and check the result if(mytrade.Buy(Lot,_Symbol,mprice,stloss,tprofit)) //if(mytrade.PositionOpen(_Symbol,ORDER_TYPE_BUY,Lot,mprice,stloss,tprofit)) { //--- Request is completed or order placed Alert("A Buy order at price:", mytrade.ResultPrice() , ", vol:",mytrade.ResultVolume(), " has been successfully placed with deal Ticket#:",mytrade.ResultDeal(),"!!"); mytrade.PrintResult(); } else { Alert("The Buy order request at vol:",mytrade.RequestVolume(), ", sl:", mytrade.RequestSL(), ", tp:",mytrade.RequestTP(), ", price:", mytrade.RequestPrice(), " could not be completed -error:",mytrade.ResultRetcodeDescription()); mytrade.PrintRequest(); return; }
Dans le code ci-dessus, nous avons essayé de pouvoir identifier certains des paramètres envoyés dans notre requête en cas d'erreur. Par exemple, si nous n'avons pas indiqué le bon prix Arrêt de Perte, nous pouvons obtenir une erreur Stops non valides et en imprimant la valeur d’ Arrêt de Perte à l'aide de mytrade.RequestSL(), nous pourrons savoir quel est le problème avec notre prix Arrêt de Perte indiqué
Ayant pris le temps de montrer comment chacune des classes peut être utilisée, il est maintenant temps de mettre en pratique certaines des fonctionnalités que nous avons décrites.
Veuillez noter que toutes les fonctionnalités que nous allons utiliser dans l'Expert Advisor ont déjà été décrites ci-dessus, ce sera une bonne idée de se référer toujours aux descriptions une fois que vous voyez l'une des fonctions dans les codes que nous allons écrire.
2. À l'aide de les fonctionnalités des classes de Trade
Afin de montrer comment utiliser les fonctionnalités de ces classes de trade, nous allons écrire un Expert Advisor qui effectuera les tâches suivantes.
- il vérifiera une condition d'achat ou de vente, et si la condition est remplie, il passera une commande d'achat ou de vente selon la condition qui a été remplie.
- si une position a été ouverte et le trade continue d'aller dans notre sens, nous modifierons la prise de bénéfice ou l’arrêt de perte de la position. Toutefois, si le trade va contre nous et notre objectif de bénéfice n'a pas été atteint, nous fermerons la position.
- Notre EA sera utilisé pour trader sur le graphique journalier sur l'un des éléments suivants monnaies – GBPUSD, AUDUSD, EURUSD, etc.
2.1 Rédaction de l'Expert Advisor
Pour commencer, démarrez un nouveau document MQL5 et sélectionnez Expert Advisor (modèle) et cliquez sur le bouton Suivant :
Figure 1. Commencer un nouveau document MQL5
Tapez le nom de l'expert Advisor et cliquez sur le bouton Terminer. Nous allons définir les paramètres d'entrée manuellement plus tard.
Figure 2. Nommer le conseiller expert
Le nouveau document créé doit ressembler à ci-dessous.
Juste immédiatement après la #ligne de version de propriété, nous inclurons toutes les classes de trade auxquelles nous allons utiliser.
//+------------------------------------------------------------------+ //| Include ALL classes that will be used | //+------------------------------------------------------------------+ //--- The Trade Class #include <Trade\Trade.mqh> //--- The PositionInfo Class #include <Trade\PositionInfo.mqh> //--- The AccountInfo Class #include <Trade\AccountInfo.mqh> //--- The SymbolInfo Class #include <Trade\SymbolInfo.mqh>
Ensuite, nous allons définir nos paramètres d’ entrée:
//+------------------------------------------------------------------+ //| INPUT PARAMETERS | //+------------------------------------------------------------------+ input int StopLoss=100; // Stop Loss input int TakeProfit=240; // Take Profit input int ADX_Period=15; // ADX Period input int MA_Period=15; // Moving Average Period input ulong EA_Magic=99977; // EA Magic Number input double Adx_Min=24.0; // Minimum ADX Value input double Lot=0.1; // Lots to Trade input ulong dev=100; // Deviation input long Trail_point=32; // Points to increase TP/SL input int Min_Bars = 20; // Minimum bars required for Expert Advisor to trade input double TradePct = 25; // Percentage of Account Free Margin to trade
Nous indiquerons également d'autres paramètres qui seront utilisés dans ce code Expert Advisor :
//+------------------------------------------------------------------+ //| OTHER USEFUL PARAMETERS | //+------------------------------------------------------------------+ int adxHandle; // handle for our ADX indicator int maHandle; // handle for our Moving Average indicator double plsDI[],minDI[],adxVal[]; // Dynamic arrays to hold the values of +DI, -DI and ADX values for each bars double maVal[]; // Dynamic array to hold the values of Moving Average for each bars double p_close; // Variable to store the close value of a bar int STP, TKP; // To be used for Stop Loss, Take Profit double TPC; // To be used for Trade percent
Créons maintenant un objet de chacune des classes que nous avons incluses :
//+------------------------------------------------------------------+ //| CREATE CLASS OBJECTS | //+------------------------------------------------------------------+ //--- The Trade Class Object CTrade mytrade; //--- The PositionInfo Class Object CPositionInfo myposition; //--- The AccountInfo Class Object CAccountInfo myaccount; //--- The SymbolInfo Class Object CSymbolInfo mysymbol;
La prochaine chose que nous souhaitons faire maintenant, est de définir quelques fonctions que nous allons utiliser pour rendre notre travail très facile.
Une fois que nous aurons défini ces fonctions, nous les appellerons simplement dans sections nécessaires dans les fonctions OnInit() et OnTick().
2.1.1 La fonction checkTrading
Cette fonction va être utilisée pour effectuer toutes les vérifications initiales pour voir si notre Expert Advisor peut trader ou pas. Si cette fonction s’renvoie vrai, notre EA continuera, sinon l'EA n'effectuer aucun trade.
//+------------------------------------------------------------------+ //| Checks if our Expert Advisor can go ahead and perform trading | //+------------------------------------------------------------------+ bool checkTrading() { bool can_trade = false; // check if terminal is syncronized with server, etc if (myaccount.TradeAllowed() && myaccount.TradeExpert() && mysymbol.IsSynchronized()) { // do we have enough bars? int mbars = Bars(_Symbol,_Period); if(mbars >Min_Bars) { can_trade = true; } } return(can_trade); }
Nous avons déclaré un type de données bool can_trade et le rendre faux. Nous avons utilisé l’ objet de la classe CAccountInfo pour vérifier si le trade est autorisé et aussi si Les Expert Advisors sont autorisés à trader sur ce compte. On utilise aussi un objet du Classe CSymbolInfo pour vérifier si le terminal est synchronisé avec le serveur du trade
Une fois ces trois conditions réunies, on vérifie alors si le total le nombre de barres actuelles est supérieur au minimum requis pour que notre EA puisse trader Si cette fonction renvoie vrai, alors notre EA effectuera des activités de trade sinon, notre EA ne s'engagera dans aucune activité de trade jusqu'à ce que les conditions dans cette fonction sont réunies
Comme vous l'avez vu, nous avons décidé de inclure toutes les activités de contrôle de trade nécessaires dans cette fonction, en utilisant les objets nécessaires des bibliothèques de classes de trade standard.
2.1.2 La fonction ConfirmMargin
//+------------------------------------------------------------------+ //| Confirms if margin is enough to open an order //+------------------------------------------------------------------+ bool ConfirmMargin(ENUM_ORDER_TYPE otype,double price) { bool confirm = false; double lot_price = myaccount.MarginCheck(_Symbol,otype,Lot,price); // Lot price/ Margin double act_f_mag = myaccount.FreeMargin(); // Account free margin // Check if margin required is okay based on setting if(MathFloor(act_f_mag*TPC)>MathFloor(lot_price)) { confirm =true; } return(confirm); }
Nous utilisons l'objet da la Classe CAccountInfo pour confirmer s'il y a suffisamment de marge pour placer un trade basé sur sur le paramètre que nous n'utiliserons seulement à un certain pourcentage de notre marge libre du compte pour passer une commande
Si le pourcentage requis de la marge libre du compte est supérieure à la marge requise pour la commande, alors cette fonction renvoie vrai, sinon, elle renvoie faux. Par cela, nous voulons seulement passer une commande si la fonction renvoie vrai. Cette fonction prend le type de commande comme paramètre d’entrée.
2.1.3 La fonction checkBuy
//+------------------------------------------------------------------+ //| Checks for a Buy trade Condition | //+------------------------------------------------------------------+ bool checkBuy() { bool dobuy = false; if ((maVal[0]>maVal[1]) && (maVal[1]>maVal[2]) &&(p_close > maVal[1])) { // MA increases upwards and previous price closed above MA if ((adxVal[1]>Adx_Min)&& (plsDI[1]>minDI[1])) { // ADX is greater than minimum and +DI is greater tha -DI for ADX dobuy = true; } } return(dobuy); }
Nous avons décidé de clore les conditions d'ouverture d'une d'achat de trade dans cette fonction. Nous n'avons utilisé aucune des fonctionnalités d’objet de classe Nous vérifions la condition où les valeurs de l'indicateur de moyenne mobile haussent et le prix de clôture de la barre précédente est supérieure à la valeur de la moyenne mobile à ce stade.
Nous souhaitons également une situation où la valeur de l'indicateur ADX est supérieure au minimum requis défini dans les paramètres d'entrée et la valeur de DI positive de L'indicateur ADX est supérieur à la valeur DI négative. Une fois ces conditions réunies, alors nous souhaitons que notre EA ouvre une commande d' ACHAT.
2.1.4 La fonction checkSell
//+------------------------------------------------------------------+ //| Checks for a Sell trade Condition | //+------------------------------------------------------------------+ bool checkSell() { bool dosell = false; if ((maVal[0]<maVal[1]) && (maVal[1]<maVal[2]) &&(p_close < maVal[1])) { // MA decreases downwards and previuos price closed below MA if ((adxVal[1]>Adx_Min)&& (minDI[1]>plsDI[1])) { // ADX is greater than minimum and -DI is greater tha +DI for ADX dosell = true; } } return(dosell); }
Cette fonction vérifie exactement l'inverse de la fonction CheckBuy. De plus, nous n'avons utilisé aucun des objets de classe dans cette fonction. Cette fonction vérifie une condition où les valeurs de l'indicateur de moyenne mobile baissent et le prix de clôture de la barre précédente est inférieure à la valeur de la Moyenne Mobile à ce stade.
Nous souhaitons également une situation où la valeur de l'indicateur ADX est supérieure au minimum requis défini dans les paramètres d'entrée et la valeur de DI négative de L'indicateur ADX est supérieur à la valeur DI positive. Une fois ces conditions réunies, alors nous souhaitons que notre EA ouvre une commande de VENTE.
2.1.5 La fonction checkFermePos//+------------------------------------------------------------------+ //| Checks if an Open position can be closed | //+------------------------------------------------------------------+ bool checkClosePos(string ptype, double Closeprice) { bool mark = false; if (ptype=="BUY") { // Can we close this position if (Closeprice < maVal[1]) // Previous price close below MA { mark = true; } } if (ptype=="SELL") { // Can we close this position if (Closeprice > maVal[1]) // Previous price close above MA { mark = true; } } return(mark); }
Cette fonction est utilisée pour vérifier si la position ouverte actuelle peut être fermée. Cette fonction est utilisée pour surveiller le si le prix de clôture de la barre précédente est supérieur ou inférieur à la valeur de l'indicateur de Moyenne Mobile à ce point (selon la direction dU trade
Si l'une des conditions est réunie, cette fonction renvoie vrai et nous nous attendrons à ce que notre EA ferme la position. Cette fonction a deux paramètres d’entrée, le type d'ordre (cette fois le nom – ACHETER ou VENDRE) et la clôture prix de la barre précédente.
2.1.6 La fonction FermerPosition
//+------------------------------------------------------------------+ //| Checks and closes an open position | //+------------------------------------------------------------------+ bool ClosePosition(string ptype,double clp) { bool marker=false; if(myposition.Select(_Symbol)==true) { if(myposition.Magic()==EA_Magic && myposition.Symbol()==_Symbol) { //--- Check if we can close this position if(checkClosePos(ptype,clp)==true) { //--- close this position and check if we close position successfully? if(mytrade.PositionClose(_Symbol)) //--- Request successfully completed { Alert("An opened position has been successfully closed!!"); marker=true; } else { Alert("The position close request could not be completed - error: ", mytrade.ResultRetcodeDescription()); } } } } return(marker); }
C'est la fonction qui en fait utilise la fonction ci-dessus (checkclosepos). Il utilise les objets des classesCPositionInfo and the CTrade Cette fonction utilise l'objet de la classe CPositionInfo pour vérifier les positions ouvertes disponibles pour la position qui a été ouverte par notre EA et pour le symbole actuel. Si une position est trouvée, il vérifie s'il peut être fermé à l'aide de la fonction checkclosepos.
Si la La fonction checkclosepos renvoie vrai, cette fonction utilise l'objet du CTrade classe pour fermer la position et affiche les résultats de la position clôturez l'opération. Si la position a été clôturée avec succès, cette fonction renvoie vrai, sinon, elle renvoie faux.
La fonction prend deux paramètres d'entrée (le nom de la position , BUY ou SELL et le prix de clôture de la barre précédente). Ces paramètres ont en fait été passés à la fonction checkclosepos qui les utilise.
2.1.7 La fonction VérifierModifier
//+------------------------------------------------------------------+ //| Checks if we can modify an open position | //+------------------------------------------------------------------+ bool CheckModify(string otype,double cprc) { bool check=false; if (otype=="BUY") { if ((maVal[2]<maVal[1]) && (maVal[1]<maVal[0]) && (cprc>maVal[1]) && (adxVal[1]>Adx_Min)) { check=true; } } else if (otype=="SELL") { if ((maVal[2]>maVal[1]) && (maVal[1]>maVal[0]) && (cprc<maVal[1]) && (adxVal[1]>Adx_Min)) { check=true; } } return(check); }
Cette fonction est utilisée pour vérifier pour une condition qui confirme si une position ouverte peut être modifiée ou non. Elle utilise le nom du type de commande et le prix de clôture de la barre précédente comme paramètres d'entrée.
Ce que fait cette fonction est de vérifier si la Moyenne Mobile augmente toujours vers le haut et le prix de clôture de la barre précédente est toujours plus élevé que la valeur moyenne de mouvement à ce point et la valeur de l'ADX est également supérieure au minimum requis (pour une position ACHAT) pendant qu'il vérifie si la Moyenne Mobile est toujours en baisse et le cours de clôture de la barre précédente est plus bas que la valeur de la moyenne mobile à ce point (pour une position de VENTE). En fonction, dépendamment du type de position que nous avons, si l'une des conditions est réunie, l'AE envisagez la modification de la position
La fonction prend deux paramètres d'entrée (le nom de la position, ACHAT ou VENTE, et le prix de clôture de la barre précédente).
2.1.8 La fonction Modifier
//+------------------------------------------------------------------+ //| Modifies an open position | //+------------------------------------------------------------------+ void Modify(string ptype,double stpl,double tkpf) { //--- New Stop Loss, new Take profit, Bid price, Ask Price double ntp,nsl,pbid,pask; long tsp=Trail_point; //--- adjust for 5 & 3 digit prices if(_Digits==5 || _Digits==3) tsp=tsp*10; //--- Stops Level long stplevel= mysymbol.StopsLevel(); //--- Trail point must not be less than stops level if(tsp<stplevel) tsp=stplevel; if(ptype=="BUY") { //--- current bid price pbid=mysymbol.Bid(); if(tkpf-pbid<=stplevel*_Point) { //--- distance to takeprofit less or equal to Stops level? increase takeprofit ntp = pbid + tsp*_Point; nsl = pbid - tsp*_Point; } else { //--- distance to takeprofit higher than Stops level? dont touch takeprofit ntp = tkpf; nsl = pbid - tsp*_Point; } } else //--- this is SELL { //--- current ask price pask=mysymbol.Ask(); if(pask-tkpf<=stplevel*_Point) { ntp = pask - tsp*_Point; nsl = pask + tsp*_Point; } else { ntp = tkpf; nsl = pask + tsp*_Point; } } //--- modify and check result if(mytrade.PositionModify(_Symbol,nsl,ntp)) { //--- Request successfully completed Alert("An opened position has been successfully modified!!"); return; } else { Alert("The position modify request could not be completed - error: ", mytrade.ResultRetcodeDescription()); return; } }
Cette fonction utilise la fonction ci-dessus (checkmodify) pour faire son travail. Il utilise les objets des classes CSymbolInfo et CTrade. Tout d'abord, nous avons déclaré quatre types de données doubles pour tenir le nouveau prise de bénéfice, arrêt de perte, prix de soumissions et demande de prix Ensuite nous avons déclaré un nouveau type de données long tsp pour tenir la valeur Trail_point définie à la section des paramètres d'entrée.
La valeur du point de piste (tsp) a ensuite été ajustée pour 5 et des prix à 3 chiffres. Nous avons ensuite utilisé l'objet CSymbolInfo pour obtenir le niveau des arrêts et assurez-vous que le point de piste que nous souhaitons ajouter n'est pas inférieur à la valeur requise du niveau d'arrêt. S'il est inférieur au niveau des arrêts, nous utiliserons la valeur du niveau des arrêts
Selon le type de poste, nous utilisons l'objet de classe CSymbolInfo pour obtenir le prix BID ou ASK actuel comme il peut en être le cas Si la différence entre le prix BID ou ASK actuel et le le prix de prise de profit initial est inférieur ou égal au niveau des stops, nous décidons d’ ajuster à la fois les prix arrêt de perte et prise de bénéfice, sinon, nous ajustons uniquement la valeur d’arrêt de perte
On utilise alors l’objet de classe CTrade pour modifier l’Arrêt de perte et la prise de bénéficie pour la position Basé sur le code de retour du résultat de la trade, un message de réussite ou d'échec s'affiche également.
Nous avons fini de définir quelques fonctions définies par l'utilisateur qui faciliteront notre travail. Passons maintenant à la section des codes EA.
2.1.9 La section OnInit
//--- set the symbol name for our SymbolInfo Object mysymbol.Name(_Symbol); // Set Expert Advisor Magic No using our Trade Class Object mytrade.SetExpertMagicNumber(EA_Magic); // Set Maximum Deviation using our Trade class object mytrade.SetDeviationInPoints(dev); //--- Get handle for ADX indicator adxHandle=iADX(NULL,0,ADX_Period); //--- Get the handle for Moving Average indicator maHandle=iMA(_Symbol,Period(),MA_Period,0,MODE_EMA,PRICE_CLOSE); //--- What if handle returns Invalid Handle if(adxHandle<0 || maHandle<0) { Alert("Error Creating Handles for MA, ADX indicators - error: ",GetLastError(),"!!"); return(1); } STP = StopLoss; TKP = TakeProfit; //--- Let us handle brokers that offers 5 or 3 digit prices instead of 4 if(_Digits==5 || _Digits==3) { STP = STP*10; TKP = TKP*10; } //--- Set trade percent TPC = TradePct; TPC = TPC/100; //---
Nous décidons de définir le symbole actuel de l'objet de classe CSymbolInfo. Nous avons également mis en place la magie Expert Advisor nombre et l'écart (en points) à l'aide de l'objet de classe CTrade. Après ça nous décidons d'obtenir les poignées de nos indicateurs et d'afficher une erreur si l’obtention des poignées échoue.
Ensuite, nous décidons d'ajuster l’ arrêt de perte et prise de bénéficie pour les prix à 3 et 5 chiffres et nous convertissons également le pourcentage de marge de compte gratuit à utiliser pour le trade en pourcentage.
2.1.10 La section OnDeinit
//--- Release our indicator handles IndicatorRelease(adxHandle); IndicatorRelease(maHandle);
Ici, nous décidons de lâcher toutes les poignées de l'indicateur.
2.1.11. La section OnTick
//--- check if EA can trade if (checkTrading() == false) { Alert("EA cannot trade because certain trade requirements are not meant"); return; } //--- Define the MQL5 MqlRates Structure we will use for our trade MqlRates mrate[]; // To be used to store the prices, volumes and spread of each bar /* Let's make sure our arrays values for the Rates, ADX Values and MA values is store serially similar to the timeseries array */ // the rates arrays ArraySetAsSeries(mrate,true); // the ADX values arrays ArraySetAsSeries(adxVal,true); // the MA values arrays ArraySetAsSeries(maVal,true); // the minDI values array ArraySetAsSeries(minDI,true); // the plsDI values array ArraySetAsSeries(plsDI,true);
La première chose que nous faisons ici est de vérifier et de nous assurer que notre EA devra trader ou non. Si le fonction checktrade renvoie faux, EA attendra le prochain tick et effectuera la vérification à nouveau.
Après cela, nous avons déclaré un MQL5 MqlRates Structure pour obtenir les prix de chaque barre puis nous utilisons la fonction ArraySetAsSeries pour définir tous les tableaux requis.
//--- Get the last price quote using the SymbolInfo class object function if (!mysymbol.RefreshRates()) { Alert("Error getting the latest price quote - error:",GetLastError(),"!!"); return; } //--- Get the details of the latest 3 bars if(CopyRates(_Symbol,_Period,0,3,mrate)<0) { Alert("Error copying rates/history data - error:",GetLastError(),"!!"); return; } //--- EA should only check for new trade if we have a new bar // lets declare a static datetime variable static datetime Prev_time; // lest get the start time for the current bar (Bar 0) datetime Bar_time[1]; //copy the current bar time Bar_time[0] = mrate[0].time; // We don't have a new bar when both times are the same if(Prev_time==Bar_time[0]) { return; } //Save time into static varaiable, Prev_time = Bar_time[0];
Nous utilisons l’objet de classe CSymbolInfo pour obtenir les cotations de prix actuelles, puis copier les prix des barres actuels dans le tableau mrates. Immédiatement après cela, nous décidons de vérifier la présence de une nouvelle barre.
Si nous avons une nouvelle barre, notre EA vérifiera si un ACHAT ou La condition de VENTE a été réunie, sinon elle attendra que nous ayons une nouvelle barre.
//--- Copy the new values of our indicators to buffers (arrays) using the handle if(CopyBuffer(adxHandle,0,0,3,adxVal)<3 || CopyBuffer(adxHandle,1,0,3,plsDI)<3 || CopyBuffer(adxHandle,2,0,3,minDI)<3) { Alert("Error copying ADX indicator Buffers - error:",GetLastError(),"!!"); return; } if(CopyBuffer(maHandle,0,0,3,maVal)<3) { Alert("Error copying Moving Average indicator buffer - error:",GetLastError()); return; } //--- we have no errors, so continue // Copy the bar close price for the previous bar prior to the current bar, that is Bar 1 p_close=mrate[1].close; // bar 1 close price
Ici, nous avons utilisé les fonctions CopyBuffer pour obtenir les tampons de nos indicateurs dans des tableaux et si une erreur se produit dans le processus, elle sera affichée. Le prix de clôture de la barre précédente a été copié.
//--- Do we have positions opened already? bool Buy_opened = false, Sell_opened=false; if (myposition.Select(_Symbol) ==true) // we have an opened position { if (myposition.Type()== POSITION_TYPE_BUY) { Buy_opened = true; //It is a Buy // Get Position StopLoss and Take Profit double buysl = myposition.StopLoss(); // Buy position Stop Loss double buytp = myposition.TakeProfit(); // Buy position Take Profit // Check if we can close/modify position if (ClosePosition("BUY",p_close)==true) { Buy_opened = false; // position has been closed return; // wait for new bar } else { if (CheckModify("BUY",p_close)==true) // We can modify position { Modify("BUY",buysl,buytp); return; // wait for new bar } } } else if(myposition.Type() == POSITION_TYPE_SELL) { Sell_opened = true; // It is a Sell // Get Position StopLoss and Take Profit double sellsl = myposition.StopLoss(); // Sell position Stop Loss double selltp = myposition.TakeProfit(); // Sell position Take Profit if (ClosePosition("SELL",p_close)==true) { Sell_opened = false; // position has been closed return; // wait for new bar } else { if (CheckModify("SELL",p_close)==true) // We can modify position { Modify("SELL",sellsl,selltp); return; //wait for new bar } } } }
Nous utilisons l’objet de classe CPositionInfo pour sélectionner et vérifier si nous avons une position ouverte pour le symbole actuel. Si une position existe et qu’il s’agit d’un ACHAT, nous définissons Buy_opened s’avérer vrai et en suite utilisez le CPositionInfo objet de classe pour obtenir arrêt de perte et prise de bénéfice de la position En utilisant une fonction que nous avions définie précédemment, ClosePosition, nous avons vérifié si la position peut être close Si la fonction retourne vrai, alors la position a été close nous avons donc défini Buy_opened à faux, la position d' ACHAT initiale vient tout juste d’être clôturée L'EA attend maintenant une nouvelle tique.
Cependant, si la fonction renvoie faux, alors la position n'a pas été clôturée. Il est maintenant temps de vérifier si nous pouvons modifier la position. Nous y sommes parvenus en utilisant la fonction CheckModify que nous avions définie précédemment. Si la fonction renvoie vrai, cela indique que la position peut être modifiée, donc nous utilisons la fonction Modifier pour modifier la position.
Si, d’autre part, une position existe et c'est une VENTE, nous définissons Sell_opened à vrai et utilisons l'objet de classe CPositionInfo pour obtenir l’arrêt de perte et prise de bénéfice de la position Nous avons répété la même étape que nous avons fait pour la position ACHETER afin de vérifier si la position peut être fermée ou modifiée
if(checkBuy()==true) { //--- any opened Buy position? if(Buy_opened) { Alert("We already have a Buy position!!!"); return; //--- Don't open a new Sell Position } double mprice=NormalizeDouble(mysymbol.Ask(),_Digits); //--- latest ask price double stloss = NormalizeDouble(mysymbol.Ask() - STP*_Point,_Digits); //--- Stop Loss double tprofit = NormalizeDouble(mysymbol.Ask()+ TKP*_Point,_Digits); //--- Take Profit //--- check margin if(ConfirmMargin(ORDER_TYPE_BUY,mprice)==false) { Alert("You do not have enough money to place this trade based on your setting"); return; } //--- open Buy position and check the result if(mytrade.Buy(Lot,_Symbol,mprice,stloss,tprofit)) //if(mytrade.PositionOpen(_Symbol,ORDER_TYPE_BUY,Lot,mprice,stloss,tprofit)) { //--- Request is completed or order placed Alert("A Buy order has been successfully placed with deal Ticket#:", mytrade.ResultDeal(),"!!"); } else { Alert("The Buy order request at vol:",mytrade.RequestVolume(), ", sl:", mytrade.RequestSL(),", tp:",mytrade.RequestTP(), ", price:", mytrade.RequestPrice(), " could not be completed -error:",mytrade.ResultRetcodeDescription()); return; } }
Ou nous pouvons utiliser la fonction PositionOpen
if(checkBuy()==true) { //--- any opened Buy position? if(Buy_opened) { Alert("We already have a Buy position!!!"); return; //--- Don't open a new Sell Position } double mprice=NormalizeDouble(mysymbol.Ask(),_Digits); //--- latest Ask price double stloss = NormalizeDouble(mysymbol.Ask() - STP*_Point,_Digits); //--- Stop Loss double tprofit = NormalizeDouble(mysymbol.Ask()+ TKP*_Point,_Digits); //--- Take Profit //--- check margin if(ConfirmMargin(ORDER_TYPE_BUY,mprice)==false) { Alert("You do not have enough money to place this trade based on your setting"); return; } //--- open Buy position and check the result //if(mytrade.Buy(Lot,_Symbol,mprice,stloss,tprofit)) if(mytrade.PositionOpen(_Symbol,ORDER_TYPE_BUY,Lot,mprice,stloss,tprofit)) { //--- Request is completed or order placed Alert("A Buy order has been successfully placed with deal Ticket#:", mytrade.ResultDeal(),"!!"); } else { Alert("The Buy order request at vol:",mytrade.RequestVolume(), ", sl:", mytrade.RequestSL(),", tp:",mytrade.RequestTP(), ", price:", mytrade.RequestPrice(), " could not be completed -error:",mytrade.ResultRetcodeDescription()); return; } }
Ici, on utilise la fonction checkbuy pour vérifier une configuration d'achat et si il retourne vrai, alors nos conditions de trade ACHETER ont été réunies Si nous avons déjà une position d'ACHAT, nous ne souhaitons pas passer une nouvelle commande. Nous avons ensuite utilisé l'objet de classe CSymbolInfo pour obtenir le prix ASK actuel et calculer l’arrêt de perte et la prise de bénéfice comme requis.
Nous utilisons également la fonction ConfirmMargin pour vérifier si le pourcentage du compte autorisé pour passer une commande est supérieur à la marge requise pour passer cette commande. Si la fonction renvoie vrai, alors nous allons de l'avant et placerons le trade sinon, nous ne placerons pas le trade.
En utilisant l'objet de classeCTrade , nous plaçons notre commande et utilisons le même objet d'appels pour obtenir l'opération de trade Code de retour En fonction du résultat de la trade, un message s'affiche.
if(checkSell()==true) { //--- any opened Sell position? if(Sell_opened) { Alert("We already have a Sell position!!!"); return; //--- Wait for a new bar } double sprice=NormalizeDouble(mysymbol.Bid(),_Digits); //--- latest Bid price double ssloss=NormalizeDouble(mysymbol.Bid()+STP*_Point,_Digits); //--- Stop Loss double stprofit=NormalizeDouble(mysymbol.Bid()-TKP*_Point,_Digits); //--- Take Profit //--- check margin if(ConfirmMargin(ORDER_TYPE_SELL,sprice)==false) { Alert("You do not have enough money to place this trade based on your setting"); return; } //--- Open Sell position and check the result if(mytrade.Sell(Lot,_Symbol,sprice,ssloss,stprofit)) //if(mytrade.PositionOpen(_Symbol,ORDER_TYPE_SELL,Lot,sprice,ssloss,stprofit)) { //---Request is completed or order placed Alert("A Sell order has been successfully placed with deal Ticket#:",mytrade.ResultDeal(),"!!"); } else { Alert("The Sell order request at Vol:",mytrade.RequestVolume(), ", sl:", mytrade.RequestSL(),", tp:",mytrade.RequestTP(), ", price:", mytrade.RequestPrice(), " could not be completed -error:",mytrade.ResultRetcodeDescription()); return; } }
Ou nous pouvons également utiliser la fonction PositionOpen :
if(checkSell()==true) { //--- any opened Sell position? if(Sell_opened) { Alert("We already have a Sell position!!!"); return; //--- Wait for a new bar } double sprice=NormalizeDouble(mysymbol.Bid(),_Digits); //--- latest Bid price double ssloss=NormalizeDouble(mysymbol.Bid()+STP*_Point,_Digits); //--- Stop Loss double stprofit=NormalizeDouble(mysymbol.Bid()-TKP*_Point,_Digits); //--- Take Profit //--- check margin if(ConfirmMargin(ORDER_TYPE_SELL,sprice)==false) { Alert("You do not have enough money to place this trade based on your setting"); return; } //--- Open Sell position and check the result //if(mytrade.Sell(Lot,_Symbol,sprice,ssloss,stprofit)) if(mytrade.PositionOpen(_Symbol,ORDER_TYPE_SELL,Lot,sprice,ssloss,stprofit)) { //---Request is completed or order placed Alert("A Sell order has been successfully placed with deal Ticket#:",mytrade.ResultDeal(),"!!"); } else { Alert("The Sell order request at Vol:",mytrade.RequestVolume(), ", sl:", mytrade.RequestSL(),", tp:",mytrade.RequestTP(), ", price:", mytrade.RequestPrice(), " could not be completed -error:",mytrade.ResultRetcodeDescription()); return; } }
Tout comme nous l'avons fait pour l' ACHAT, nous avons utilisé la fonction Checksell pour vérifier une configuration de vente. S'il retournevrai et nous n'avons pas de position de vente déjà ouverte, nous avons utilisé le ConfirmMargin fonction pour vérifier si nous avons assez d'argent pour ouvrir la commande. Si ConfirmMargin renvoie vrai, l'objet de classe CTrade est utilisé pour passer la commande et basé sur la réponse du serveur du trade, le résultat du trade est affiché en utilisant les fonctions d'objet de classe CTrade.
Jusqu'à présent, nous avons examiné comment nous pouvons utiliser les bibliothèques de classe Trade pour écrire un Expert Advisor. La chose suivante est de tester notre Expert Advisor avec le testeur de stratégie et de constater ses performances.
Compilez le code EA, puis chargez-le dans le Testeur de Stratégie
Figure 3. Rapport de compilation d'un Expert Advisor
Sur le graphique quotidien GBPUSD en utilisant les paramètres par défaut : Prise de Bénéfice- 270, Arrêt de Perte - 100 et Point de pistes (TP/SL) - 32, on a les résultats suivants :
Figure 4. Rapport de test Expert Advisor - Graphique quotidien GBPUSD
Figure 5. Résultat du graphique du test Expert Advisor - Graphique quotidien GBPUSD
Figure 6. Le rapport de test d'Expert Advisor montre une modification des positions ouvertes - Graphique quotidien GBPUSD
Figure 7. Rapport de graphique de test d'Expert Advisor pour le graphique quotidien GBPUSD
Vous êtes libre de tester l'EA sur tout autre graphique quotidien de symboles avec différents paramètres de réglage de Prise de Bénéfice et, Arrêt de perte et le point de Piste et voyez ce que vous obtenez.
Cependant, vous devez comprendre que cet Expert Advisor a été rédigé à des fins de test uniquement...
Voyons maintenant comment nous pouvons utiliser les autres classes ((COrderInfo, , CHistoryOrderInfo,, et CDealInfo) pour obtenir les détails de la commande/du deal.
2.2 Ouverture/Suppression une Commande en Cours
Dans cet exemple, nous rédigerons un simple Expert Advisor qui passera une commande en cours (BuyStop ou SellStop) lorsque les conditions de configuration d'achat ou de vente sont respectivement réunies.
2.2.1 Inclure les classes requises
//+------------------------------------------------------------------+ //| Include ALL classes that will be used | //+------------------------------------------------------------------+ //--- The Trade Class #include <Trade\Trade.mqh> //--- The PositionInfo Class #include <Trade\PositionInfo.mqh> //--- The SymbolInfo Class #include <Trade\SymbolInfo.mqh> //--- The OrderInfo Class #include <Trade\OrderInfo.mqh>
Nous avons inclus les quatre classes que nous utiliserons dans ce simple Expert Advisor. eIles ont été expliquées dans les exemples ci-dessus.
Je n'expliquerai pas chaque section de cet Expert Advisor car elle est similaire à celle expliquée ci-dessus, cependant, je passerai en revue la partie essentielle de l'Expert Advisor qui explique ce que nous souhaitons discuter dans cette section.
La seule différence est que nous avons décidé de déclarer MqlRates mrate[] sur une portée globale.
//--- Define the MQL5 MqlRates Structure we will use for our trade MqlRates mrate[]; // To be used to store the prices, volumes and spread of each bar
Une fois que nous avons inclus les classes, nous devons également penser à créer des objets de chaque classe :
//+------------------------------------------------------------------+ //| CREATE CLASS OBJECTS | //+------------------------------------------------------------------+ //--- The CTrade Class Object CTrade mytrade; //--- The CPositionInfo Class Object CPositionInfo myposition; //--- The CSymbolInfo Class Object CSymbolInfo mysymbol; //--- The COrderInfo Class Object COrderInfo myorder;
Les fonctions CheckBuy() and CheckSell()sont les mêmes que dans l'Expert Advisor expliquées précédemment.
Ce que nous souhaitons faire ici, c'est passer un commande BUYSTOP lorsque nous avons une configuration d'achat et une commande SELLSTOP lorsque nous avons une configuration de vente.
Passons maintenant en revue certaines des fonctions que nous avons créées pour nous faciliter la tâche.
2.2.2 La fonction CountOrders
//+------------------------------------------------------------------+ //| Count Total Orders for this expert/symbol | //+------------------------------------------------------------------+ int CountOrders() { int mark=0; for(int i=OrdersTotal()-1; i>=0; i--) { if(myorder.Select(OrderGetTicket(i))) { if(myorder.Magic()==EA_Magic && myorder.Symbol()==_Symbol) mark++; } } return(mark); }
Cette fonction est utilisée pour obtenir le total des commandes en cours disponibles à un moment donné.
Nous avons utilisé l'objet de notre classe COrderInfo pour vérifier les détails de la commande si elle est sélectionnée avec succès avec la fonction myorder.Select().
Si le retour Magique par notre objet de classe et le symbole retourné est ce que nous recherchons, alors la commande a été passée par notre Expert Advisor, elle est donc comptée et stockée dans la variable mark.
2.2.3 La fonction DeletePending
//+------------------------------------------------------------------+ //| Checks and Deletes a pending order | //+------------------------------------------------------------------+ bool DeletePending() { bool marker=false; //--- check all pending orders for(int i=OrdersTotal()-1; i>=0; i--) { if(myorder.Select(OrderGetTicket(i))) { if(myorder.Magic()==EA_Magic && myorder.Symbol()==_Symbol) { //--- check if order has stayed more than two bars time if(myorder.TimeSetup()<mrate[2].time) { //--- delete this pending order and check if we deleted this order successfully? if(mytrade.OrderDelete(myorder.Ticket())) //Request successfully completed { Alert("A pending order with ticket #", myorder.Ticket(), " has been successfully deleted!!"); marker=true; } else { Alert("The pending order # ",myorder.Ticket(), " delete request could not be completed - error: ",mytrade.ResultRetcodeDescription()); } } } } } return(marker); }
Tout comme la fonction du compteur de commande cette fonction utilise également les fonctions de la classe COrderInfo pour obtenir les Propriétés des commandes La fonction vérifie toute commande en cours qui a été configurée trois barres avant (le temps de configuration de la commande en cours est inférieur à mrate[2].time) et n'a pas encore été déclenchée.
Si une commande tombe dans cette catégorie, la fonction de classe CTrade OrderDelete est utilisée pour supprimer la commande. Cette fonction renvoie vrai en cas de succès et faux dans le cas contraire.
Les deux fonctions ci-dessus sont utilisées immédiatement après la formation d'une nouvelle barre, avant de rechercher une nouvelle configuration du trade Nous souhaitons nous assurer que nous n'avons pas plus de trois commandes en cours passées à chaque instant. Pour ce faire, nous utilisons le code suivant :
// do we have more than 3 already placed pending orders if (CountOrders()>3) { DeletePending(); return; }
2.2.4 Passer une Commande en Cours
if(checkBuy()==true) { Alert("Total Pending Orders now is :",CountOrders(),"!!"); //--- any opened Buy position? if(Buy_opened) { Alert("We already have a Buy position!!!"); return; //--- Don't open a new Sell Position } //Buy price = bar 1 High + 2 pip + spread int sprd=mysymbol.Spread(); double bprice =mrate[1].high + 10*_Point + sprd*_Point; double mprice=NormalizeDouble(bprice,_Digits); //--- Buy price double stloss = NormalizeDouble(bprice - STP*_Point,_Digits); //--- Stop Loss double tprofit = NormalizeDouble(bprice+ TKP*_Point,_Digits); //--- Take Profit //--- open BuyStop order if(mytrade.BuyStop(Lot,mprice,_Symbol,stloss,tprofit)) //if(mytrade.OrderOpen(_Symbol,ORDER_TYPE_BUY_STOP,Lot,0.0,bprice,stloss,tprofit,ORDER_TIME_GTC,0)) { //--- Request is completed or order placed Alert("A BuyStop order has been successfully placed with Ticket#:",mytrade.ResultOrder(),"!!"); return; } else { Alert("The BuyStop order request at vol:",mytrade.RequestVolume(), ", sl:", mytrade.RequestSL(),", tp:",mytrade.RequestTP(), ", price:", mytrade.RequestPrice(), " could not be completed -error:",mytrade.ResultRetcodeDescription()); return; } }
Ou nous pouvons également utiliser la fonction OrderOpen pour passer la commande BUYSTOP
if(checkBuy()==true) { Alert("Total Pending Orders now is :",CountOrders(),"!!"); //--- any opened Buy position? if(Buy_opened) { Alert("We already have a Buy position!!!"); return; //--- Don't open a new Sell Position } //Buy price = bar 1 High + 2 pip + spread int sprd=mysymbol.Spread(); double bprice =mrate[1].high + 10*_Point + sprd*_Point; double mprice=NormalizeDouble(bprice,_Digits); //--- Buy price double stloss = NormalizeDouble(bprice - STP*_Point,_Digits); //--- Stop Loss double tprofit = NormalizeDouble(bprice+ TKP*_Point,_Digits); //--- Take Profit //--- open BuyStop order //if(mytrade.BuyStop(Lot,mprice,_Symbol,stloss,tprofit)) if(mytrade.OrderOpen(_Symbol,ORDER_TYPE_BUY_STOP,Lot,0.0,bprice,stloss,tprofit,ORDER_TIME_GTC,0)) { //--- Request is completed or order placed Alert("A BuyStop order has been successfully placed with Ticket#:",mytrade.ResultOrder(),"!!"); return; } else { Alert("The BuyStop order request at vol:",mytrade.RequestVolume(), ", sl:", mytrade.RequestSL(),", tp:",mytrade.RequestTP(), ", price:", mytrade.RequestPrice(), " could not be completed -error:",mytrade.ResultRetcodeDescription()); return; } }
En passant notre commande BUYSTOP, le prix d'ouverture est le Bar 1 High + 2pip + spread.
Rappelez-vous que le prix affiché sur le graphique est le prix BID et en passant des commandes longs/d'achat dont vous avez besoin le prix ASK, c'est pourquoi nous décidons d'ajouter le spread au Bar 1 High pour que ce que nous ayons maintenant est le prix Ask correspondant + 2pip. L’arrêt de perte et La prise de profit ont déjà été définis dans les paramètres d'entrée.
Une fois que nous avons préparé tous les paramètres nécessaires, nous utilisons la fonction de classe CTrade BuyStop ou OrderOpen pour placer notre commande Le type d'ordre ici est ORDER_TYPE_BUY_STOP (commande d'achat stop). Nous utilisons le même prix pour le prix limite mais il ne s'agit pas d'une commande BuyLimit. Nous fixons également la durée de validité de la commande à ORDER_TIME_GTC, ce qui signifie que les commandes restent valides jusqu'à ce qu’elles soient annulées.
Si vous utilisez ORDER_TIME_GTC ou ORDER_TIME_DAY, il n'y a pas besoin d’indiquer l'heure d'expiration, c'est pourquoi nous définissons l'heure d'expiration à 0.
if(checkSell()==true) { Alert("Total Pending Orders now is :",CountOrders(),"!!"); //--- any opened Sell position? if(Sell_opened) { Alert("We already have a Sell position!!!"); return; //--- Wait for a new bar } //--- Sell price = bar 1 Low - 2 pip double sprice=mrate[1].low-10*_Point; double slprice=NormalizeDouble(sprice,_Digits); //--- Sell price double ssloss=NormalizeDouble(sprice+STP*_Point,_Digits); //--- Stop Loss double stprofit=NormalizeDouble(sprice-TKP*_Point,_Digits); //--- Take Profit //--- Open SellStop Order if(mytrade.SellStop(Lot,slprice,_Symbol,ssloss,stprofit)) //if(mytrade.OrderOpen(_Symbol,ORDER_TYPE_SELL_STOP,Lot,0.0,slprice,ssloss,stprofit,ORDER_TIME_GTC,0)) { //--- Request is completed or order placed Alert("A SellStop order has been successfully placed with Ticket#:",mytrade.ResultOrder(),"!!"); return; } else { Alert("The SellStop order request at Vol:",mytrade.RequestVolume(), ", sl:", mytrade.RequestSL(),", tp:",mytrade.RequestTP(), ", price:", mytrade.RequestPrice(), " could not be completed -error:",mytrade.ResultRetcodeDescription()); return; } }
Ou nous pouvons également utiliser la fonction OrderOpen pour passer la commande :
if(checkSell()==true) { Alert("Total Pending Orders now is :",CountOrders(),"!!"); //--- any opened Sell position? if(Sell_opened) { Alert("We already have a Sell position!!!"); return; //--- Wait for a new bar } //--- Sell price = bar 1 Low - 2 pip double sprice=mrate[1].low-10*_Point; double slprice=NormalizeDouble(sprice,_Digits); //--- Sell price double ssloss=NormalizeDouble(sprice+STP*_Point,_Digits); //--- Stop Loss double stprofit=NormalizeDouble(sprice-TKP*_Point,_Digits); //--- Take Profit //--- Open SellStop Order //if(mytrade.SellStop(Lot,slprice,_Symbol,ssloss,stprofit)) if(mytrade.OrderOpen(_Symbol,ORDER_TYPE_SELL_STOP,Lot,0.0,slprice,ssloss,stprofit,ORDER_TIME_GTC,0)) { //--- Request is completed or order placed Alert("A SellStop order has been successfully placed with Ticket#:",mytrade.ResultOrder(),"!!"); return; } else { Alert("The SellStop order request at Vol:",mytrade.RequestVolume(), ", sl:", mytrade.RequestSL(),", tp:",mytrade.RequestTP(), ", price:", mytrade.RequestPrice(), " could not be completed -error:",mytrade.ResultRetcodeDescription()); return; } }
Tout comme la commande BuyStop, le prix d'ouverture est Bar 1 low + 2pip. Ici, nous n'avons pas besoin d'ajouter spread, car, normalement, nous avons besoin du prix BID pour passer des commandes à découvert/vente.
Nous utilisons également la même fonction OrderOpen ou la fonction SellStop pour passer la commande SellStop. La commande tapez ici ORDER_TYPE_SELL_STOP (commande de vente stop).
Vous trouverez ci-dessous les résultats de notre simple Expert Advisor.
Figure 8. Le rapport de test pour la commande en attente EA
Figure 9 - Le rapport graphique pour l'EA
Figure 10. Le rapport Chart pour l'EA
2.3 Obtenir une commande/un deal Détails
Dans cet exemple, nous montrerons comment nous pouvons obtenir les détails d'une commande une fois qu'elle a été déclenchée.
À ce stade ce n'est plus une commande en cours car elle a été déclenchée et transformée en un deal
Pour bien comprendre cette procédure, jetons un coup d’œil sur le détail du journal d'un de nos trades :
Figure 11. Procédure de traitement des commandes
- Étape 1: Une commande en cours est passée en attendant que des conditions se réunissent (Commande en cours)
- Étape 2: La condition est réunie, commande en cours est déclenchée, un deal est conclu (Commande en cours est maintenant dans l'historique)
- Étape 3. Le deal est conclu et nous avons une Ouverture de Position (Le deal est maintenant dans l’historique)
2.3.1 Obtention des propriétés de la commande (historique)
//+------------------------------------------------------------------+ //| Include ALL classes that will be used | //+------------------------------------------------------------------+ //--- The Trade Class #include <Trade\HistoryOrderInfo.mqh> //+------------------------------------------------------------------+ //| CREATE CLASS OBJECT | //+------------------------------------------------------------------+ //--- The HistoryOrderInfo Class Object CHistoryOrderInfo myhistory; //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ void OnStart() { //--- Get all orders in History and get their details int buystop=0; int sellstop=0; int buylimit=0; int selllimit=0; int buystoplimit=0; int sellstoplimit=0; int buy=0; int sell=0; int s_started=0; int s_placed=0; int s_cancelled=0; int s_partial=0; int s_filled=0; int s_rejected=0; int s_expired=0; ulong o_ticket; // Get all history records if(HistorySelect(0,TimeCurrent())) // get all history orders { // Get total orders in history for(int j=HistoryOrdersTotal(); j>0; j--) { // select order by ticket o_ticket=HistoryOrderGetTicket(j); if(o_ticket>0) { // Set order Ticket to work with myhistory.Ticket(o_ticket); Print("Order index ",j," Order Ticket is: ",myhistory.Ticket()," !"); Print("Order index ",j," Order Setup Time is: ",TimeToString(myhistory.TimeSetup())," !"); Print("Order index ",j," Order Open Price is: ",myhistory.PriceOpen()," !"); Print("Order index ",j," Order Symbol is: ",myhistory.Symbol() ," !"); Print("Order index ",j," Order Type is: ", myhistory.Type() ," !"); Print("Order index ",j," Order Type Description is: ",myhistory.TypeDescription()," !"); Print("Order index ",j," Order Magic is: ",myhistory.Magic()," !"); Print("Order index ",j," Order Time Done is: ",myhistory.TimeDone()," !"); Print("Order index ",j," Order Initial Volume is: ",myhistory.VolumeInitial()," !"); // // if(myhistory.Type() == ORDER_TYPE_BUY_STOP) buystop++; if(myhistory.Type() == ORDER_TYPE_SELL_STOP) sellstop++; if(myhistory.Type() == ORDER_TYPE_BUY) buy++; if(myhistory.Type() == ORDER_TYPE_SELL) sell++; if(myhistory.Type() == ORDER_TYPE_BUY_LIMIT) buylimit++; if(myhistory.Type() == ORDER_TYPE_SELL_LIMIT) selllimit++; if(myhistory.Type() == ORDER_TYPE_BUY_STOP_LIMIT) buystoplimit++; if(myhistory.Type() == ORDER_TYPE_SELL_STOP_LIMIT) sellstoplimit++; if(myhistory.State() == ORDER_STATE_STARTED) s_started++; if(myhistory.State() == ORDER_STATE_PLACED) s_placed++; if(myhistory.State() == ORDER_STATE_CANCELED) s_cancelled++; if(myhistory.State() == ORDER_STATE_PARTIAL) s_partial++; if(myhistory.State() == ORDER_STATE_FILLED) s_filled++; if(myhistory.State() == ORDER_STATE_REJECTED) s_rejected++; if(myhistory.State() == ORDER_STATE_EXPIRED) s_expired++; } } } // Print summary Print("Buy Stop Pending Orders : ",buystop); Print("Sell Stop Pending Orders: ",sellstop); Print("Buy Orders : ",buy); Print("Sell Orders: ",sell); Print("Total Orders in History is :",HistoryOrdersTotal()," !"); Print("Orders type summary"); Print("Market Buy Orders: ",buy); Print("Market Sell Orders: ",sell); Print("Pending Buy Stop: ",buystop); Print("Pending Sell Stop: ",sellstop); Print("Pending Buy Limit: ",buylimit); Print("Pending Sell Limit: ",selllimit); Print("Pending Buy Stop Limit: ",buystoplimit); Print("Pending Sell Stop Limit: ",sellstoplimit); Print("Total orders:",HistoryOrdersTotal()," !"); Print("Orders state summary"); Print("Checked, but not yet accepted by broker: ",s_started); Print("Accepted: ",s_placed); Print("Canceled by client: ",s_cancelled); Print("Partially executed: ",s_partial); Print("Fully executed: ",s_filled); Print("Rejected: ",s_rejected); Print("Expired: ",s_expired); }
Ceci est juste un script simple qui montre comment obtenir les détails des commandes dans nos enregistrements d'historique. Nous avons inclus la classe CHistoryOrderInfo et avons créé un objet de la classe.
Nous utilisons maintenant l'objet pour obtenir les détails des commandes.
Figure 12. Résultat du script de l’historique de la commande
2.3.2 Obtention des propriétés du deal (historique)
//+------------------------------------------------------------------+ //| Include ALL classes that will be used | //+------------------------------------------------------------------+ //--- The CDealInfo Class #include <Trade\DealInfo.mqh> //+------------------------------------------------------------------+ //| Create class object | //+------------------------------------------------------------------+ //--- The CDealInfo Class Object CDealInfo mydeal; //+------------------------------------------------------------------+ //| Script program start function | //+------------------------------------------------------------------+ void OnStart() { //--- Get all deals in History and get their details int buy=0; int sell=0; int deal_in=0; int deal_out=0; ulong d_ticket; // Get all history records if (HistorySelect(0,TimeCurrent())) { // Get total deals in history for (int j=HistoryDealsTotal(); j>0; j--) { // select deals by ticket if (d_ticket = HistoryDealGetTicket(j)) { // Set Deal Ticket to work with mydeal.Ticket(d_ticket); Print("Deal index ", j ," Deal Ticket is: ", mydeal.Ticket() ," !"); Print("Deal index ", j ," Deal Execution Time is: ", TimeToString(mydeal.Time()) ," !"); Print("Deal index ", j ," Deal Price is: ", mydeal.Price() ," !"); Print("Deal index ", j ," Deal Symbol is: ", mydeal.Symbol() ," !"); Print("Deal index ", j ," Deal Type Description is: ", mydeal.TypeDescription() ," !"); Print("Deal index ", j ," Deal Magic is: ", mydeal.Magic() ," !"); Print("Deal index ", j ," Deal Time is: ", mydeal.Time() ," !"); Print("Deal index ", j ," Deal Initial Volume is: ", mydeal.Volume() ," !"); Print("Deal index ", j ," Deal Entry Type Description is: ", mydeal.EntryDescription() ," !"); Print("Deal index ", j ," Deal Profit is: ", mydeal.Profit() ," !"); // if (mydeal.Entry() == DEAL_ENTRY_IN) deal_in++; if (mydeal.Entry() == DEAL_ENTRY_OUT) deal_out++; if (mydeal.Type() == DEAL_TYPE_BUY) buy++; if (mydeal.Type() == DEAL_TYPE_SELL) sell++; } } } // Print Summary Print("Total Deals in History is :", HistoryDealsTotal(), " !"); Print("Total Deal Entry IN is : ", deal_in); Print("Total Deal Entry OUT is: ", deal_out); Print("Total Buy Deal is : ", buy); Print("Total Sell Deal is: ", sell); }
C'est aussi un script simple qui montre comment obtenir les détails de nos registres de deals.
Figure 13. Le résultat du script de l’historique du deal
Conclusion
Dans cet article, nous avons été en mesure d'examiner les principales fonctions des bibliothèques Standard Trade Class et d'avoir démontré comment certaines de ces fonctionnalités peuvent être utilisées en écriture Expert Advisors qui implémente la modification de position, la passation de commande en attente et suppression et vérification de la Marge avant de passer un deal
Nous avons aussi démontré comment elles peuvent être utilisées pour obtenir les détails des commandes et des deals. Il y a certaines de ces fonctions que nous n'avons pas utilisées dans le cours d'écriture notre Expert Advisor, selon le type de stratégie de trading que vous employez, vous pouvez utiliser plus ou moins que ce que nous avons utilisé dans cet exemple.
Ce sera une bonne idée de revoir la section de description des différentes fonctions et de voir comment vous pouvez les utiliser pour rédiger votre propre Expert Advisor.
Les Bibliothèques de classe Standard sont destinées à faciliter la vie des traders et des développeurs, donc assurez-vous de les utiliser.
Traduit de l’anglais par MetaQuotes Ltd.
Article original : https://www.mql5.com/en/articles/138
Contrôler la Pente de la Courbe d' Équilibre Pendant le Travail d'un Expert Advisor
Utilisation de la fonction TesterWithdrawal() pour modéliser les retraits de bénéfice.
Comment créer rapidement un Expert Advisor pour le championnat de trading automatisé 2010
La Méthode Optimale pour le calcul du volume total de la position par Nombre Magique Indiqué
- Applications de trading gratuites
- Plus de 8 000 signaux à copier
- Actualités économiques pour explorer les marchés financiers
Vous acceptez la politique du site Web et les conditions d'utilisation