Struktur der Handelsanforderung (MqlTradeRequest)

Interaktion von Client-Terminal und Handelsserverfür Durchführung für Operation der Orderstellung wird mittels Handelanforderungen durchgeführt.  Anforderung ist durch die spezielle vorbestimmte Struktur MqlTradeRequest dargestellt, die alle erforderlichen Felder für Abschluss der Handelsorder enthält. Ergebnis der Verarbeitung von Anforderung ist durch die Struktur MqlTradeResult repraesentiert.

struct MqlTradeRequest
  {
   ENUM_TRADE_REQUEST_ACTIONS    action;           // Operationstyp 
   ulong                         magic;            // Expert Advisor ID (Identifikator magic number)
   ulong                         order;            // Orderticket
   string                        symbol;           // Name des Handelssymbols 
   double                        volume;           // angefordertes Dealvolumen in Lots 
   double                        price;            // Preis 
   double                        stoplimit;        // Orderlevel StopLimit 
   double                        sl;               // Oderlevel Stop Loss 
   double                        tp;               // Orderlevel  Take Profit 
   ulong                         deviation;        // maximal moegliche Abweichnung vom angeforderten Preis 
   ENUM_ORDER_TYPE               type;             // Ordertyp 
   ENUM_ORDER_TYPE_FILLING       type_filling;     // Durchführungstyp der Order 
   ENUM_ORDER_TYPE_TIME          type_time;        // Wirkzeittyp der Order 
   datetime                      expiration;       // Fristablauf der Order (für Ordern des Typs ORDER_TIME_SPECIFIED)
   string                        comment;          // Oprderkommentar
   ulong                         position;         // Position ticket
   ulong                         position_by;      // The ticket of an opposite position
  };

Beschreibung der Felder

Feld

Beschreibung

action

Typ der Handelsoperation. Wert kann einer der Enumerationswerte ENUM_TRADE_REQUEST_ACTIONS sein

magic

Identifikator des Experten. Ermoeglicht, analytische Verabeitung der Handelsordern zu gestalten. Jeder Experte kann seinen unikalen Identifikator beim Senden der Handelanforderung stellen

order

Ticket der Order. Für Modifikation der Warteordern erforderlich.

symbol

Symbolname der Order. Nicht erforderlich bei Modifikation der Ordern und Schliessen der Positionen.

volume

Angefordertes Dealvolumen in Lots. Realwert des Volumens wird vom Durchführungstyp der Order abhängen

price

Preis, bei dem Order ausgeführt werden muss, für Marktordern mit dem Durchführungstyp "Market Execution" (SYMBOL_TRADE_EXECUTION_MARKET), die den Typ TRADE_ACTION_DEAL haben, ist es nicht erforderlich, Preis anzugeben

stoplimit

Preis, bei dem Warteorder Limit gestellt wird, wenn der Preis den Wert price reicht( diese Bedingung ist obligatorisch). Bis dahin wird Warteorder ins Handelssystem nicht ausgegeben

sl

Stop Loss des Preises bei unguenstiger Bewegung des Preises

tp

Take Profit des Preises bei  guenstiger Bewegung des Preises

deviation

Maximal moefliche Abweichung vom angeforderten Preis vorgegeben in Punkten

type

Ordertyp. Wert kann einer der Enumerationswerte ENUM_ORDER_TYPE sein

type_filling

Durchführungstyp der Order. Kann einer der Enumerationswerte ENUM_ORDER_TYPE_FILLING sein

type_time

Ablauftyp der Order. Kann einer der Enumerationswerte ENUM_ORDER_TYPE_TIME sein

expiration

Ablauffrist der Warteordern (für Ordern des Typs ORDER_TIME_SPECIFIED)

comment

Kommentar zur Order

Beim Modifizieren oder Schließen einer Position im Hedging-Modus müssen Sie ihr Ticket (MqlTradeRequest::position) angeben. Im Netting-Modus können Sie das Ticket auch angeben, aber die Identifikation erfolgt anhand des Symbolnamens.

