交易之间的停顿

1.是必须还是好意?

在 МetaТrader 3客户终端中，在两笔交易中需要停留10秒钟的时间。在 MetaQuotes Software Corporation 公司创建 МТ4时，出于交易者的意愿删除了这个限定。事实上，这种情况是接收一个接一个的交易执 (对于一些仓位移动止损水平,移除挂单交易等等)。但有些交易者认为交易之间的停顿是错误的，并且进行设置智能交易可以不间断的开仓。这种结果导致账户被封，在经纪的角度这是不友好的态度。

这篇文章的目的是使交易者和经纪人双方都能够感受到舒适的交易。

2. 一个智能交易或几个智能交易:它们又怎样的区别？

如果您只有一个终端开启并且只有一个智能交易运行，它自己会很自然地安排交易之间的停顿：:创建整体变量 (整体变量水平，不要与终端的整体变量混淆)并且存储到最近交易时间。当然，在你执行每笔交易之前， 你可以检测间隔时间是否能够接受。

请看示例如下:

datetime LastTradeTime = 0;
int start()
 {
  // 检测是否进入市场
  ...
  // 计算止损水平，赢利水平和标准手数 
  ...
  // 在最后一笔交易完成后检测停顿时间
  if(LocalTime() - LastTradeTime < 10)
   {
    Comment("在最后一笔交易完成后停顿少于10秒!",
            " 智能交易不能交易!"); 
    return(-1);
   }
 
  // 开仓
  if(OrderSend(...) < 0)
   {
    Alert( "错误开仓位置 # ", GetLastError() );
    return(-2);
   }
    
  // 记住最后交易时间
  LastTradeTime = LocalTime();
 
  return(0);
 }

这个示例只适用于一个终端的一个智能交易运行。如果一个或多个智能交易同时运行，交易之间的停顿将不会保持在10 秒。当其他智能交易进行交易时，他们没有任何意识。每个智能交易都有自己的 LastTradeTime 变量。从上面我们得出一个很明显的结论: 你应该创建一个整体变量并且记住最近的交易时间。这里我们只的是终端的整体变量，所有的智能交易都将从这里通过。

3. 函数 _PauseBeforeTrade()

虽然代码实现的停顿对于所有的智能交易都是相同的，此函数将会更加合理地安排。将可以提供的智能交易代码的最大可用性和最小成交量。

在开始编写代码之前，让我们一步一步地按照指令执行 - 这样能够减少时间同样可以避免不必要的错误。那么，函数需要做到以下这些:

• 检测整体变量是否创建。如果没有整体变量，创建它。 从智能交易的init()函数中创建和保存更加符合逻辑，但随后可能被用户删除并且所有的智能交易将在此时停止保持交易之间的停顿。所以我们需要将其放置到函数中创建；
  
• 记住整体变量中的当前时间 ，使其他的智能交易保持停顿；
• 在最后的交易结束后，检测时间是否够用。为了使用方便，需要添加一个外部变量来设定停顿的持续时间。对于每个智能交易变量值可以改变;
• 显示信息，在运行中程序处理和错误生成；
• 在执行结果中返回不同值.

在最后的交易结束后，如果函数探测到时间不足，必须等待。函数Sleep() 将得到函数 IsStopped()的等待和检测值。即 ，如果你从图表“睡眠”状态中删除智能交易，将会强制执行。

对于更多的描述，让它显示需要等待时间的信息("睡眠"状态中每秒)。

以下是我们需要得到的结果：

extern int PauseBeforeTrade = 10; // 交易之间的停顿(以秒为单位)
 
