Manual de referencia de MQL5Constantes, Enumeraciones y EstruturasEstructuras de datosEstructura de solicitud comercial

Estructura de solicitud comercial (MqlTradeRequest)

La interacción entre el terminal de cliente y el servidor comercial con el fin de ejecutar las operaciones de colocación de las órdenes se realiza a través de las solicitudes comerciales. La solicitud comercial está representada por la estructura especial predefinida MqlTradeRequest que contiene todos los campos necesarios para celebrar las transacciones comerciales. El resultado de procesamiento de una solicitud está representado por la estructura MqlTradeResult.

struct MqlTradeRequest
  {
   ENUM_TRADE_REQUEST_ACTIONS    action;           // Tipo de acción que se ejecuta
   ulong                         magic;            // ID del Asesor Experto (identificador magic number)
   ulong                         order;            // Ticket de la orden
   string                        symbol;           // Nombre del instrumento comercial
   double                        volume;           // Volumen solicitado de la transacción en lotes
   double                        price;            // Precio
   double                        stoplimit;        // Nivel StopLimit de la orden
   double                        sl;               // Nivel Stop Loss de la orden
   double                        tp;               // Nivel Take Profit de la orden
   ulong                         deviation;        // Desviación máxima aceptable del precio solicitado
   ENUM_ORDER_TYPE               type;             // Tipo de orden
   ENUM_ORDER_TYPE_FILLING       type_filling;     // Tipo de ejecución de la orden
   ENUM_ORDER_TYPE_TIME          type_time;        // Tipo de orden por su plazo de ejecución
   datetime                      expiration;       // Plazo de expiración de la orden (para las órdenes del tipo ORDER_TIME_SPECIFIED)
   string                        comment;          // Comentarios sobre la orden
   ulong                         position;         // Position ticket
   ulong                         position_by;      // Comentarios sobre la orden
  };

Descripción de campos

Campo	Descripción
action	Tipo de operación comercial. El valor puede ser uno de los valores de la enumeración ENUM_TRADE_REQUEST_ACTIONS
magic	Identificador del Asesor Experto. Permite organizar el procesamiento analítico de las órdenes comerciales. Cada Asesor Experto puede establecer su propio identificador personal único a la hora de mandar una solicitud comercial.
order	Ticket de la orden. Se necesita para modificar las órdenes pendientes.
symbol	Nombre del instrumento financiero (símbolo) para el que se coloca una orden. No se necesita para modificar las órdenes y cerrar las posiciones.
volume	Volumen solicitado de la transacción en lotes. El valor real del volumen dependerá del tipo de ejecución de la orden.
price	Precio. Al alcanzarlo, la orden tiene que ejecutarse. Las órdenes del mercado de símbolos, cuyo tipo de ejecución es "Market Execution" (SYMBOL_TRADE_EXECUTION_MARKET), del tipo TRADE_ACTION_DEAL, no requieren la especificación del precio.
stoplimit	Precio según el cual será colocado la orden pendiente Limit, cuando el precio alcance el valor price (esta condición es obligatoria). Hasta entonces la orden pendiente no se introduce en el sistema.
sl	Precio que activará la orden Stop Loss, si el precio se mueve en la dirección desfavorable
tp	Precio que activará la orden Take Profit. si el precio se mueve en la dirección favorable
deviation	Desviación máxima aceptable del precio solicitado, se especifica en puntos
type	Tipo de la orden. Su valor puede ser uno de los valores de la enumeración ENUM_ORDER_TYPE
type_filling	Tipo de ejecución de la orden. Su valor puede ser uno de los valores de ENUM_ORDER_TYPE_FILLING
type_time	Tipo de orden por su plazo de ejecución. Su valor puede ser uno de los valores de ENUM_ORDER_TYPE_TIME
expiration	Plazo de expiración de la orden (para las órdenes del tipo ORDER_TIME_SPECIFIED)
comment	Comentarios sobre la orden

Al modificar o cerrar una posición en el sistema de cobertura, asegúrese de indicar su ticket (MqlTradeRequest::position). En el sistema de compensación el ticket también se puede indicar, sin embargo, la identificación de la posición tiene lugar según el nombre del símbolo.

Para dar las órdenes de ejecución de las operaciones comerciales es necesario usar la función OrderSend(). Para cada operación comercial hay que indicar los campos obligatorios, también se puede rellenar campos opcionales. En total hay siete formas de enviar una solicitud comercial:

Request Execution

Es una orden comercial para abrir una posición en el régimen Request Execution (régimen de actividad comercial sobre solicitud de precios actuales). Se requiere especificar 9 campos:

