Como verificar se um pedido é selecionado - página 12

 
grell:

Então esse é o meu ponto. Minhas funções não têm versatilidade, cada uma delas é estritamente dedicada a seu próprio negócio. Até mesmo a compra e a venda são separadas. Portanto, deixe os números de pedido mudarem, deixe as paradas se arrastarem, mas o bilhete e o mágico permanecerão.

Bem, você se deixou levar com o slosoll:)
 
tara:

Bem, você se deixou levar com a surra:)

Ainda não houve falhas. Eu sou um tirano nesse aspecto:)
 
tara:
Não, não como queijo na manteiga, mas fiz a minha parte de serviço como tenente-coronel. Desculpe se eu o ofendi :(
Não, não se ofenda, não seja obrigado se eu disser algo errado, mas sinceramente. :)
 
borilunad:
Não, não há motivo para se ofender, você não precisa obrigar se eu disser algo errado, mas sinceramente. :)
Não importa.
 
Ant_TL:

Vocês me entenderam mal. Assim como metade das pessoas, por alguma razão. Não preciso na função B() para processar essa ordem, que é selecionada na função A(). A função B() funciona com outras ordens, não importa quais, ela nada tem a ver com a função A(); a função B() tem sua própria lógica. Pode contar o número de pedidos, seu lucro total, olhar através de seus comentários, TP SL, etc. A tarefa é retornar da função B() de volta à função A() de modo que não importa o que a função B() tenha feito com as ordens, a lógica da operação da função A() no ponto de chamada da função B() a partir dela não será violada devido ao fato de que a ordem selecionada pela função A() antes da função B() foi chamada não é mais selecionada e a ordem selecionada é outra ordem aleatória processada pela função B() que muito provavelmente também busca ordens no laço.


Você continua esquecendo que apenas um pedido pode ser selecionado de cada vez. Sair = armazenar a lista de pedidos em um pool de economias (sua matriz). uma última ordem variável global não é suficiente. uma opção melhor seria lastords[ticket][função].
 
//+------------------------------------------------------------------+
//| 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, obrigado e boas festas.
 
Sim, Boas festas para você também! 100 gramas para todos :)
 
TarasBY:

Este erro não ocorrerá em meu código, pois esta função é chamada de AFTER OrderSelect(). E o cheque no código é deixado dos tempos em que os códigos eram escritos sem uma estrutura comum de todas as funções executáveis da EA.

Além disso, a maioria das minhas funções contém funções de tratamento de erros e eu tenho muito cuidado para evitá-las. E também há uma série de funções que geram um erro, como a resposta que você estava procurando: "Ordem selecionada antes, ou não?".

P.S. A propósito, lembrei-me de uma peculiaridade (que pode ser útil para alguém) de trabalhar com funções OrderSelect() de bibliotecas compiladas: selecionamos uma ordem (como - não principalmente), OrderTicket() - devolve o número da ordem selecionada. Mas se quisermos obter as propriedades desta ordem selecionada a partir da função que está localizada na biblioteca compilada, não receberemos nada. Temos que selecionar essa ordem novamente (novamente).

Na verdade, encontrei uma situação em que o erro foi causado por uma das funções de propósito geral que podia ser usada tanto dentro dos laços de processamento de pedidos quanto fora desses laços, ou seja, antes da seleção do pedido, o que levou ao erro. Se quisermos fazer funções de serviço universal trabalhando com pedidos que podem ser usados tanto depois de um pedido ter sido selecionado como antes disso, tanto quando há pedidos abertos como quando não há nenhum, devemos usar um mecanismo como o que citei para ter certeza de que não teremos esse erro.

Eu já escrevi anteriormente neste tópico sobre o fato de que a seleção de pedidos não é passada para os módulos da biblioteca e vice-versa.

 
Ant_TL:

Na verdade, encontrei uma situação em que o erro foi causado por uma das funções de propósito geral que podia ser usada tanto dentro como fora dos laços de processamento de pedidos, ou seja, antes de um pedido ser selecionado, o que levou ao erro. Se quisermos fazer funções de serviço universal que funcionem com pedidos e possam ser usadas tanto depois de um pedido ter sido selecionado quanto antes, tanto quando há pedidos abertos e quando não há pedidos, devemos usar tal mecanismo como mencionei na página anterior para evitar este erro.

Eu já escrevi anteriormente neste tópico sobre o fato de que a seleção de pedidos não é passada para os módulos da biblioteca e vice-versa.


Você deve se acostumar ao fato de que cada operação comercial tem sua própria ordem seletiva e você não terá nenhum problema. E, sim, você foi escrito corretamente, apenas um pedido pode ser selecionado. Tudo o resto é resolvido por matrizes.