/////////////////////////////////////////////////////////////////////////////////
// int _PauseBeforeTrade()
//
// 对于整体变量LastTradeTime函数设定地方时间值 .
// 如果此刻开启的地方时间值小于LastTradeTime + 
// PauseBeforeTrade 值,函数将进行等待。
// 如果根本没有整体变量LastTradeTime, 函数将进行创建.
// 返回代码:
//  1 - 成功编译
// -1 - 智能交易被用户打断(智能交易从图表中删除, 
//      终端关闭, 图表货币对或时间周期改变，等等。)
/////////////////////////////////////////////////////////////////////////////////
int _PauseBeforeTrade()
 {
  // 在测试执行期间没有停顿 - 只是终端函数
  if(IsTesting()) 
    return(1); 
  int _GetLastError = 0;
  int _LastTradeTime, RealPauseBeforeTrade;
 
  //+------------------------------------------------------------------+
  //| 检测整体变量是否存在。如果不存在，进行创建                               |
  //+------------------------------------------------------------------+
  while(true)
   {
    // 如果智能交易被用户打断，停止运行
    if(IsStopped()) 
     { 
      Print("智能交易被用户终止!"); 
      return(-1); 
     }
    // 检测整体变量是否存在
    // 如果存在，循环等待
    if(GlobalVariableCheck("LastTradeTime")) 
      break;
    else
     // 如果GlobalVariableCheck返回FALSE, 说明没有任何整体变量存在，
     // 或是在检测过程中出现了错误
     {
      _GetLastError = GetLastError();
      // 如果仍然存在错误，显示信息，等待0.1秒， 
      // 开始重新检测
      if(_GetLastError != 0)
       {
        Print("_PauseBeforeTrade()-GlobalVariableCheck(\"LastTradeTime\")-Error #",
              _GetLastError );
        Sleep(100);
        continue;
       }
     }
    // 如果没有错误生成,说明没有整体变量，尝试创建
    // 如果GlobalVariableSet > 0, 说明整体变量成功创建. 
    // 退出函数
    if(GlobalVariableSet("LastTradeTime", LocalTime() ) > 0) 
      return(1);
    else
     // 如果GlobalVariableSet 返回值<= 0, 说明在变量创建期间生成错误
     {
      _GetLastError = GetLastError();
      // 显示信息,等待0.1秒，重新开始尝试 
      if(_GetLastError != 0)
       {
        Print("_PauseBeforeTrade()-GlobalVariableSet(\"LastTradeTime\", ", 
              LocalTime(), ") - Error #", _GetLastError );
        Sleep(100);
        continue;
       }
     }
   }
  //+--------------------------------------------------------------------------------+
  //| 如果函数执行达到此点,所名整体变量存在                                                 |
  //|                                                                                |
  //| 等待LocalTime() 值> LastTradeTime + PauseBeforeTrade                            |
  //+--------------------------------------------------------------------------------+
  while(true)
   {
    // 如果智能交易被用户打断，停止运作
    if(IsStopped()) 
     { 
      Print("智能交易被用户终止!"); 
      return(-1); 
     }
    // 获取整体变量值 
    _LastTradeTime = GlobalVariableGet("LastTradeTime");
    // 如果此时生成错误，显示信息，等待0.1秒， 
    // 并且在此尝试
    _GetLastError = GetLastError();
    if(_GetLastError != 0)
     {
      Print("_PauseBeforeTrade()-GlobalVariableGet(\"LastTradeTime\")-Error #", 
            _GetLastError );
      continue;
     }
    // 以秒为单位计算自最后交易结束过去的时间
    RealPauseBeforeTrade = LocalTime() - _LastTradeTime;
    // 如果少于PauseBeforeTrade秒数的时间过去，
    if(RealPauseBeforeTrade < PauseBeforeTrade)
     {
      // 显示信息，等待一秒，重新检验
      Comment("Pause between trades. Remaining time: ", 
               PauseBeforeTrade - RealPauseBeforeTrade, " sec" );
      Sleep(1000);
      continue;
     }
    // 如果过去时间超过PauseBeforeTrade秒数，停止循环
    else
      break;
   }
  //+--------------------------------------------------------------------------------+
  //| 如果函数执行到达此点，说明整体变量存在并且地方时间超过LastTradeTime + PauseBeforeTrade   |
  //|                                                                                |
  //| 给整体变量LastTradeTime 设置地方时间值                                             |
  //+--------------------------------------------------------------------------------+
  while(true)
   {
    // 如果智能交易被用户打断，停止运作
    if(IsStopped()) 
     { 
      Print("智能交易被用户终止!"); 
      return(-1);
     }

    // 给整体变量LastTradeTime设置地方时间值。
    // 成功的情况下退出
    if(GlobalVariableSet( "LastTradeTime", LocalTime() ) > 0) 
     { 
      Comment(""); 
      return(1); 
     }
    else
    // 如果GlobalVariableSet 返回值<= 0, 说明错误生成
     {
      _GetLastError = GetLastError();
      // 显示信息，等待0.1 秒，并且重新开始尝试
      if(_GetLastError != 0)
       {
        Print("_PauseBeforeTrade()-GlobalVariableSet(\"LastTradeTime\", ", 
              LocalTime(), " ) - Error #", _GetLastError );
        Sleep(100);
        continue;
       }
     }
   }
 }