action
symbol
volume
price
sl
tp
deviation
type
type_filling

Además se puede definir los valores de los campos magic y comment.

Instant Execution

Es una orden comercial para abrir una posición en el régimen Instant Execution (régimen de actividad comercial a base de los precios corrientes). Se requiere especificar 9 campos:

action
symbol
volume
price
sl
tp
deviation
type
type_filling

Además se puede definir los valores de los campos magic comment.

Market Execution

Es una orden comercial para abrir una posición en el régimen Market Execution (régimen de ejecución de las órdenes comerciales en el mercado). Se requiere especificar 5 campos:

action
symbol
volume
type
type_filling

Además se puede definir los valores de los campos magic y comment.

Exchange Execution

Es una orden comercial para abrir una posición en el régimen Exchange Execution (modo de ejecución de órdenes comerciales por bolsa). Se requiere especificar 5 campos:

action
symbol
volume
type
type_filling

Además se puede definir los valores de los campos magic y comment.

Ejemplo de la operación comercial TRADE_ACTION_DEAL para abrir una posición Buy:

#define EXPERT_MAGIC 123456   // MagicNumber эксперта
//+------------------------------------------------------------------+
//| Apertura de posición Buy                                         |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- declaración e inicialización de la solicitud y el resultado
   MqlTradeRequest request={};
   MqlTradeResult  result={};
//--- parámetros de la solicitud
   request.action   =TRADE_ACTION_DEAL;                     // tipo de operación comercial
   request.symbol   =Symbol();                              // símbolo
   request.volume   =0.1;                                   // volumen de 0.1 lote
   request.type     =ORDER_TYPE_BUY;                        // tipo de orden
   request.price    =SymbolInfoDouble(Symbol(),SYMBOL_ASK); // precio de apertura
   request.deviation=5;                                     // desviación permisible del precio
   request.magic    =EXPERT_MAGIC;                          // Número mágico de la orden
//--- envío de la solicitud
   if(!OrderSend(request,result))
      PrintFormat("OrderSend error %d",GetLastError());     // si no se ha logrado enviar la solicitud, introducir el código de error
//--- información sobre la operación
   PrintFormat("retcode=%u  deal=%I64u  order=%I64u",result.retcode,result.deal,result.order);
  }
//+------------------------------------------------------------------+

Ejemplo de la operación comercial TRADE_ACTION_DEAL para abrir una posición Sell:

#define EXPERT_MAGIC 123456   // Número mágico del experto
//+------------------------------------------------------------------+
//| Apertura de posición Sell                                        |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- declaración e inicialización de la solicitud y el resultado
   MqlTradeRequest request={};
   MqlTradeResult  result={};
//--- parámetros de la solicitud
   request.action   =TRADE_ACTION_DEAL;                     // tipo de operación comercial
   request.symbol   =Symbol();                              // símbolo
   request.volume   =0.2;                                   // volumen 0.2 lote
   request.type     =ORDER_TYPE_SELL;                       // tipo de orden
   request.price    =SymbolInfoDouble(Symbol(),SYMBOL_BID); // precio de apertura
   request.deviation=5;                                     // desviación permisible del precio
   request.magic    =EXPERT_MAGIC;                          // Número mágico de la orden
//--- envío de la solicitud
   if(!OrderSend(request,result))
      PrintFormat("OrderSend error %d",GetLastError());     // si no se ha logrado enviar la solicitud, mostrar el código de error
//--- información sobre la operación
   PrintFormat("retcode=%u  deal=%I64u  order=%I64u",result.retcode,result.deal,result.order);
  }
//+------------------------------------------------------------------+

Ejemplo de la operación comercial TRADE_ACTION_DEAL para cerrar una posición:

#define EXPERT_MAGIC 123456   // Número mágico del experto
//+------------------------------------------------------------------+
//| Cierre de todas las posiciones                                   |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- declaración de la solicitud y el resultado
   MqlTradeRequest request;
   MqlTradeResult  result;
   int total=PositionsTotal(); // número de posiciones abiertas
