Comment vérifier si une commande est sélectionnée - page 12

Nouveau commentaire
 
grell:

C'est ce que je veux dire. Mes fonctions ne sont pas polyvalentes, chacune est strictement dédiée à sa propre activité. Même l'achat et la vente sont séparés. Alors, que les numéros de commande changent, que les arrêts se multiplient, mais le billet et le magicien resteront.

Eh bien, tu t'es emporté avec le slosoll :)
 
tara:

Eh bien, tu t'es emporté avec le clobbering :)

Il n'y a pas encore eu de manquement. Je suis un tyran à cet égard :)
 
tara:
Non, pas comme le fromage dans le beurre, mais j'ai fait ma part de service en tant que lieutenant-colonel. Désolé si je vous ai offensé :(
Non, ne soyez pas offensé, ne soyez pas obligé si j'ai dit quelque chose de mal, mais sincèrement. :)
 
borilunad:
Non, aucune raison d'être offensé, vous n'avez pas à vous engager si j'ai dit quelque chose de mal, mais sincèrement. :)
Peu importe.
 
Ant_TL:

Vous vous trompez sur moi. Comme la moitié des gens pour une raison quelconque. Je n'ai pas besoin, dans la fonction B(), de traiter cet ordre, qui est sélectionné dans la fonction A(). La fonction B() fonctionne avec d'autres ordres, peu importe lesquels, elle n'a rien à voir avec la fonction A() ; la fonction B() a sa propre logique. Il peut compter le nombre d'ordres, leur profit total, consulter leurs commentaires, TP SL, etc. La tâche consiste à retourner de la fonction B() à la fonction A() de telle sorte que, quoi que la fonction B() ait fait avec les ordres, la logique de fonctionnement de la fonction A() au moment de l'appel de la fonction B() à partir de celle-ci ne sera pas violée du fait que l'ordre sélectionné par la fonction A() avant l'appel de la fonction B() n'est plus sélectionné et que l'ordre sélectionné est un autre ordre aléatoire traité par la fonction B() qui recherche très probablement aussi des ordres dans la boucle.


Vous oubliez toujours qu'une seule commande peut être sélectionnée à la fois. Exit = stocker la liste des commandes dans une réserve d'épargne (votre tableau). une variable globale lastorder n'est pas suffisante. une meilleure option serait lastords[ticket][fonction].
  
//+------------------------------------------------------------------+
//| Description included Functions                                   |
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//|                                                       ORDERS.mq4 |
//|           Copyright © 2012. XrustSolution. mail:xrustx@gmail.com |
//|          https://www.youtube.com/user/opmlv http://forexrust.info |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2012. XrustSolution. mail:xrustx@gmail.com"
#property link      "https://www.youtube.com/user/opmlv http://forexrust.info"
//+------------------------------------------------------------------+
//| Defines and Exports and Includes                                 |
//+------------------------------------------------------------------+
#define  ORDS_TOTAL 100
#define  HIST_TOTAL 100000
//+------------------------------------------------------------------+
//| Orders Property Indexes                                          |
//+------------------------------------------------------------------+
#define  ORD_TICK 0
#define  ORD_LOTS 1
#define  ORD_OPTM 2
#define  ORD_OPPR 3
#define  ORD_STOP 4
#define  ORD_TAKE 5
#define  ORD_CLPR 6
#define  ORD_CLTM 7
#define  ORD_PROF 8
#define  ORD_SWAP 9
#define  ORD_COMM 10
#define  ORD_EXPR 11
#define  ORD_SYMB 12
#define  ORD_COMN 13
//+------------------------------------------------------------------+
//| Extern and Global variables                                      |
//+---externs--------------------------------------------------------+

