So prüfen Sie, ob ein Auftrag ausgewählt ist - Seite 12

Neuer Kommentar
 
grell:

Das ist also mein Punkt. Meine Funktionen sind nicht vielseitig, jede ist strikt auf ihr eigenes Geschäft ausgerichtet. Auch Kauf und Verkauf sind getrennt. Die Bestellnummern können sich ändern, die Haltestellen können sich erhöhen, aber das Ticket und der Zauberer bleiben.

Na ja, du hast dich von der slosoll mitreißen lassen:)
 
tara:

Na ja, du hast es mit dem Klamauk übertrieben:)

Es gab bisher keine Fehlschüsse. In dieser Hinsicht bin ich ein Tyrann:)
 
tara:
Nein, nicht wie Käse in Butter, aber ich habe als Oberstleutnant meinen Teil dazu beigetragen. Tut mir leid, wenn ich Sie beleidigt habe :(
Nein, seien Sie nicht beleidigt, fühlen Sie sich nicht verpflichtet, wenn ich etwas Falsches gesagt habe, sondern seien Sie aufrichtig. :)
 
borilunad:
Nein, kein Grund, beleidigt zu sein, Sie müssen sich nicht verpflichten, wenn ich etwas Falsches gesagt habe, aber aufrichtig. :)
Macht nichts.
 
Ant_TL:

Du verstehst mich völlig falsch. Das tut die Hälfte der Menschen aus irgendeinem Grund auch. Ich brauche in der Funktion B() nicht den Auftrag zu verarbeiten, der in der Funktion A() ausgewählt wird. Die Funktion B() arbeitet mit anderen Aufträgen, egal mit welchen, sie hat nichts mit der Funktion A() zu tun; die Funktion B() hat ihre eigene Logik. Es kann die Anzahl der Aufträge, ihren Gesamtgewinn zählen, ihre Kommentare, TP SL, usw. einsehen. Die Aufgabe besteht darin, von der Funktion B() zu der Funktion A() zurückzukehren, so dass unabhängig davon, was die Funktion B() mit den Aufträgen gemacht hat, die Logik der Funktion A() zum Zeitpunkt des Aufrufs der Funktion B() nicht verletzt wird, da der Auftrag, der von der Funktion A() vor dem Aufruf der Funktion B() ausgewählt wurde, nicht mehr ausgewählt wird und der ausgewählte Auftrag ein anderer zufälliger Auftrag ist, der von der Funktion B() verarbeitet wird, die höchstwahrscheinlich auch Aufträge in der Schleife sucht.


Sie vergessen immer wieder, dass immer nur ein Auftrag ausgewählt werden kann. Exit = speichert die Liste der Aufträge in einem Sparpool (Ihr Array). eine globale Variable lastorder ist nicht genug. eine bessere Option wäre 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, vielen Dank und schöne Feiertage.
 
Ja, auch Ihnen frohe Festtage! 100 Gramm für jeden :)
 
TarasBY:

Dieser Fehler tritt in meinem Code nicht auf, da diese Funktion NACH OrderSelect() aufgerufen wird. Und die Prüfung im Code stammt noch aus der Zeit, als Codes ohne eine gemeinsame Struktur aller ausführbaren EA-Funktionen geschrieben wurden.

Außerdem enthalten die meisten meiner Funktionen Funktionen zur Fehlerbehandlung, und ich bin sehr darauf bedacht, diese zu vermeiden. Und es gibt auch eine Reihe von Funktionen, die eine Fehlermeldung erzeugen, wie die von Ihnen gesuchte Antwort: "Bestellung früher ausgewählt, oder nicht?"

P.S. Übrigens, ich erinnerte mich an eine Besonderheit (kann für jemanden nützlich sein) der Arbeit mit OrderSelect() Funktionen aus kompilierten Bibliotheken: wir haben eine Bestellung ausgewählt (wie - nicht prinzipiell), OrderTicket() - gibt die Nummer der ausgewählten Bestellung zurück. Wenn wir jedoch die Eigenschaften dieser ausgewählten Bestellung von der Funktion in der kompilierten Bibliothek abrufen wollen, erhalten wir nichts. Wir müssen diesen Auftrag (erneut) auswählen.

In der Tat bin ich auf eine Situation gestoßen, in der der Fehler durch eine der Allzweckfunktionen verursacht wurde, die sowohl innerhalb als auch außerhalb der Auftragsverarbeitungsschleifen verwendet werden konnten, d. h. bevor der Auftrag ausgewählt wurde, was zu dem Fehler führte. Wenn wir universelle Servicefunktionen mit Aufträgen einrichten wollen, die sowohl nach der Auswahl eines Auftrags als auch davor verwendet werden können, sowohl wenn es offene Aufträge gibt als auch wenn es keine gibt, sollten wir einen Mechanismus wie den von mir genannten verwenden, um sicherzustellen, dass wir diesen Fehler nicht bekommen.

Ich habe bereits früher in diesem Thread darüber geschrieben, dass die Auftragsauswahl nicht an Bibliotheksmodule und zurück weitergegeben wird.

 
Ant_TL:

In der Tat bin ich auf eine Situation gestoßen, in der der Fehler durch eine der allgemeinen Funktionen verursacht wurde, die sowohl innerhalb als auch außerhalb der Auftragsverarbeitungsschleifen verwendet werden konnten, d. h. bevor ein Auftrag ausgewählt wurde, was den Fehler verursachte. Wenn wir universelle Servicefunktionen erstellen wollen, die mit Aufträgen arbeiten und sowohl nach der Auswahl eines Auftrags als auch davor verwendet werden können, sowohl bei offenen Aufträgen als auch wenn es überhaupt keine Aufträge gibt, sollten wir einen solchen Mechanismus verwenden, wie ich ihn auf der vorherigen Seite erwähnt habe, um diesen Fehler zu vermeiden.

Ich habe bereits früher in diesem Thread darüber geschrieben, dass die Auftragsauswahl nicht an Bibliotheksmodule und zurück weitergegeben wird.


Sie sollten sich daran gewöhnen, dass jeder Handelsvorgang seine eigene Auswahlreihenfolge hat, und Sie werden keine Probleme haben. Und, ja, Sie haben richtig geschrieben, es kann nur eine Bestellung ausgewählt werden. Alles andere wird durch Arrays gelöst.
1...567891011121314151617181920
Neuer Kommentar