//--- iteración de todas las posiciones abiertas
   for(int i=total-1; i>=0; i--)
     {
      //--- parámetros de la orden
      ulong  position_ticket=PositionGetTicket(i);                                      // ticket de la posición
      string position_symbol=PositionGetString(POSITION_SYMBOL);                        // símbolo
      int    digits=(int)SymbolInfoInteger(position_symbol,SYMBOL_DIGITS);              // número de dígitos tras la coma
      ulong  magic=PositionGetInteger(POSITION_MAGIC);                                  // Número mágico de la posición
      double volume=PositionGetDouble(POSITION_VOLUME);                                 // volumen de la posición
      ENUM_POSITION_TYPE type=(ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);    // tipo de posición
      //--- mostrar la información de la posición
      PrintFormat("#%I64u %s  %s  %.2f  %s [%I64d]",
                  position_ticket,
                  position_symbol,
                  EnumToString(type),
                  volume,
                  DoubleToString(PositionGetDouble(POSITION_PRICE_OPEN),digits),
                  magic);
      //--- si el número mágico coincide
      if(magic==EXPERT_MAGIC)
        {
         //--- reseteo de los valores de la solicitud y el resultado
         ZeroMemory(request);
         ZeroMemory(result);
         //--- establecer los parámetros de la operación
         request.action   =TRADE_ACTION_DEAL;        // tipo de operación comercial
         request.position =position_ticket;          // ticket de la posición
         request.symbol   =position_symbol;          // símbolo
         request.volume   =volume;                   // volumen de la posición
         request.deviation=5;                        // desviación permisible del precio
         request.magic    =EXPERT_MAGIC;             // Número mágico de la posición
         //--- establecer el precio y el tipo de orden dependiendo del tipo de posición
         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;
           }
         //--- mostrar información sobre el cierre
         PrintFormat("Close #%I64d %s %s",position_ticket,position_symbol,EnumToString(type));
         //--- envío de la solicitud
         if(!OrderSend(request,result))
            PrintFormat("OrderSend error %d",GetLastError());  // si no se ha logrado enviar la solicitud, mostrar el código de error
         //--- información sobre la operación
         PrintFormat("retcode=%u  deal=%I64u  order=%I64u",result.retcode,result.deal,result.order);
         //---
        }
     }
  }
//+------------------------------------------------------------------+

SL & TP Modification

Es una orden comercial para modificar los niveles StopLoss y/o TakeProfit. Se requiere especificar 4 campos:

action
symbol
sl
tp

Ejemplo de la operación comercial TRADE_ACTION_SLTP para cambiar los valores de Stop Loss y Take Profit de una posición abierta:

#define EXPERT_MAGIC 123456  // Número mágico del experto
//+------------------------------------------------------------------+
//| Modificación de Stop Loss y Take Profit de la posición           |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- declaración de la solicitud y el resultado
   MqlTradeRequest request;
   MqlTradeResult  result;
   int total=PositionsTotal(); // número de posiciones abiertas
//--- iteración de todas las posiciones abiertas
   for(int i=0; i<total; i++)
     {
      //--- parámetros de la orden
      ulong  position_ticket=PositionGetTicket(i);// ticket de la posición
      string position_symbol=PositionGetString(POSITION_SYMBOL); // símbolo
      int    digits=(int)SymbolInfoInteger(position_symbol,SYMBOL_DIGITS); // número de dígitos tras la coma
      ulong  magic=PositionGetInteger(POSITION_MAGIC); // Número mágico de la posición
      double volume=PositionGetDouble(POSITION_VOLUME);    // volumen de la posición
      double sl=PositionGetDouble(POSITION_SL);  // Stop Loss de la posición
      double tp=PositionGetDouble(POSITION_TP);  // Take Profit de la posición
      ENUM_POSITION_TYPE type=(ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);  // tipo de posición
      //--- mostrar información de la posición
      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);
      //--- si el número mágico coincide, Stop Loss y Take Profit no han sido establecidos
      if(magic==EXPERT_MAGIC && sl==0 && tp==0)
        {
         //--- cálculo de los niveles de precio actuales
         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;
         //--- si el nivel de separación máxima permitida en puntos con respecto al precio de cierre actual no ha sido establecido
         if(stop_level<=0)
            stop_level=150; // establecemos una separación de 150 puntos con respecto el precio de cierre actual
         else
            stop_level+=50; // tomaremos un nivel de separación igual a (SYMBOL_TRADE_STOPS_LEVEL + 50) puntos para estar seguros

         //--- cálculo y redondeo de los valores de Stop Loss y Take Profit
         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);
           }
         //--- reseteo de los valores de la solicitud y el resultado
         ZeroMemory(request);
         ZeroMemory(result);
         //--- establecer los parámetros de la operación
         request.action  =TRADE_ACTION_SLTP; // tipo de operación comercial
         request.position=position_ticket;   // ticket de la posición
         request.symbol=position_symbol;     // símbolo
         request.sl      =sl;                // Stop Loss de la posición
         request.tp      =tp;                // Take Profit de la posición
         request.magic=EXPERT_MAGIC;         // Número mágico de la posición
         //--- mostrar información de la modificación
         PrintFormat("Modify #%I64d %s %s",position_ticket,position_symbol,EnumToString(type));
         //--- envío de la solicitud
         if(!OrderSend(request,result))
            PrintFormat("OrderSend error %d",GetLastError());  // si no se ha logrado enviar la solicitud, mostrar el código de error
         //--- información sobre la operación
         PrintFormat("retcode=%u  deal=%I64u  order=%I64u",result.retcode,result.deal,result.order);
        }
     }
  }