für Senden der Order Handelsoperationen  durchzuführen, muss die Funktion OrderSend() verwendet werden. Für jede Handelsoperation muessen obligatorische Felde angegeben werden und können optionale Felder ausgefuellt werden.  Insgesamt werden 7 Varianten des Sendens der Handelsanforderung vorausgesehen:

Request Execution

Handelsorder, Positionen im  Request Execution Mode zu oeffnen (Handelsmode bei der Anforderung der laufenden Preise). Man muss 9 Felder spezifizieren:

  • action
  • symbol
  • volume
  • price
  • sl
  • tp
  • deviation
  • type
  • type_filling

Man kann auch Feldwerte magic und comment vorgeben.

Instant Execution

Handelsorder, Positionen im  Instant Execution Mode zu oeffnen (Handel mit Flowpreisen). Man muss 9 Felder spezifizieren:

  • action
  • symbol
  • volume
  • price
  • sl
  • tp
  • deviation
  • type
  • type_filling

Man kann auch Feldwerte magic und comment vorgeben.

Market Execution

Handelsorder, Positionen im Market Execution Mode zu oeffnen (Durchführung der Handelsorder im Mark). Man muss 5 Felder spezifizieren:

  • action
  • symbol
  • volume
  • type
  • type_filling

Man kann auch Feldwerte magic und comment vorgeben.

Exchange Execution

Handelsorder, Positionen im Exchange Execution Modus zu öffnen (Börse-Modus der Ausführung von Handelsordern).  Man muss 5 Felder angeben:

  • action
  • symbol
  • volume
  • type
  • type_filling

Man kann auch Feldwerte magic und comment vorgeben.

Ein Beispiel der Transaktion TRADE_ACTION_DEAL für das Eröffnen einer Buy-Position:

#define EXPERT_MAGIC 123456   // MagicNumber des EAs
//+------------------------------------------------------------------+
//| Eröffnen einer Buy-Position                                      |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- die Anfrage und das Ergebnis deklarieren und initialisieren
   MqlTradeRequest request={0};
   MqlTradeResult  result={0};
//--- Parameter der Anfrage
   request.action   =TRADE_ACTION_DEAL;                     // Typ der Transaktion
   request.symbol   =Symbol();                              // Symbol
   request.volume   =0.1;                                   // Volumen von 0.1 Lot
   request.type     =ORDER_TYPE_BUY;                        // Ordertyp
   request.price    =SymbolInfoDouble(Symbol(),SYMBOL_ASK); // Eröffnungspreis
   request.deviation=5;                                     // zulässige Abweichung vom Kurs
   request.magic    =EXPERT_MAGIC;                          // MagicNumber der Order
//--- Anfrage senden
   if(!OrderSend(request,result))
      PrintFormat("OrderSend error %d",GetLastError());     // wenn die Anfrage konnte nicht gesendet werden, den Fehlercode anzeigen
//--- Details zur Transaktion
   PrintFormat("retcode=%u  deal=%I64u  order=%I64u",result.retcode,result.deal,result.order);
  }
//+------------------------------------------------------------------+

 
Ein Beispiel der Transaktion TRADE_ACTION_DEAL für das Eröffnen einer Sell-Position:

#define EXPERT_MAGIC 123456   // MagicNumber des EAs
//+------------------------------------------------------------------+
//| Eröffnen einer Sell-Position                                     |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- die Anfrage und das Ergebnis deklarieren und initialisieren
   MqlTradeRequest request={0};
   MqlTradeResult  result={0};
//--- Parameter der Anfrage
   request.action   =TRADE_ACTION_DEAL;                     // Typ der Transaktion
   request.symbol   =Symbol();                              // Symbol
   request.volume   =0.2;                                   // Volumen von 0.2 Lot
   request.type     =ORDER_TYPE_SELL;                       // Ordertyp
   request.price    =SymbolInfoDouble(Symbol(),SYMBOL_BID); // Eröffnungspreis
   request.deviation=5;                                     // zulässige Abweichung vom Kurs
   request.magic    =EXPERT_MAGIC;                          // MagicNumber der Order