4. 结合智能交易的使用

检测函数，我们创建一个预测智能交易来保持交易之间的停顿。函数 _PauseBeforeTrade() 被放置在PauseBeforeTrade.mq4 的包含文件中，在智能交易直接使用 #include。

注意! 这个智能交易只能用作检测函数的可用性！不能使用在交易中！

#include <PauseBeforeTrade.mq4>
 
int ticket = 0;
int start()
 {
  // 如果这个智能交易没有开仓
  if(ticket <= 0)
   {
    // 保持交易之间停顿,如果有错误生成，退出
    if(_PauseBeforeTrade() < 0) 
      return(-1);
    // 刷新市场信息
    RefreshRates();
 
    // 尝试开仓
    ticket = OrderSend(Symbol(), OP_BUY, 0.1, Ask, 5, 0.0, 0.0, "PauseTest", 123, 0, 
                       Lime);
    if(ticket < 0)
      Alert("Error OrderSend № ", GetLastError());
   }
  // 如果这个智能交易有开仓
  else
   {
    // 保持交易之间的停顿(如果有错误生成，退出)
    if(_PauseBeforeTrade() < 0)
      return(-1);
    // 刷新市场信息
    RefreshRates();


 
    // 尝试平仓
    if (!OrderClose( ticket, 0.1, Bid, 5, Lime ))
      Alert("Error OrderClose № ", GetLastError());
    else
      ticket = 0;
   }
  return(0);
 }

随后，一个智能交易获取 EURUSD-M1图表，另一个智能交易获取完全相同的GBPUSD-M1图表。这个结果不会长时间保存: 两个智能交易在交易中保持10秒的停顿:

5. 可能出现的问题

当几个智能交易在一个整体变量上运行时，错误会生成。为了避免错误，我们必须限定变量通道。在文章"错误146 ("交易作业忙")和如何解决"中有一些“限定”的计算描述。这种计算对我们很有用。

智能交易的最终版本如下:

#include <PauseBeforeTrade.mq4>
#include <TradeContext.mq4>
 
int ticket = 0;
int start()
 {
  // 如果这个智能交易没有开仓
  if(ticket <= 0)
   {
    // 等待直至交易空闲并占据 (如果有错误生成, 
    // 退出)
    if(TradeIsBusy() < 0)
      return(-1);
    // 保持交易之间的停顿
    if(_PauseBeforeTrade() < 0)
     {
      // 如果错误生成,交易空闲并退出
 TradeIsNotBusy();
      return(-1);
     }
    // 刷新市场信息
    RefreshRates();
 
    // 尝试开仓
    ticket = OrderSend(Symbol(), OP_BUY, 0.1, Ask, 5, 0.0, 0.0, "PauseTest", 123, 0, 
                       Lime);
    if (ticket < 0)
      Alert("Error OrderSend № ", GetLastError());
    // 交易空闲
    TradeIsNotBusy();
   }
  // 如果这个智能交易有开仓
  else
   {
    // 等待直至交易空闲并占据(如果错误生成，, 
    // 退出)
    if(TradeIsBusy() < 0)
      return(-1);
    // 保持交易之间的停顿
    if(_PauseBeforeTrade() < 0)
     {
      // 如果错误生成，交易空闲并退出
      TradeIsNotBusy();
      return(-1);
     }
    //刷新市场信息
    RefreshRates();
 
    // 尝试平仓
    if(!OrderClose( ticket, 0.1, Bid, 5, Lime))
      Alert("Error OrderClose № ", GetLastError());
    else
      ticket = 0;
 
    // 交易空闲
    TradeIsNotBusy();
   }
  return(0);
 }

转自 MetaQuotes Software Corp.
原文: http://articles.mql4.com/ru/articles/1355