Referência MQL5Funções de NegociaçãoOrderSend

OrderSend

A função OrderSend() é usada para a execução de operações de negociação enviando solicitações para um servidor de negociação.

bool  OrderSend(
   MqlTradeRequest&  request,      // estrutura de pedido
   MqlTradeResult&   result        // estrutura da resposta
   );

Parâmetros

request

[in] Ponteiro para uma estrutura de tipo MqlTradeRequest descrevendo a atividade de negociação do cliente.

result

[in,out] Ponteiro para uma estrutura do tipo MqlTradeResult descrevendo o resultado da operação comercial, no caso de uma realização bem sucedida (se True é retornado).

Valor do Retorno

Em caso de sucesso na verificação básica de estruturas (verificação do índice) retorna True. No entanto, este não é um sinal de sucesso com execução de uma operação de negociação . Para uma descrição mais detalhada do resultado da execução da função, analisar os domínios da estrutura de resultado.

Observação

Os pedidos de negociação passar por várias etapas de verificação de um servidor de negociação. Primeiro de tudo, ele verifica se todos os campos obrigatórios dos parâmetros de solicitação estão preenchidos corretamente. Se não houver erros nesta guia, você pode iniciar o programa no terminal cliente. Se o pedido for aceito com sucesso pelo servidor de negociação, o OrderSend() retorna True.

Recomenda-se verificar o pedido antes de enviá-lo para um servidor de negociação. Para verificar os pedidos, use a função OrderCheck(). Ele verifica se há fundos suficientes para executar a operação de negociação, e retorna muitos parâmetros úteis nos resultados da verificação do pedido de negociação:

código de retorno contém informações sobre erros no pedido verificado;
Valor de saldo após a execução da operação de negociação;
valor de eqüidade que irá aparecer após a operação comercial é executado;
valor de ponto flutuante que irá aparecer após a operação de negociação for executado;
Margem requerida para a operação de negociação;
quantidade de capital livre que permanecerá após a execução da operação de negociação;
o nível da margem que será definido após a operação de negociação for executado;
Comentário sobre o código da resposta, descrição do erro.

Ao enviar uma ordem a mercado (MqlTradeRequest.action=TRADE_ACTION_DEAL), o resultado bem-sucedido da função OrderSend() não significa que a ordem tenha sido executada (executadas as transações correspondentes): neste caso, true apenas significa que a ordem foi colocada corretamente no sistema de negociação para execução posterior. Na estrutura do resultado result a ser retornada, o servidor de negociação pode preencher os valores dos campos deal ou order, se esse dados forem conhecidos por ele, no momento da formação da resposta à chamada da OrderSend(). Em geral, o(s) evento(s) da execução das transações, da ordem correspondente, podem ocorrer após ter sido enviada a resposta à chamada da OrderSend(). Por isso, para qualquer tipo de solicitação de negociação, após obtido o resultado da execução da OrderSend(), é necessário, antes de tudo, verificar o código de retorno do servidor de negociação retcode e o código de resposta do sistema de negociação externo retcode_external (se necessário), que estão disponíveis na estrutura do resultado result a ser retornada.

Cada pedido aceito é armazenado no servidor de negociação esperando o processamento até que ocorre uma das condições para a sua execução:

expiração,
aparecimento de uma solicitação oposta,
execução da ordem, quando o preço de execução aparece,
uma solicitação para cancelar a ordem é recebido.

No momento do processamento da ordem, o servidor de negociaçãos envia ao terminal uma mensagem sobre a ocorrência do evento Trade (evento de negociação), que pode ser processado pela função OnTrade().

O resultado da execução do pedido de negociação sobre o servidor enviado pela função OrderSend() pode ser controlada pelo handler (Manipulador) OnTradeTransaction. Deve ser observado que o handler (manipulador) OnTradeTransaction será chamado várias vezes durante a execução de um pedido de negociação.

Por exemplo, ao enviar uma ordem de compra de mercado, ela é tratada, uma ordem de compra apropriada é criada para a conta, a ordem é então executada e removida da lista de ordens em aberto, e então ela é adicionada ao histórico de ordens, uma apropriada operação (deal) é adicionada ao histórico e uma nova posição é criada. Função OnTradeTransaction será chamado para cada um desses eventos.

Exemplo:

//--- valor para ORDER_MAGIC
input long order_magic=55555;
//+------------------------------------------------------------------+
//| Programa Script da função start (iniciar)                        |
//+------------------------------------------------------------------+
void OnStart()
  {
//--- Ter a certeza que é uma conta demonstração
   if(AccountInfoInteger(ACCOUNT_TRADE_MODE)==ACCOUNT_TRADE_MODE_REAL)
     {
      Alert("Operação de script não é permitido em uma conta real!");
      return;
     }
//--- Colocar ou deletar uma ordem
   if(GetOrdersTotalByMagic(order_magic)==0)
     {
      //--- Não ordens atuais - colocar uma ordem
      uint res=SendRandomPendingOrder(order_magic);
      Print("Retorna código do servidor de negociação",res);
     }
   else // existem ordens - deletar ordens
     {
      DeleteAllOrdersByMagic(order_magic);
     }
//---
  }