//--- Anfrage senden
   if(!OrderSend(request,result))
      PrintFormat("OrderSend error %d",GetLastError());     // wenn die Anfrage konnte nicht gesendet werden, den Fehlercode anzeigen
//--- Details zur Transaktion
   PrintFormat("retcode=%u  deal=%I64u  order=%I64u",result.retcode,result.deal,result.order);
  }
//+------------------------------------------------------------------+

 
Ein Beispiel der Transaktion TRADE_ACTION_DEAL für das Schließen von Positionen:

#define EXPERT_MAGIC 123456   // MagicNumber des EAs
//+------------------------------------------------------------------+
//| Schließen aller Position                                         |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- die Anfrage und das Ergebnis deklarieren
   MqlTradeRequest request;
   MqlTradeResult  result;
   int total=PositionsTotal(); // Anzahl offener Positionen   
//--- in allen offenen Positionen suchen
   for(int i=total-1; i>=0; i--)
     {
      //--- Parameter der Order
      ulong  position_ticket=PositionGetTicket(i);                                      // das Ticket der Position
      string position_symbol=PositionGetString(POSITION_SYMBOL);                        // Symbol 
      int    digits=(int)SymbolInfoInteger(position_symbol,SYMBOL_DIGITS);              // Stellen nach dem Komma
      ulong  magic=PositionGetInteger(POSITION_MAGIC);                                  // MagicNumber der Position
      double volume=PositionGetDouble(POSITION_VOLUME);                                 // das Volumen der Position
      ENUM_POSITION_TYPE type=(ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);    // Typ der Position
      //--- Details zur Position anzeigen
      PrintFormat("#%I64u %s  %s  %.2f  %s [%I64d]",
                  position_ticket,
                  position_symbol,
                  EnumToString(type),
                  volume,
                  DoubleToString(PositionGetDouble(POSITION_PRICE_OPEN),digits),
                  magic);
      //--- wenn MagicNumber übereinstimmt
      if(magic==EXPERT_MAGIC)
        {
         //--- die Werte der Anfrage und des Ergebnisses auf Null setzen
         ZeroMemory(request);
         ZeroMemory(result);
         //--- Parameter der Transaktion setzen
         request.action   =TRADE_ACTION_DEAL;        // Typ der Transaktion
         request.position =position_ticket;          // das Ticket der Position
         request.symbol   =position_symbol;          // Symbol 
         request.volume   =volume;                   // das Volumem der Position
         request.deviation=5;                        // zulässige Abweichung vom Preis
         request.magic    =EXPERT_MAGIC;             // MagicNumber der Position
         //--- den Preis und den Ordertyp je nach dem Positionstyp setzen
         if(type==POSITION_TYPE_BUY)
           {
            request.price=SymbolInfoDouble(position_symbol,SYMBOL_BID);
            request.type =ORDER_TYPE_SELL;
           }
         else
           {
            request.price=SymbolInfoDouble(position_symbol,SYMBOL_ASK);
            request.type =ORDER_TYPE_BUY;
           }
         //--- Informationen über das Schließen anzeigen
         PrintFormat("Close #%I64d %s %s",position_ticket,position_symbol,EnumToString(type));
         //--- Senden der Anfrage
         if(!OrderSend(request,result))
            PrintFormat("OrderSend error %d",GetLastError());  // wenn die Anfrage konnte nicht gesendet werden, den Fehlercode anzeigen
         //--- Details zur Transaktion   
         PrintFormat("retcode=%u  deal=%I64u  order=%I64u",result.retcode,result.deal,result.order);
         //---
        }
     }
  }
//+------------------------------------------------------------------+

 
SL & TP Modification