//+---globals--------------------------------------------------------+
int    gOrdsTotal[7];                     // number open orders
int    gOrdsTicks[ORDS_TOTAL][6];         // array of open ords tickets
double gOrdsProps[ORDS_TOTAL][6][12];     // array of open ords properties
double gPreOrdsProps[ORDS_TOTAL][6][12];
double gOrdsPrf[6];                       // open ords summary profit for order types
double gOrdsLts[6];                       // open ords summary lots for order types
//+------------------------------------------------------------------+
int    gHistTotal[7];                     // number closed orders
int    gHistTicks[HIST_TOTAL][6];         // array of closed ords tickets
double gHistProps[HIST_TOTAL][6][12];     // array of closed ords properties
double gHistPrf[6];                       // closed ords summary profit for order types
double gHistLts[6];                       // closed ords summary lots for order types
//+------------------------------------------------------------------+
//|   Function  :  double iOrdProps(OrderType,PropIndex,Count)       |
//+------------------------------------------------------------------+
double iOrdProps(int type,int indx,int co){int i;double res=0;
   i = gOrdsTicks[co][type];
   if(OrderSelect(i,SELECT_BY_TICKET)){
      if(OrderCloseTime()==0){
         switch(indx){
            case ORD_TICK : res = OrderTicket(); break;
            case ORD_LOTS : res = OrderLots(); break;
            case ORD_OPTM : res = OrderOpenTime(); break;
            case ORD_OPPR : res = OrderOpenPrice(); break;
            case ORD_STOP : res = OrderStopLoss(); break;
            case ORD_TAKE : res = OrderTakeProfit(); break;
            case ORD_CLPR : res = OrderClosePrice(); break;
            case ORD_CLTM : res = OrderCloseTime(); break;
            case ORD_PROF : res = OrderProfit(); break;
            case ORD_SWAP : res = OrderSwap(); break;
            case ORD_COMM : res = OrderCommission(); break;
            case ORD_EXPR : res = OrderExpiration(); break;
            default: res = 0; break;
         }
      }
   }else{
      return(EMPTY_VALUE);
   }
   return(res);
}
//+------------------------------------------------------------------+
//|   Function  :  double fOrdProps(OrderType,PropIndex,Count)       |
//+------------------------------------------------------------------+
double fOrdProps(int type,int indx,int co){return(gOrdsProps[co][type][indx]);}
//+------------------------------------------------------------------+
//|   Function  :  int fOrdsTicket(OrderType,Count)                  |
//+------------------------------------------------------------------+
int fOrdsTicket(int type, int indx = 0){return(gOrdsTicks[indx][type]);}
//+------------------------------------------------------------------+
//|   Function  :  int fOrdsTotal(OrderType)                         |
//+------------------------------------------------------------------+
int fOrdsTotal(int type = 6){return(gOrdsTotal[type]);}
//+------------------------------------------------------------------+
//|   Function  :  double fHistProps(OrderType,PropIndex,Count)      |
//+------------------------------------------------------------------+
double fHistProps(int type,int indx,int co){return(gOrdsProps[co][type][indx]);}
//+------------------------------------------------------------------+
//|   Function  :  int fHistTicket(OrderType,Count)                  |
//+------------------------------------------------------------------+
int fHistTicket(int type, int indx = 0){return(gHistTicks[indx][type]);}
//+------------------------------------------------------------------+
//|   Function  :  int fHistTotal(OrderType)                         |
//+------------------------------------------------------------------+
int fHistTotal(int type = 6){return(gOrdsTotal[type]);}
//+------------------------------------------------------------------+
//|          Function  : int HistRefresh(Magik,Comment,Symbol)       |
//|          Copyright © 2012, XrustSolution.  mail:xrustx@gmail.com |
//|          https://www.youtube.com/user/opmlv http://forexrust.info |
//+------------------------------------------------------------------+
//|          Description:                                            |
//+------------------------------------------------------------------+
int HistRefresh(int mn=-1,string comm="",string sy=""){int i,ii=0,type;bool iMn=true,iComm=true;
   if(mn<0){iMn=false;}
   ArrayResize(gHistTotal,7);
   ArrayInitialize(gHistTotal,0);
   ArrayResize(gHistProps,ORDS_TOTAL);
   ArrayInitialize(gHistProps,0);
   ArrayResize(gHistPrf,ORDS_TOTAL);
   ArrayInitialize(gHistPrf,0);
   ArrayResize(gHistLts,ORDS_TOTAL);
   ArrayInitialize(gHistLts,0);      
   if(StringLen(comm)<1){iComm=false;}
   for(i = OrdersHistoryTotal()-1; i>=0; i--){
      if(OrderSelect(i,SELECT_BY_POS,MODE_HISTORY)){
         if(OrderType()>5){continue;}
         if(OrderCloseTime()==0){continue;}
         if(sy!=""){if(OrderSymbol()!=sy){continue;}}
         if(iMn){if(OrderMagicNumber()!=mn){continue;}}
         if(iComm){if(StringFind(OrderComment(),comm)<0){continue;}}
         type = OrderType();
         gHistProps[gHistTotal[type]][type][0] = OrderTicket();
         gHistProps[gHistTotal[type]][type][1] = OrderLots();
         gHistProps[gHistTotal[type]][type][2] = OrderOpenTime();
         gHistProps[gHistTotal[type]][type][3] = OrderOpenPrice();
         gHistProps[gHistTotal[type]][type][4] = OrderStopLoss();
         gHistProps[gHistTotal[type]][type][5] = OrderTakeProfit();
         gHistProps[gHistTotal[type]][type][6] = OrderClosePrice();
         gHistProps[gHistTotal[type]][type][7] = OrderCloseTime();
         gHistProps[gHistTotal[type]][type][8] = OrderProfit();
         gHistProps[gHistTotal[type]][type][9] = OrderSwap();
         gHistProps[gHistTotal[type]][type][10] = OrderCommission();
         gHistProps[gHistTotal[type]][type][11] = OrderExpiration();
         gHistPrf[type] += OrderProfit()+OrderSwap()+OrderCommission();
         gHistLts[type] += OrderLots();
         gHistTotal[type]++;// count for ordertypes
         gHistTotal[6]++;// all orders count
         ii++;
      }
   }   
   return(ii);
}
//+------------------------------------------------------------------+
//|          Function  : int OrdsRefresh(Magik,Comment,Symbol)       |
//|          Copyright © 2012, XrustSolution.  mail:xrustx@gmail.com |
//|          https://www.youtube.com/user/opmlv http://forexrust.info |
//+------------------------------------------------------------------+
//|          Description:                                            |
//+------------------------------------------------------------------+
int OrdsRefresh(int mn=-1,string comm="",string sy=""){int i,ii=0,type;bool iMn=true,iComm=true;
   if(mn<0){iMn=false;}
   if(StringLen(comm)<1){iComm=false;}
   ArrayResize(gOrdsTotal,7);
   ArrayInitialize(gOrdsTotal,0);
   ArrayResize(gOrdsTicks,ORDS_TOTAL);
   ArrayInitialize(gOrdsTicks,0);
   ArrayResize(gOrdsProps,ORDS_TOTAL);
   ArrayInitialize(gOrdsProps,0);
   ArrayResize(gOrdsPrf,ORDS_TOTAL);
   ArrayInitialize(gOrdsPrf,0);
   ArrayResize(gOrdsLts,ORDS_TOTAL);
   ArrayInitialize(gOrdsLts,0);
   for(i = OrdersTotal()-1; i>=0; i--){
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)){
         if(OrderType()>5){continue;}
         if(OrderCloseTime()!=0){continue;}
         if(sy!=""){if(OrderSymbol()!=sy){continue;}}
         if(iMn){if(OrderMagicNumber()!=mn){continue;}}
         if(iComm){if(StringFind(OrderComment(),comm)<0){continue;}}
         type = OrderType();
         gOrdsTicks[gOrdsTotal[type]][type] = OrderTicket();        
         gOrdsProps[gOrdsTotal[type]][type][0] = OrderTicket();
         gOrdsProps[gOrdsTotal[type]][type][1] = OrderLots();
         gOrdsProps[gOrdsTotal[type]][type][2] = OrderOpenTime();
         gOrdsProps[gOrdsTotal[type]][type][3] = OrderOpenPrice();
         gOrdsProps[gOrdsTotal[type]][type][4] = OrderStopLoss();
         gOrdsProps[gOrdsTotal[type]][type][5] = OrderTakeProfit();
         gOrdsProps[gOrdsTotal[type]][type][6] = OrderClosePrice();
         gOrdsProps[gOrdsTotal[type]][type][7] = OrderCloseTime();
         gOrdsProps[gOrdsTotal[type]][type][8] = OrderProfit();
         gOrdsProps[gOrdsTotal[type]][type][9] = OrderSwap();
         gOrdsProps[gOrdsTotal[type]][type][10] = OrderCommission();
         gOrdsProps[gOrdsTotal[type]][type][11] = OrderExpiration();
         gOrdsPrf[type] += OrderProfit()+OrderSwap()+OrderCommission();
         gOrdsLts[type] += OrderLots();
         gOrdsTotal[type]++;// count for ordertypes
         gOrdsTotal[6]++;// all orders count
         ii++;
      }
   }   
   return(ii);
}
//+------------------------------------------------------------------+
 
