MetaTrader 5 herunterladen

Typen der Handelsoperationen

Handel wird durch Senden der Befehlsanweisungen, Positionen zu öffnen und auch  Befehlsanweisungen, wartende Order einzustellen, modifizieren und entfernen unter Verwendung der Funktion OrderSend(). Jede Handelsorder deutet auf den Typ der angeforderten Handelsoperation.  Handelsoperationen werden in der Enumeration ENUM_TRADE_REQUEST_ACTIONS beschrieben.

ENUM_TRADE_REQUEST_ACTIONS

Identifikator

Beschreibung

TRADE_ACTION_DEAL

Handelsorder auf den sofortigen Dealabschluss mit den angegebenen Parametern stellen (Marktorder stellen)

TRADE_ACTION_PENDING

Handelsorder für Dealabschluss bei den angegebenen Bedingungen (wartende Order) stellen

TRADE_ACTION_SLTP

die Werte  Stop Loss und Take Profit der offenen Position verändern

TRADE_ACTION_MODIFY

Parameter der früher eingestellten Order verändern

TRADE_ACTION_REMOVE

Wartende Handelsserver entfernen

TRADE_ACTION_CLOSE_BY

Close a position by an opposite one

 
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);
         //---
        }
     }
  }
//+------------------------------------------------------------------+

 
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_ASK)+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_ASK)-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);
  }
//+------------------------------------------------------------------+

 
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(ask+price_level,digits);
           }
         else
           {
            sl=NormalizeDouble(ask+price_level,digits);
            tp=NormalizeDouble(bid-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);
        }
     }
  }
//+------------------------------------------------------------------+

 
Ein Beispiel der Transkation 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_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
           }
         else if(type==ORDER_TYPE_SELL_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
           }
         //--- 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);
        }
     }
  }
//+------------------------------------------------------------------+

 
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);
        }
     }
  }
//+------------------------------------------------------------------+

 
Ein Beispiel der Transaktion TRADE_ACTION_CLOSE_BY für das Schließen zur Gegenposition:

#define EXPERT_MAGIC 123456  // MagicNumber des EAs
//+------------------------------------------------------------------+
//| Alle Positionen zu Gegenpositionen schließen                     |
//+------------------------------------------------------------------+
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);                               // 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
      if(magic==EXPERT_MAGIC)
        {
         for(int j=0; j<i; j++)
           {
            string symbol=PositionGetSymbol(j); // das Symbol der Gegenposition
            //--- wenn das Symbol der Gegenposition mit dem Symbol der gesuchten übereinstimmen
            if(symbol==position_symbol && PositionGetInteger(POSITION_MAGIC)==EXPERT_MAGIC)
              {
               //--- Typ der Gegenposition setzen
               ENUM_POSITION_TYPE type_by=(ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
               //--- beenden, wenn die Typen der Positionen gleich sind
               if(type==type_by)
                  continue;
               //--- die Werte der Anfrage und des Ergebnisses auf Null setzen
               ZeroMemory(request);
               ZeroMemory(result);
               //--- Parameter der Transaktion setzten
               request.action=TRADE_ACTION_CLOSE_BY;                         // Typ der Transaktion
               request.position=position_ticket;                             // Ticket der Position
               request.position_by=PositionGetInteger(POSITION_TICKET);      // Ticket der Gegenposition
               //request.symbol     =position_symbol;
               request.magic=EXPERT_MAGIC;                                   // MagicNumber der Position
               //--- Information über das Schließen zur Gegenposition anzeigen
               PrintFormat("Close #%I64d %s %s by #%I64d",position_ticket,position_symbol,EnumToString(type),request.position_by);
               //--- 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);
              }
           }
        }
     }
  }
//+------------------------------------------------------------------+