Handelsorder, Levels StopLoss und/oder TakeProfit zu modifizieren. Man muss 4 Felder angeben:

  • action
  • symbol
  • sl
  • tp

 

Ein Beispiel für die Transaktion TRADE_ACTION_SLTP für die Änderung von Stop Loss und Take Profit bei einer offenen Position:

#define EXPERT_MAGIC 123456  // MagicNumber des EAs
//+------------------------------------------------------------------+
//| Stop Loss und Take Profit modifizieren                           |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- die Anfrage und das Ergebnis deklarieren
   MqlTradeRequest request;
   MqlTradeResult  result;
   int total=PositionsTotal(); // Anzahl offener Positionen   
//--- in allen offenen Positionen suchen
   for(int i=0; i<total; i++)
     {
      //--- Parameter der Order
      ulong  position_ticket=PositionGetTicket(i);// das Ticket der Position
      string position_symbol=PositionGetString(POSITION_SYMBOL); // Symbol 
      int    digits=(int)SymbolInfoInteger(position_symbol,SYMBOL_DIGITS); // Stellen nach dem Komma
      ulong  magic=PositionGetInteger(POSITION_MAGIC); // MagicNumber der Position
      double volume=PositionGetDouble(POSITION_VOLUME);    // Volumen der Position
      double sl=PositionGetDouble(POSITION_SL);  // Stop Loss der Position
      double tp=PositionGetDouble(POSITION_TP);  // Take Profit der Position
      ENUM_POSITION_TYPE type=(ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);  // Typ der Position
      //--- Details zur Position anzeigen
      PrintFormat("#%I64u %s  %s  %.2f  %s  sl: %s  tp: %s  [%I64d]",
                  position_ticket,
                  position_symbol,
                  EnumToString(type),
                  volume,
                  DoubleToString(PositionGetDouble(POSITION_PRICE_OPEN),digits),
                  DoubleToString(sl,digits),
                  DoubleToString(tp,digits),
                  magic);
      //--- wenn die MagicNumber übereinstimmt, sind Stop Loss und Take Profit nicht gesetzt
      if(magic==EXPERT_MAGIC && sl==0 && tp==0)
        {
         //--- aktuelle Preis Levels berechnen
         double price=PositionGetDouble(POSITION_PRICE_OPEN);
         double bid=SymbolInfoDouble(position_symbol,SYMBOL_BID);
         double ask=SymbolInfoDouble(position_symbol,SYMBOL_ASK);
         int    stop_level=(int)SymbolInfoInteger(position_symbol,SYMBOL_TRADE_STOPS_LEVEL);
         double price_level;
         //--- wenn der Level der minimalen Abweichung vom aktuellen Schlusskurs in Punkten nicht angegeben wurde,
         if(stop_level<=0)
            stop_level=150; // setzen wir eine Abweichung von 150 Punkten vom aktuellen Schlusskurs
         else
            stop_level+=50; // sicherheitshalber nehmen wir (SYMBOL_TRADE_STOPS_LEVEL + 50) Punkte
 
         //--- Stop Loss und Take Profit berechnen und abrunden
         price_level=stop_level*SymbolInfoDouble(position_symbol,SYMBOL_POINT);
         if(type==POSITION_TYPE_BUY)
           {
            sl=NormalizeDouble(bid-price_level,digits);
            tp=NormalizeDouble(bid+price_level,digits);
           }
         else
           {
            sl=NormalizeDouble(ask+price_level,digits);
            tp=NormalizeDouble(ask-price_level,digits);
           }
         //--- die Werte der Anfrage und des Ergebnisses auf Null setzen
         ZeroMemory(request);
         ZeroMemory(result);
         //--- Parameter der Transaktion setzen
         request.action  =TRADE_ACTION_SLTP// Typ der Transaktion
         request.position=position_ticket;   // das Ticket der Position
         request.symbol=position_symbol;     // Symbol 
         request.sl      =sl;                // Stop Loss der Position
         request.tp      =tp;                // Take Profit der Position
         request.magic=EXPERT_MAGIC;         // MagicNumber der Position
         //--- Informationen über die Modifizierung anzeigen
         PrintFormat("Modify #%I64d %s %s",position_ticket,position_symbol,EnumToString(type));
         //--- Senden einer Anfrage
         if(!OrderSend(request,result))
            PrintFormat("OrderSend error %d",GetLastError());  // wenn die Anfrage konnte nicht gesendet werden, den Fehlercode anzeigen
         //--- Details zur Transaktion   
         PrintFormat("retcode=%u  deal=%I64u  order=%I64u",result.retcode,result.deal,result.order);
        }
     }
  }