Rustam, merci et bonnes fêtes de fin d'année.
 
Oui, joyeuses fêtes à vous aussi ! 100 grammes pour tout le monde :)
 
TarasBY:

Dans mon code, cette erreur ne se produira pas, car cette fonction est appelée APRÈS OrderSelect(). Et le contrôle dans le code est un vestige de l'époque où les codes étaient écrits sans une structure commune de toutes les fonctions exécutables de l'EA.

En outre, la plupart de mes fonctions contiennent des fonctions de gestion des erreurs et je fais très attention à les éviter. Et il existe également un certain nombre de fonctions qui génèrent une erreur, comme la réponse que vous recherchiez : "Ordre sélectionné plus tôt, ou non ?"

P.S. A propos, je me suis souvenu d'une particularité (qui pourrait être utile à quelqu'un) du travail avec les fonctions OrderSelect() des bibliothèques compilées : nous avons sélectionné une commande (comment - pas principalement), OrderTicket() - renvoie le numéro de la commande sélectionnée. Mais si nous voulons obtenir les propriétés de cet ordre sélectionné à partir de la fonction qui se trouve dans la bibliothèque compilée, nous n'obtiendrons rien. Nous devons sélectionner cet ordre à nouveau (encore).

En fait, j'ai rencontré une situation où l'erreur était causée par l'une des fonctions à usage général qui aurait pu être utilisée à la fois dans les boucles de traitement des commandes et en dehors de ces boucles, c'est-à-dire avant la sélection de la commande, ce qui a entraîné l'erreur. Si nous voulons que les fonctions du service universel fonctionnent avec des ordres qui peuvent être utilisés aussi bien après qu'un ordre a été sélectionné qu'avant, aussi bien lorsqu'il y a des ordres ouverts que lorsqu'il n'y en a pas, nous devrions utiliser un mécanisme comme celui que j'ai cité pour nous assurer que nous n'obtenons pas cette erreur.