//+------------------------------------------------------------------+

Pending Order

Es una orden comercial para colocar una orden pendiente. Se requiere especificar 11 campos:

action
symbol
volume
price
stoplimit
sl
tp
type
type_filling
type_time
expiration

Además se puede definir los valores de los campos magic y comment.

Ejemplo de la operación comercial TRADE_ACTION_PENDING para colocar una orden pendiente:

#property description "Ejemplo de colocación de órdenes pendientes"
#property script_show_inputs
#define EXPERT_MAGIC 123456                             // Número mágico del experto
input ENUM_ORDER_TYPE orderType=ORDER_TYPE_BUY_LIMIT;   // tipo de orden
//+------------------------------------------------------------------+
//| Colocar órdenes pendientes                                       |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- declaración e inicialización de la solicitud y el resultado
   MqlTradeRequest request={};
   MqlTradeResult  result={};
//--- parámetros para la colocación de una orden pendiente
   request.action   =TRADE_ACTION_PENDING;                             // tipo de operación comercial
   request.symbol   =Symbol();                                         // símbolo
   request.volume   =0.1;                                              // volumen 0.1 lote
   request.deviation=2;                                                // desviación permisible del precio
   request.magic    =EXPERT_MAGIC;                                     // Número mágico de la orden
   int offset = 50;                                                    // distancia con respecto al precio actual para poner la orden, en puntos
   double price;                                                       // precio de activación de la orden
   double point=SymbolInfoDouble(_Symbol,SYMBOL_POINT);                // tamaño del punto
   int digits=SymbolInfoInteger(_Symbol,SYMBOL_DIGITS);                // número de dígitos tras la coma (precisión)
   //--- comprobación del tipo de operación
   if(orderType==ORDER_TYPE_BUY_LIMIT)
     {
      request.type     =ORDER_TYPE_BUY_LIMIT;                          // tipo de orden
      price=SymbolInfoDouble(Symbol(),SYMBOL_ASK)-offset*point;        // precio de apertura
      request.price    =NormalizeDouble(price,digits);                 // precio de apertura normalizado
     }
   else if(orderType==ORDER_TYPE_SELL_LIMIT)
     {
      request.type     =ORDER_TYPE_SELL_LIMIT;                          // tipo de orden
      price=SymbolInfoDouble(Symbol(),SYMBOL_BID)+offset*point;         // precio de apertura
      request.price    =NormalizeDouble(price,digits);                  // precio de apertura normalizado
     }
   else if(orderType==ORDER_TYPE_BUY_STOP)
     {
      request.type =ORDER_TYPE_BUY_STOP;                                // tipo de orden
      price        =SymbolInfoDouble(Symbol(),SYMBOL_ASK)+offset*point; // precio de apertura
      request.price=NormalizeDouble(price,digits);                      // precio de apertura normalizado
     }
   else if(orderType==ORDER_TYPE_SELL_STOP)
     {
      request.type     =ORDER_TYPE_SELL_STOP;                           // tipo de orden
      price=SymbolInfoDouble(Symbol(),SYMBOL_BID)-offset*point;         // precio de apertura
      request.price    =NormalizeDouble(price,digits);                  // precio de apertura normalizado
     }
   else Alert("Este ejemplo es solo para colocar órdenes pendientes");   // si no se ha elegido una orden pendiente
//--- enviar solicitud
   if(!OrderSend(request,result))
      PrintFormat("OrderSend error %d",GetLastError());                 // si no se ha logrado enviar la solicitud, mostrar el código de error
//--- información sobre la operación
   PrintFormat("retcode=%u  deal=%I64u  order=%I64u",result.retcode,result.deal,result.order);
  }
//+------------------------------------------------------------------+

Modify Pending Order

Es una orden comercial para modificar los precios de una orden pendiente. Se requiere especificar 7 campos:

action
order
price
sl
tp
type_time
expiration

Ejemplo de la operación comercial TRADE_ACTION_MODIFY para modificar los niveles de precio de las órdenes pendientes:

#define EXPERT_MAGIC 123456  // Número mágico del experto
//+------------------------------------------------------------------+
//| Modificación de órdenes pendientes                               |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- declaración e incialización de la solicitud y el resultado
   MqlTradeRequest request={};
   MqlTradeResult  result={};
   int total=OrdersTotal(); // número de órdenes pendientes colocadas
//--- iteración de todas las órdenes pendientes colocadas
   for(int i=0; i<total; i++)
     {
      //--- parámetros de la orden
      ulong  order_ticket=OrderGetTicket(i);                             // ticket de la orden
      string order_symbol=Symbol();                                      // símbolo
      int    digits=(int)SymbolInfoInteger(order_symbol,SYMBOL_DIGITS);  // número de dígitos tras la coma
      ulong  magic=OrderGetInteger(ORDER_MAGIC);                         // Número mágico de la orden
      double volume=OrderGetDouble(ORDER_VOLUME_CURRENT);                // volumen actual de la orden
      double sl=OrderGetDouble(ORDER_SL);                                // Stop Loss actual de la orden
      double tp=OrderGetDouble(ORDER_TP);                                // Take Profit actual de la orden
      ENUM_ORDER_TYPE type=(ENUM_ORDER_TYPE)OrderGetInteger(ORDER_TYPE); // tipo de orden
      int offset = 50;                                                   // distancia con respecto al precio actual para la colocación de una orden, en puntos
      double price;                                                      // precio de activación de la orden
      double point=SymbolInfoDouble(order_symbol,SYMBOL_POINT);          // tamaño del punto
      //--- mostrar información sobre la orden
      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);
      //--- si el número mágico coincide, Stop Loss y Take Profit no han sido establecidos
      if(magic==EXPERT_MAGIC && sl==0 && tp==0)
        {
         request.action=TRADE_ACTION_MODIFY;                           // tipo de operación comercial
         request.order = OrderGetTicket(i);                            // ticket de la orden
         request.symbol   =Symbol();                                   // símbolo
         request.deviation=5;                                          // desviación permisible del precio
        //--- establecer los niveles de precio, Take Profit y Stop Loss de la orden dependiendo de su tipo
         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);                // precio de apertura normalizado
           }
         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);                 // precio de apertura normalizado
           }
         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);                 // precio de apertura normalizado
           }
         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);                 // precio de apertura normalizado
           }
         //--- envío de la solicitud
         if(!OrderSend(request,result))
            PrintFormat("OrderSend error %d",GetLastError());  // si no se ha logrado enviar la solicitud, mostrar el código de error
         //--- información sobre la operación
         PrintFormat("retcode=%u  deal=%I64u  order=%I64u",result.retcode,result.deal,result.order);
         //--- reseteo de los valores de la solicitud y el resultado
         ZeroMemory(request);
         ZeroMemory(result);
        }
     }
  }
//+------------------------------------------------------------------+

Delete Pending Order

Es una orden comercial para eliminar una orden pendiente. Se requiere especificar 2 campos:

action
order

Ejemplo de la operación comercial TRADE_ACTION_REMOVE para eliminar órdenes pendientes:

#define EXPERT_MAGIC 123456  // Número mágico del experto
//+------------------------------------------------------------------+
//| Eliminación de órdenes pendientes                                |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- declaración e inicialización de la solicitud y el resultado
   MqlTradeRequest request={};
   MqlTradeResult  result={};
   int total=OrdersTotal(); // cantidad de órdenes pendientes establecidas
//--- iteración de todas las órdenes pendientes establecidas
   for(int i=total-1; i>=0; i--)
     {
      ulong  order_ticket=OrderGetTicket(i);                   // ticket de la orden
      ulong  magic=OrderGetInteger(ORDER_MAGIC);               // Número mágico de la orden
      //--- si el número mágico coincide
      if(magic==EXPERT_MAGIC)
        {
         //--- reseteo de los valores de la solicitud y el resultado
         ZeroMemory(request);
         ZeroMemory(result);
         //--- establecer los parámetros de la operación
         request.action=TRADE_ACTION_REMOVE;                   // tipo de operación comercial
         request.order = order_ticket;                         // ticket de la orden
         //--- envío de la solicitud
         if(!OrderSend(request,result))
            PrintFormat("OrderSend error %d",GetLastError());  // si no se ha logrado enviar la solicitud, mostrar el código de error
         //--- información sobre la operación
         PrintFormat("retcode=%u  deal=%I64u  order=%I64u",result.retcode,result.deal,result.order);
        }
     }
  }
//+------------------------------------------------------------------+

Véase también

Estructuras y clases, Funciones comerciales, Propiedades de órdenes

Estructura de profundidad de mercado

Estructura de resultados de verificación de una solicitud comercial