//+------------------------------------------------------------------+

 
Pending Order

Handelsorder, eine Handelsorder einzustellen. Man muss 11 Felder angeben:

  • action
  • symbol
  • volume
  • price
  • stoplimit
  • sl
  • tp
  • type
  • type_filling
  • type_time
  • expiration

Man kann auch Feldwerte magic und comment vorgeben.

Ein Beispiel der Transaktion TRADE_ACTION_PENDING für das Setzen einer Pending Order:

#property description "Ein Beispiel für das Platzieren von Pending Orders"
#property script_show_inputs
#define EXPERT_MAGIC 123456                             // MagicNumber des Expert Advisors
input ENUM_ORDER_TYPE orderType=ORDER_TYPE_BUY_LIMIT;   // Ordertyp
//+------------------------------------------------------------------+
//| Pending Orders setzen                                            |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- die Anfrage und das Ergebnis deklarieren und initialisieren
   MqlTradeRequest request={0};
   MqlTradeResult  result={0};
//--- Parameter für das Platzieren einer Pending Order
   request.action   =TRADE_ACTION_PENDING;                             // Typ der Transaktion
   request.symbol   =Symbol();                                         // Symbol
   request.volume   =0.1;                                              // das Volumen von 0.1 Lot
   request.deviation=2;                                                // zulässige Abweichung vom Preis
   request.magic    =EXPERT_MAGIC;                                     // MagicNumber der Order
   int offset = 50;                                                    // Abweichung von aktuellen Kurs für das Platzieren einer Order, in Punkten
   double price;                                                       // Preis, bei dem die Order ausgelöst wird
   double point=SymbolInfoDouble(_Symbol,SYMBOL_POINT);                // Punktgröße
   int digits=SymbolInfoInteger(_Symbol,SYMBOL_DIGITS);                // Stellen nach dem Komma (Genauigkeit)
   //--- den Typ der Transaktion überprüfen
   if(orderType==ORDER_TYPE_BUY_LIMIT)
     {
      request.type     =ORDER_TYPE_BUY_LIMIT;                          // Ordertyp
      price=SymbolInfoDouble(Symbol(),SYMBOL_ASK)-offset*point;        // Eröffnungskurs 
      request.price    =NormalizeDouble(price,digits);                 // normierter Eröffnungskurs 
     }
   else if(orderType==ORDER_TYPE_SELL_LIMIT)
     {
      request.type     =ORDER_TYPE_SELL_LIMIT;                          // Ordertyp
      price=SymbolInfoDouble(Symbol(),SYMBOL_BID)+offset*point;         // Eröffnungskurs 
      request.price    =NormalizeDouble(price,digits);                  // normierter Eröffnungskurs 
     }
   else if(orderType==ORDER_TYPE_BUY_STOP)
     {
      request.type =ORDER_TYPE_BUY_STOP;                                // Ordertyp
      price        =SymbolInfoDouble(Symbol(),SYMBOL_ASK)+offset*point; // Eröffnungskurs 
      request.price=NormalizeDouble(price,digits);                      // normierter Eröffnungskurs 
     }
   else if(orderType==ORDER_TYPE_SELL_STOP)
     {
      request.type     =ORDER_TYPE_SELL_STOP;                           // Ordertyp
      price=SymbolInfoDouble(Symbol(),SYMBOL_BID)-offset*point;         // Eröffnungspreis 
      request.price    =NormalizeDouble(price,digits);                  // normierter Eröffnungspreis 
     }
   else Alert("Dieses Beispiel gilt nur für das Platzieren von Pending Orders");   // wenn eine nicht Pending Order ausgewählt wurde