J'ai déjà écrit plus tôt dans ce fil de discussion sur le fait que la sélection des commandes n'est pas transmise aux modules de bibliothèque et vice-versa.

 
Ant_TL:

En fait, j'ai rencontré une situation où l'erreur était causée par l'une des fonctions à usage général qui pouvait être utilisée à la fois à l'intérieur et à l'extérieur des cycles de traitement des commandes, c'est-à-dire avant qu'une commande soit sélectionnée, ce qui a provoqué l'erreur. Si nous voulons créer des fonctions de service universel qui fonctionnent avec les ordres et qui peuvent être utilisées aussi bien après qu'un ordre ait été sélectionné qu'avant, aussi bien lorsqu'il y a des ordres ouverts que lorsqu'il n'y a aucun ordre, nous devons utiliser un mécanisme tel que celui mentionné à la page précédente pour éviter cette erreur.

J'ai déjà écrit plus tôt dans ce fil de discussion sur le fait que la sélection des commandes n'est pas transmise aux modules de bibliothèque et vice-versa.


Vous devez vous habituer au fait que chaque opération commerciale a son propre ordre de sélection et vous n'aurez aucun problème. Et, oui, on vous a bien écrit, une seule commande peut être sélectionnée. Tout le reste est résolu par des tableaux.
1...567891011121314151617181920
Nouveau commentaire