Cómo comprobar si una orden está seleccionada - página 12

 
grell:

Así que ese es mi punto. Mis funciones no tienen ninguna versatilidad, cada una se dedica estrictamente a su propio negocio. Incluso la compra y la venta están separadas. Que cambien los números de orden, que suban las paradas, pero el billete y el mago permanecerán.

Bueno, te has dejado llevar por el slosoll:)
 
tara:

Bueno, te has dejado llevar por la paliza:)

Todavía no se ha producido ningún fallo. Soy un tirano en ese sentido:)
 
tara:
No, no como el queso en la mantequilla, pero hice mi parte justa de servicio como teniente coronel. Lo siento si te he ofendido :(
No, no te ofendas, no te sientas obligado si he dicho algo malo, pero sinceramente. :)
 
borilunad:
No, no hay razón para ofenderse, no tienes que comprometerte si dije algo malo, pero sinceramente. :)
No importa.
 
Ant_TL:

Me has entendido mal. Por alguna razón, la mitad de la gente también lo hace. No necesito en la función B() procesar esa orden, que se selecciona en la función A(). La función B() funciona con otras órdenes, no importa cuáles, no tiene nada que ver con la función A(); la función B() tiene su propia lógica. Puede contar el número de órdenes, su beneficio total, mirar a través de sus comentarios, TP SL, etc. La tarea es volver de la función B() de nuevo a la función A() de tal manera que no importa lo que la función B() haya hecho con los pedidos, la lógica de la operación de la función A() en el punto de llamada de la función B() desde ella no será violada debido al hecho de que el orden seleccionado por la función A() antes de la llamada de la función B() ya no es seleccionado y el orden seleccionado es otro orden aleatorio procesado por la función B() que muy probablemente también busca órdenes en el bucle.


Sigues olvidando que sólo se puede seleccionar un pedido a la vez. Salir = almacenar la lista de pedidos en un pool de ahorro (su array). una variable global lastorder no es suficiente. una mejor opción sería lastords[ticket][function].
 
//+------------------------------------------------------------------+
//| 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, gracias y felices fiestas.
 
Sí, ¡felices fiestas para ti también! Cien gramos para todos :)
 
TarasBY:

En mi código, este error no se producirá, porque esta función se llama DESPUÉS de OrderSelect(). Y la comprobación en el código queda de los tiempos en que los códigos se escribían sin una estructura común de todas las funciones ejecutables de EA.

Además, la mayoría de mis funciones contienen funciones de gestión de errores y tengo mucho cuidado de evitarlos. Y también hay una serie de funciones que generan un error, como la respuesta que buscabas: "¿Ordenar antes, o no?"

P.D. Por cierto, he recordado una peculiaridad (puede ser útil para alguien) del trabajo con las funciones OrderSelect() de las bibliotecas compiladas: hemos seleccionado un pedido (cómo - no principalmente), OrderTicket() - devuelve el número del pedido seleccionado. Pero si queremos obtener las propiedades de esta orden seleccionada desde la función que se encuentra en la biblioteca compilada, no obtendremos nada. Tenemos que volver a seleccionar esa orden (otra vez).

De hecho, me encontré con una situación en la que el error era causado por una de las funciones de propósito general que podía ser utilizada tanto dentro de los bucles de procesamiento de pedidos como fuera de esos bucles, es decir, antes de que el pedido fuera seleccionado, lo que provocaba el error. Si queremos que las funciones del servicio universal trabajen con órdenes que se puedan utilizar tanto después de que se haya seleccionado una orden como antes, tanto cuando hay órdenes abiertas como cuando no las hay, deberíamos utilizar un mecanismo como el que he citado para asegurarnos de que no obtenemos este error.

Ya escribí anteriormente en este hilo sobre el hecho de que la selección de la orden no se pasa a los módulos de la biblioteca y de vuelta.

 
Ant_TL:

De hecho, me encontré con una situación en la que el error era causado por una de las funciones de propósito general que podía ser utilizada tanto dentro como fuera de los bucles de procesamiento de pedidos, es decir, antes de que se seleccionara un pedido, lo que causaba el error. Si queremos hacer funciones de servicio universal que trabajen con órdenes y que puedan ser utilizadas tanto después de que una orden haya sido seleccionada como antes, tanto cuando hay órdenes abiertas como cuando no hay órdenes, deberíamos utilizar un mecanismo como el que mencioné en la página anterior para evitar este error.

Ya escribí anteriormente en este hilo sobre el hecho de que la selección de la orden no se pasa a los módulos de la biblioteca y de vuelta.


Acostúmbrese a que cada operación tiene su propio orden de selección y no tendrá ningún problema. Y, sí, se ha escrito correctamente, sólo se puede seleccionar una orden. Todo lo demás se resuelve con matrices.