//--- Senden einer Anfrage
   if(!OrderSend(request,result))
      PrintFormat("OrderSend error %d",GetLastError());                 // wenn die Anfrage konnte nicht gesendet werden, den Fehlercode anzeigen
//--- Details zur Transaktion
   PrintFormat("retcode=%u  deal=%I64u  order=%I64u",result.retcode,result.deal,result.order);
  }
//+------------------------------------------------------------------+

 
Modify Pending Order

Handelsorder, Preislevels der Warteorder zu modifizieren. Man muss 7 Felder spezifizieren:

  • action
  • order
  • price
  • sl
  • tp
  • type_time
  • expiration

 

Ein Beispiel der Transaktion TRADE_ACTION_MODIFY für das Modifizieren von Preis-Levels von Pending Orders:

#define EXPERT_MAGIC 123456  // MagicNumber des EAs
//+------------------------------------------------------------------+
//| Modifizieren von Pending Orders                                  |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- die Anfrage und das Ergebnis deklarieren und initialisieren
   MqlTradeRequest request={0};
   MqlTradeResult  result={0};
   int total=OrdersTotal(); // Anzahl platzierter Pending Orders
//--- in allen gesetzten Pending Orders suchen
   for(int i=0; i<total; i++)
     {
      //--- Parameter der Order
      ulong  order_ticket=OrderGetTicket(i);                             // das Ticket der Order
      string order_symbol=Symbol();                                      // Symbol
      int    digits=(int)SymbolInfoInteger(order_symbol,SYMBOL_DIGITS);  // Stellen nach dem Komma
      ulong  magic=OrderGetInteger(ORDER_MAGIC);                         // MagicNumber der Order
      double volume=OrderGetDouble(ORDER_VOLUME_CURRENT);                // das aktuelle Volumen der Order
      double sl=OrderGetDouble(ORDER_SL);                                // der aktuelle Stop Loss der Order
      double tp=OrderGetDouble(ORDER_TP);                                // der aktuelle Take Profit der Order
      ENUM_ORDER_TYPE type=(ENUM_ORDER_TYPE)OrderGetInteger(ORDER_TYPE); // Ordertyp
      int offset = 50;                                                   // Abweichung vom aktuellen Kurs für das Platzieren einer Order, in Punkten
      double price;                                                      // Preis der Auslösung der Order
      double point=SymbolInfoDouble(order_symbol,SYMBOL_POINT);          // Punktgröße
      //--- Details zur Order anzeigen
      PrintFormat("#%I64u %s  %s  %.2f  %s  sl: %s  tp: %s  [%I64d]",
                  order_ticket,
                  order_symbol,
                  EnumToString(type),
                  volume,
                  DoubleToString(PositionGetDouble(POSITION_PRICE_OPEN),digits),
                  DoubleToString(sl,digits),
                  DoubleToString(tp,digits),
                  magic);
      //--- wenn die MagicNumber übereinstimmt, sind Stop Loss und Take Profit nicht setzt
      if(magic==EXPERT_MAGIC && sl==0 && tp==0)
        {
         request.action=TRADE_ACTION_MODIFY;                           // Typ der Transaktion
         request.order = OrderGetTicket(i);                            // das Ticket der Order
         request.symbol   =Symbol();                                   // Symbol
         request.deviation=5;                                          // zulässige Abweichung vom Preis
        //--- Preis-Level, Take Profit und Stop Loss der Order je nach Ordertyp setzen
         if(type==ORDER_TYPE_BUY_LIMIT)
           {
            price = SymbolInfoDouble(Symbol(),SYMBOL_ASK)-offset*point; 
            request.tp = NormalizeDouble(price+offset*point,digits);
            request.sl = NormalizeDouble(price-offset*point,digits);
            request.price    =NormalizeDouble(price,digits);                // normierter Eröffnungspreis
           }
         else if(type==ORDER_TYPE_SELL_LIMIT)
           {
           price = SymbolInfoDouble(Symbol(),SYMBOL_BID)+offset*point; 
            request.tp = NormalizeDouble(price-offset*point,digits);
            request.sl = NormalizeDouble(price+offset*point,digits);
            request.price    =NormalizeDouble(price,digits);                 // normierter Eröffnungspreis
           }
         else if(type==ORDER_TYPE_BUY_STOP)
           {
           price = SymbolInfoDouble(Symbol(),SYMBOL_ASK)+offset*point; 
            request.tp = NormalizeDouble(price+offset*point,digits);
            request.sl = NormalizeDouble(price-offset*point,digits);
            request.price    =NormalizeDouble(price,digits);                 // normierter Eröffnungskurs
           }
         else if(type==ORDER_TYPE_SELL_STOP)
           {
           price = SymbolInfoDouble(Symbol(),SYMBOL_BID)-offset*point; 
            request.tp = NormalizeDouble(price-offset*point,digits);
            request.sl = NormalizeDouble(price+offset*point,digits);
            request.price    =NormalizeDouble(price,digits);                 // normierter Eröffnungskurs
           }
         //--- Anfrage senden
         if(!OrderSend(request,result))
            PrintFormat("OrderSend error %d",GetLastError());  // wenn die Anfrage konnte nicht gesendet werden, den Fehlercode anzeigen
         //--- Details zur Transaktion   
         PrintFormat("retcode=%u  deal=%I64u  order=%I64u",result.retcode,result.deal,result.order);
         //--- die Werte der Anfrage und des Ergebnisses auf Null setzen
         ZeroMemory(request);
         ZeroMemory(result);
        }
     }
  }