//+------------------------------------------------------------------+
//| Receber o número das atuais ordens atuais com especificação      |
//+------------------------------------------------------------------+
int GetOrdersTotalByMagic(long const magic_number)
  {
   ulong order_ticket;
   int total=0;
//--- passar por todas as ordens pendentes
   for(int i=0;i<OrdersTotal();i++)
      if((order_ticket=OrderGetTicket(i))>0)
         if(magic_number==OrderGetInteger(ORDER_MAGIC)) total++;
//---
   return(total);
  }
//+------------------------------------------------------------------+
//| Deletar todas as ordens pendentes com especificação ORDER_MAGIC  |
//+------------------------------------------------------------------+
void DeleteAllOrdersByMagic(long const magic_number)
  {
   ulong order_ticket;
//--- passar por todas as ordens pendentes
   for(int i=OrdersTotal()-1;i>=0;i--)
      if((order_ticket=OrderGetTicket(i))>0)
         //--- ordem com apropriado ORDER_MAGIC
         if(magic_number==OrderGetInteger(ORDER_MAGIC))
           {
            MqlTradeResult result={};
            MqlTradeRequest request={};
            request.order=order_ticket;
            request.action=TRADE_ACTION_REMOVE;
            OrderSend(request,result);
            //--- escrever a resposta do servidor para log
            Print(__FUNCTION__,": ",result.comment," reply code ",result.retcode);
           }
//---
  }
//+------------------------------------------------------------------+
//| Definir uma ordem pendente de maneira aleatória                  |
//+------------------------------------------------------------------+
uint SendRandomPendingOrder(long const magic_number)
  {
//--- preparar um pedido
   MqlTradeRequest request={};
   request.action=TRADE_ACTION_PENDING;         // definição de uma ordem pendente
   request.magic=magic_number;                  // ORDER_MAGIC
   request.symbol=_Symbol;                      // símbolo
   request.volume=0.1;                          // volume em 0.1 lotes
   request.sl=0;                                // Stop Loss (Parar Perda) não é especificado
   request.tp=0;                                // Take Profit (Tomar Lucro) não é especificado
//--- formar o tipo de ordem
   request.type=GetRandomType();                // tipo de ordem
//--- formar o preço para uma ordem pendente
   request.price=GetRandomPrice(request.type);  // preço de abertura
//--- enviar um pedido de negociação
   MqlTradeResult result={};
   OrderSend(request,result);
//--- escrever resposta do servido para log
   Print(__FUNCTION__,":",result.comment);
   if(result.retcode==10016) Print(result.bid,result.ask,result.price);
//--- código de retorno da resposta do servidor de negociação
   return result.retcode;
  }
//+------------------------------------------------------------------+
//| tipo de retorno de uma ordem pendente de maneira aleatória       |
//+------------------------------------------------------------------+
ENUM_ORDER_TYPE GetRandomType()
  {
   int t=MathRand()%4;
//---   0<=t<4
   switch(t)
     {
      case(0):return(ORDER_TYPE_BUY_LIMIT);
      case(1):return(ORDER_TYPE_SELL_LIMIT);
      case(2):return(ORDER_TYPE_BUY_STOP);
      case(3):return(ORDER_TYPE_SELL_STOP);
     }
//--- valor incorreto
   return(WRONG_VALUE);
  }
//+------------------------------------------------------------------+
//|  retorno do preço de forma aleatória                             |
//+------------------------------------------------------------------+
double GetRandomPrice(ENUM_ORDER_TYPE type)
  {
   int t=(int)type;
//--- níveis de stop (parar) para símbolo
   int distance=(int)SymbolInfoInteger(_Symbol,SYMBOL_TRADE_STOPS_LEVEL);
//--- receber dados do último tick (ponto)
   MqlTick last_tick={};
   SymbolInfoTick(_Symbol,last_tick);
//--- calcular o preço de acordo com o tipo
   double price;
   if(t==2 || t==5) // ORDER_TYPE_BUY_LIMIT ou ORDER_TYPE_SELL_STOP
     {
      price=last_tick.bid; // divergir do preço de compra
      price=price-(distance+(MathRand()%10)*5)*_Point;
     }
   else             // ORDER_TYPE_SELL_LIMIT ou ORDER_TYPE_BUY_STOP
     {
      price=last_tick.ask; // divergir do preço de venda
      price=price+(distance+(MathRand()%10)*5)*_Point;
     }
//---
   return(price);
  }

Veja Também

Tipos de Operação de Negociação, Estrutura de Solicitação de Negociação, Estrutura de Solicitação de Verificação de Resultados, Estrutura de uma Solicitação de Resultado de Negociação

OrderCheck

OrderSendAsync