MetaTrader 5 herunterladen

Processing

Implementiert den Basisalgorithmus.

virtual bool  Processing()

Rückgabewert

Gibt true zurück wenn einige Operation ausgeführt ist, ansonsten gibt false zurück.

Bemerkung

Die Methode der Basisklasse führt die folgende Aktionen aus:

1. Prüft ob irgendwelche Position für das Arbeitssymbol geöffnet ist. Wenn es kein Position gibt, werden die Schritte 2, 3 und 4 ausgelassen.

2. Prüft die Notwendigkeit eine Position umzukehren (Aufruf der CheckReverse()-Methode). Wenn die Position "Reverse" ist, dann verlassen.

3. Prüft die Notwendigkeit eine Position zu schließen (Aufruf der CheckClose()-Methode). Wenn die Position geschlossen ist, wird Schritt 4 ausgelassen.

4. Prüft die Notwendigkeit eine Position zu ändern (Aufruf der CheckTrailingStop()-Methode). Wenn die Position geändert war, dann verlassen.

5. Prüft ob er irgendwelche Pending-Ordern für das Arbeitssymbol geöffnet ist. Wenn es keine Ordern gibt, dann gehen wir weiter auf den Schritt .9.

6. Prüft die Notwendigkeit eine Order zu löschen (Aufruf der CheckDeleteOrderLong()-Methode für Kaufsordern und CheckDeleteOrderShort() für Verkaufsordern). Wird eine Order gelöscht, dann gehen wir weiter auf den Schritt 9.

7. Prüft die Notwendigkeit eine Order zu ändern (Aufruf der CheckTrailingOrderLong()-Methode für Kaufsordern und CheckTrailingOrderShort() für Verkaufsordern). Wenn die Order geändert war, dann verlassen.

8. Verlassen.

9. Prüft die Notwendigkeit eine Position zu eröffnen (Aufruf der CheckOpen()-Methode).

Um Ihren eigenen Algorithmus zu implementieren, überschreiben Sie Processing()-Methode in der abgeleiteten Klasse.

Implementierung:

//+------------------------------------------------------------------+
//| Main function                                                    |
//| INPUT:  no.                                                      |
//| OUTPUT: true-if any trade operation processed, false otherwise.  |
//| REMARK: no.                                                      |
//+------------------------------------------------------------------+
bool CExpert::Processing()
  {
//--- check if open positions
   if(m_position.Select(m_symbol.Name()))
     {
      //--- open position is available
      //--- check the possibility of reverse the position
      if(CheckReverse()) return(true);
      //--- check the possibility of closing the position/delete pending orders
      if(!CheckClose())
        {
         //--- check the possibility of modifying the position
         if(CheckTrailingStop()) return(true);
         //--- return without operations
         return(false);
        }
     }
//--- check if placed pending orders
   int total=OrdersTotal();
   if(total!=0)
     {
      for(int i=total-1;i>=0;i--)
        {
         m_order.SelectByIndex(i);
         if(m_order.Symbol()!=m_symbol.Name()) continue;
         if(m_order.OrderType()==ORDER_TYPE_BUY_LIMIT || m_order.OrderType()==ORDER_TYPE_BUY_STOP)
           {
            //--- check the ability to delete a pending order to buy
            if(CheckDeleteOrderLong()) return(true);
            //--- check the possibility of modifying a pending order to buy
            if(CheckTrailingOrderLong()) return(true);
           }
         else
           {
            //--- check the ability to delete a pending order to sell
            if(CheckDeleteOrderShort()) return(true);
            //--- check the possibility of modifying a pending order to sell
            if(CheckTrailingOrderShort()) return(true);
           }
         //--- return without operations
         return(false);
        }
     }
//--- check the possibility of opening a position/setting pending order
   if(CheckOpen()) return(true);
//--- return without operations
   return(false);
  }