//+------------------------------------------------------------------+

 
Delete Pending Order

Handelsorder, eine Warteorder zu entfernen. Man muss  2 Felder spezifizieren:

  • action
  • order

 

Ein Beispiel der Transaktion TRADE_ACTION_REMOVE für das Löschen von Pending Orders:

#define EXPERT_MAGIC 123456  // MagicNumber des Expert Advisors
//+------------------------------------------------------------------+
//| Pending Orders löschen                                           |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- die Anfrage und das Ergebnis deklarieren und initialisieren
   MqlTradeRequest request={0};
   MqlTradeResult  result={0};
   int total=OrdersTotal(); // Anzahl platzierter Pending Orders 
//--- in allen platzierten Pending Orders suchen
   for(int i=total-1; i>=0; i--)
     {
      ulong  order_ticket=OrderGetTicket(i);                   // das Ticket der Order
      ulong  magic=OrderGetInteger(ORDER_MAGIC);               // MagicNumber der Order
      //--- wenn die MagicNumber übereinstimmt
      if(magic==EXPERT_MAGIC)
        {
         //--- die Werte der Anfrage und des Ergebnisses auf Null setzen
         ZeroMemory(request);
         ZeroMemory(result);
         //--- Parameter der Transaktion setzen     
         request.action=TRADE_ACTION_REMOVE;                   // Typ der Transaktion
         request.order = order_ticket;                         // das Ticket der Order
         //--- Anfrage senden
         if(!OrderSend(request,result))
            PrintFormat("OrderSend error %d",GetLastError());  // wenn die Anfrage konnte nicht gesendet werden, den Fehlercode anzeigen
         //--- Details zur Transaktion   
         PrintFormat("retcode=%u  deal=%I64u  order=%I64u",result.retcode,result.deal,result.order);
        }
     }
  }
//+------------------------------------------------------------------+

 
Sehen Sie auch

Strukturen und Klassen, Handelsfunktionen, Ordereigenschaften