MT5异步订单执行与智能重试机制实战

bool OrderSendAsync(
   MqlTradeRequest&  request,      // 交易请求结构体
   MqlTradeResult&   result        // 交易结果结构体
);

//+------------------------------------------------------------------+
//| 异步发送订单封装函数                                                |
//| 参数: request - 交易请求结构体                                     |
//| 返回: true=请求提交成功, false=提交失败                            |
//+------------------------------------------------------------------+
bool SendOrderAsync(const MqlTradeRequest &request)
{
   // --- 1. 参数校验 ---
   if(request.symbol == NULL || StringLen(request.symbol) == 0)
   {
      Print("[SendOrderAsync] 错误: 交易品种为空");
      return false;
   }

   // 检查品种是否存在
   if(SymbolSelect(request.symbol, false) == false)
   {
      Print("[SendOrderAsync] 错误: 品种不存在 - ", request.symbol);
      return false;
   }

   // 检查手数合法性
   double min_volume = SymbolInfoDouble(request.symbol, SYMBOL_VOLUME_MIN);
   double max_volume = SymbolInfoDouble(request.symbol, SYMBOL_VOLUME_MAX);
   double volume_step = SymbolInfoDouble(request.symbol, SYMBOL_VOLUME_STEP);

   if(request.volume < min_volume || request.volume > max_volume)
   {
      Print("[SendOrderAsync] 错误: 手数超出范围 - ", request.volume,
            " [", min_volume, ", ", max_volume, "]");
      return false;
   }

   // 手数必须是步长的整数倍
   double normalized_volume = MathFloor(request.volume / volume_step) * volume_step;
   if(MathAbs(normalized_volume - request.volume) > volume_step * 0.01)
   {
      Print("[SendOrderAsync] 警告: 手数不符合步长要求，已调整为 ", normalized_volume);
      // 注意：这里不能直接修改传入的const结构体，实际使用时需要调整传入参数
      // 此处仅做校验提示，建议调用前先做手数标准化
   }

   // --- 2. 调用OrderSendAsync ---
   MqlTradeResult result;
   bool submitted = OrderSendAsync(request, result);

   // --- 3. 返回值判断 ---
   if(submitted)
   {
      // 请求提交成功
      // result.retcode 通常为 10011(已接受) 或 10016(处理中)
      // result.ticket 可能为0，这是正常的，ticket会在后续回调中给出
      Print("[SendOrderAsync] 请求已提交, retcode=", result.retcode,
            ", ticket=", result.ticket,
            ", deal=", result.deal);

      // 记录提交时间，用于后续超时检测
      // （实际使用中可以存入一个全局的请求追踪表）
      return true;
   }
   else
   {
      // 请求提交失败 - 连本地队列都没进去
      // 通常是参数错误、品种不存在、交易被禁用等问题
      Print("[SendOrderAsync] 请求提交失败, retcode=", result.retcode,
            ", 描述: ", GetErrorDescription(result.retcode));
      return false;
   }
}

void OnTradeTransaction(
   const MqlTradeTransaction&  trade,       // 交易事务详情
   const MqlTradeRequest&      request,     // 原始请求结构体
   const MqlTradeResult&       retcode      // 返回码
);

//+------------------------------------------------------------------+
//| 订单结果回调处理器类                                               |
//| 职责：接管OnTradeTransaction回调，解析结果，维护状态映射表            |
//+------------------------------------------------------------------+
class CTradeResultHandler
{
private:
   // 订单状态追踪结构
   struct OrderTrackInfo
   {
      ulong      order_ticket;      // 订单ticket
      ulong      deal_ticket;       // 成交ticket
      string     symbol;            // 品种
      ENUM_ORDER_TYPE order_type;   // 订单类型
      double     volume;            // 手数
      double     price;             // 请求价格
      datetime   submit_time;       // 提交时间
      int        status;            // 0=Pending, 1=Filled, 2=Rejected, 3=Canceled, 4=Retrying
      int        retry_count;       // 已重试次数
      int        last_retcode;      // 最后一次返回码
      string     comment;           // 备注
   };

   CArrayObj         m_order_map;       // 订单追踪列表（可用CMap优化，这里简化用数组）
   CRetryManager     m_retry_mgr;       // 重试管理器引用（后续章节讲解）

public:
   // 构造函数
   CTradeResultHandler() { }
   ~CTradeResultHandler() { }

   // 添加一个待追踪的请求
   void AddPendingRequest(const MqlTradeRequest &request)
   {
      OrderTrackInfo *info = new OrderTrackInfo();
      info.order_ticket    = 0;
      info.deal_ticket     = 0;
      info.symbol          = request.symbol;
      info.order_type      = (ENUM_ORDER_TYPE)request.type;
      info.volume          = request.volume;
      info.price           = request.price;
      info.submit_time     = TimeCurrent();
      info.status          = 0; // Pending
      info.retry_count     = 0;
      info.last_retcode    = 0;
      info.comment         = request.comment;
      m_order_map.Add(info);
   }

   // 处理交易回调
   void OnTradeTransaction(const MqlTradeTransaction &trade,
                           const MqlTradeRequest &request,
                           const MqlTradeResult &result)
   {
      // 只处理请求结果类型的事务
      if(trade.type != TRADE_TRANSACTION_REQUEST)
         return;

      // 根据请求信息查找对应的追踪记录
      // 实际项目中可以用专属请求ID来匹配，这里用symbol+type+时间近似匹配
      OrderTrackInfo *info = FindTrackInfo(trade.symbol, trade.order);

      if(info == NULL)
      {
         // 找不到对应的追踪记录，可能是其他模块或手动操作的订单
         // 记录日志即可，不要报错
         Print("[CTradeResultHandler] 收到未追踪的订单回调, ticket=", trade.order,
               ", retcode=", result.retcode);
         return;
      }

      // 根据返回码更新状态
      int retcode = result.retcode;
      info.last_retcode = retcode;

      if(retcode >= 10000 && retcode <= 10009)
      {
         // 成功类返回码
         if(trade.order > 0)
            info.order_ticket = trade.order;
         if(trade.deal > 0)
            info.deal_ticket = trade.deal;

         if(retcode == TRADE_RETCODE_DONE || retcode == TRADE_RETCODE_PLACED)
         {
            // 成交成功或挂单成功
            info.status = 1; // Filled/Placed
            OnOrderFilled(info);
         }
         else
         {
            // 其他成功类状态，保持pending继续等待
            Print("[CTradeResultHandler] 中间状态, retcode=", retcode, ", ticket=", trade.order);
         }
      }
      else if(retcode >= 10010 && retcode <= 10039)
      {
         // 错误类返回码
         info.order_ticket = trade.order;
         
         // 判断是否可重试
         if(m_retry_mgr.IsRetriable(retcode) && info.retry_count < m_retry_mgr.GetMaxRetries())
         {
            // 可以重试
            info.status = 4; // Retrying
            info.retry_count++;
            m_retry_mgr.ScheduleRetry(info.order_ticket, info.retry_count);
            Print("[CTradeResultHandler] 订单可重试, retcode=", retcode,
                  ", 第", info.retry_count, "次重试");
         }
         else
         {
            // 不可重试或已达最大重试次数
            info.status = 2; // Rejected
            OnOrderRejected(info, retcode);
         }
      }
   }

private:
   // 查找追踪记录（简化实现，实际项目中建议用哈希表）
   OrderTrackInfo* FindTrackInfo(string symbol, ulong ticket)
   {
      for(int i = 0; i < m_order_map.Total(); i++)
      {
         OrderTrackInfo *info = (OrderTrackInfo*)m_order_map.At(i);
         if(ticket > 0 && info.order_ticket == ticket)
            return info;
         if(info.symbol == symbol && info.status == 0)
            return info;
      }
      return NULL;
   }

   // 订单成交回调 - 可在此处触发后续业务逻辑
   void OnOrderFilled(OrderTrackInfo *info)
   {
      Print("[CTradeResultHandler] 订单成交: ", info.symbol,
            " ticket=", info.order_ticket,
            " deal=", info.deal_ticket);
      // 触发仓位更新、信号通知等后续逻辑...
   }

   // 订单拒绝回调 - 记录日志，触发告警
   void OnOrderRejected(OrderTrackInfo *info, int retcode)
   {
      Print("[CTradeResultHandler] 订单被拒绝: ", info.symbol,
            " retcode=", retcode,
            " 描述=", GetErrorDescription(retcode));
      // 触发告警逻辑...
   }
};

//+------------------------------------------------------------------+
//| 智能重试管理器类                                                   |
//| 职责：错误分类、指数退避计算、重试调度队列管理                       |
//+------------------------------------------------------------------+
class CRetryManager
{
private:
   int           m_max_retries;      // 最大重试次数
   int           m_base_delay_ms;    // 退避基数（毫秒）
   double        m_jitter_ratio;     // 抖动比例（0~1）

   // 重试任务结构
   struct RetryTask
   {
      ulong      order_ticket;       // 关联的订单ticket
      int        retry_count;        // 第几次重试
      datetime   retry_time_ms;      // 计划重试时间（毫秒时间戳）
      bool       is_active;          // 是否有效
   };

   CArrayObj     m_retry_queue;      // 重试队列

public:
   // 构造函数 - 可配置参数
   CRetryManager(int max_retries = 3, int base_delay_ms = 100, double jitter_ratio = 0.25)
   {
      m_max_retries    = max_retries;
      m_base_delay_ms  = base_delay_ms;
      m_jitter_ratio   = jitter_ratio;
   }

   ~CRetryManager() { }

   // 获取最大重试次数
   int GetMaxRetries() const { return m_max_retries; }

   // 设置参数
   void SetParams(int max_retries, int base_delay_ms, double jitter_ratio)
   {
      m_max_retries    = max_retries;
      m_base_delay_ms  = base_delay_ms;
      m_jitter_ratio   = jitter_ratio;
   }

   // 判断错误码是否可重试
   bool IsRetriable(int retcode)
   {
      switch(retcode)
      {
         // --- 可重试错误 ---
         case 10004:  // ERR_REQUOTE 重报价
         case 10006:  // ERR_NO_CONNECTION 无连接
         case 10013:  // ERR_INVALID_PRICE 无效价格
         case 10015:  // ERR_INVALID_STOPS 无效止损止盈
         case 10020:  // ERR_PRICE_CHANGED 价格已变
         case 10029:  // ERR_TOO_MANY_REQUESTS 请求过于频繁
         case 10033:  // ERR_TRADE_TIMEOUT 交易超时
            return true;

         // --- 不可重试错误 ---
         case 10001:  // ERR_INVALID_PARAMETER 无效参数
         case 10003:  // ERR_INVALID_TICKET 无效ticket
         case 10014:  // ERR_INVALID_VOLUME 无效手数
         case 10019:  // ERR_NOT_ENOUGH_MONEY 余额不足
         case 10023:  // ERR_TRADE_DISABLED 交易禁用
         case 10027:  // ERR_LONG_ONLY 仅允许做多
         case 10031:  // ERR_NO_MQL5_TRADING EA交易未开启
         case 10025:  // ERR_TRADE_EXPERT_DISABLED_BY_SERVER 服务器禁用EA
         case 10030:  // ERR_INVALID_ORDER_TYPE 无效订单类型
            return false;

         // --- 其他错误默认不可重试，避免风险 ---
         default:
            Print("[CRetryManager] 未知错误码: ", retcode, "，默认不重试");
            return false;
      }
   }

   // 计算指数退避延迟（含抖动）
   int CalculateDelay(int retry_attempt)
   {
      // 指数退避: base * 2^attempt
      double base_delay = m_base_delay_ms * MathPow(2, retry_attempt);

      // 添加抖动: ±jitter_ratio范围内随机偏移
      int jitter = (int)(base_delay * m_jitter_ratio * (MathRand() / 32767.0 * 2 - 1));

      int delay = (int)(base_delay + jitter);

      // 设置最小延迟为50ms，避免太快
      if(delay < 50) delay = 50;

      return delay;
   }

   // 调度一次重试
   void ScheduleRetry(ulong order_ticket, int retry_count)
   {
      RetryTask *task = new RetryTask();
      task.order_ticket = order_ticket;
      task.retry_count  = retry_count;
      task.is_active    = true;

      // 计算延迟并设置重试时间
      int delay_ms = CalculateDelay(retry_count - 1);
      task.retry_time_ms = GetTickCount64() + delay_ms;

      m_retry_queue.Add(task);

      Print("[CRetryManager] 已调度重试: ticket=", order_ticket,
            ", 第", retry_count, "次, 延迟=", delay_ms, "ms");
   }

   // 检查并执行到期的重试任务（在OnTimer中周期性调用）
   void CheckAndExecute()
   {
      ulong now = GetTickCount64();

      for(int i = m_retry_queue.Total() - 1; i >= 0; i--)
      {
         RetryTask *task = (RetryTask*)m_retry_queue.At(i);

         if(!task.is_active)
         {
            m_retry_queue.Delete(i);
            continue;
         }

         if(now >= task.retry_time_ms)
         {
            // 到期了，执行重试
            ExecuteRetry(task);
            task.is_active = false;
            m_retry_queue.Delete(i);
         }
      }
   }

private:
   // 执行重试 - 这里调用外部引擎的SendOrder方法
   void ExecuteRetry(RetryTask *task)
   {
      Print("[CRetryManager] 执行重试: ticket=", task.order_ticket,
            ", 第", task.retry_count, "次");
      // 注意：实际实现中需要：
      // 1. 检查当前仓位，确认之前的订单确实没有成交
      // 2. 刷新最新价格
      // 3. 重新构造MqlTradeRequest并调用OrderSendAsync
      // 这里只给出框架，具体实现放在订单引擎类中
   }
};

//+------------------------------------------------------------------+
//| CAsyncOrderEngine 异步订单引擎类（完整版）                         |
//| 整合：异步发送 + 回调处理 + 智能重试 + 超时检测 + 速率控制          |
//+------------------------------------------------------------------+
class CAsyncOrderEngine
{
private:
   // === 内部子模块 ===
   CTradeResultHandler  m_result_handler;    // 结果回调处理器
   CRetryManager        m_retry_mgr;         // 重试管理器
   CRequestQueue        m_request_queue;     // 请求队列（含流控）
   CTimeoutChecker      m_timeout_checker;   // 超时检测器

   // === 配置参数 ===
   int     m_timeout_seconds;     // 订单超时时间（秒）
   int     m_max_retries;         // 最大重试次数
   int     m_rate_limit_per_sec;  // 每秒最大请求数
   int     m_timer_id;            // 定时器ID

public:
   // 构造函数
   CAsyncOrderEngine()
   {
      m_timeout_seconds    = 10;   // 默认10秒超时
      m_max_retries        = 3;    // 默认最多重试3次
      m_rate_limit_per_sec = 5;    // 默认每秒最多5个请求
      m_timer_id           = 0;
   }

   // 析构函数
   ~CAsyncOrderEngine()
   {
      if(m_timer_id > 0)
         EventKillTimer(m_timer_id);
   }

   // 初始化引擎 - 设置参数并启动定时器
   bool Init(int timeout_seconds = 10,
             int max_retries = 3,
             int rate_limit_per_sec = 5,
             int timer_interval_ms = 500)
   {
      m_timeout_seconds    = timeout_seconds;
      m_max_retries        = max_retries;
      m_rate_limit_per_sec = rate_limit_per_sec;

      // 初始化子模块
      m_retry_mgr.SetParams(max_retries, 100, 0.25);
      m_request_queue.SetRateLimit(rate_limit_per_sec);
      m_timeout_checker.SetTimeout(timeout_seconds);

      // 启动定时器 - 用于周期性检查重试队列、超时订单、发送队列
      m_timer_id = EventSetTimer(timer_interval_ms);
      if(m_timer_id == 0)
      {
         Print("[CAsyncOrderEngine] 定时器创建失败");
         return false;
      }

      Print("[CAsyncOrderEngine] 初始化完成: 超时=", timeout_seconds, "s, ",
            "最大重试=", max_retries, "次, ",
            "速率限制=", rate_limit_per_sec, "/s");
      return true;
   }

   // --- 核心对外接口 ---

   // 发送订单（通用接口）
   bool SendOrder(const MqlTradeRequest &request)
   {
      // 1. 参数校验
      if(!ValidateRequest(request))
      {
         Print("[CAsyncOrderEngine] 参数校验失败");
         return false;
      }

      // 2. 加入请求队列（由队列控制发送速率）
      m_request_queue.Enqueue(request);

      return true;
   }

   // 市价买入
   bool Buy(string symbol, double volume, double sl = 0, double tp = 0,
            int deviation = 10, string comment = "")
   {
      MqlTradeRequest request = {0};
      request.action          = TRADE_ACTION_DEAL;
      request.symbol          = symbol;
      request.type            = ORDER_TYPE_BUY;
      request.volume          = volume;
      request.sl              = sl;
      request.tp              = tp;
      request.deviation       = deviation;
      request.comment         = comment;
      request.type_filling    = ORDER_FILLING_FOK;
      request.type_time       = ORDER_TIME_GTC;
      return SendOrder(request);
   }

   // 市价卖出
   bool Sell(string symbol, double volume, double sl = 0, double tp = 0,
             int deviation = 10, string comment = "")
   {
      MqlTradeRequest request = {0};
      request.action          = TRADE_ACTION_DEAL;
      request.symbol          = symbol;
      request.type            = ORDER_TYPE_SELL;
      request.volume          = volume;
      request.sl              = sl;
      request.tp              = tp;
      request.deviation       = deviation;
      request.comment         = comment;
      request.type_filling    = ORDER_FILLING_FOK;
      request.type_time       = ORDER_TIME_GTC;
      return SendOrder(request);
   }

   // 平仓（指定ticket）
   bool ClosePosition(ulong position_ticket, int deviation = 10)
   {
      // 获取仓位信息
      if(!PositionGetTicket(position_ticket))
      {
         Print("[CAsyncOrderEngine] 仓位不存在: ", position_ticket);
         return false;
      }

      string symbol = PositionGetString(POSITION_SYMBOL);
      double volume = PositionGetDouble(POSITION_VOLUME);
      ENUM_POSITION_TYPE pos_type = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);

      MqlTradeRequest request = {0};
      request.action          = TRADE_ACTION_DEAL;
      request.symbol          = symbol;
      request.volume          = volume;
      request.deviation       = deviation;
      request.position        = position_ticket;
      request.type_filling    = ORDER_FILLING_FOK;
      request.type_time       = ORDER_TIME_GTC;

      // 平仓方向与仓位方向相反
      request.type = (pos_type == POSITION_TYPE_BUY) ? ORDER_TYPE_SELL : ORDER_TYPE_BUY;

      return SendOrder(request);
   }

   // 修改止损止盈
   bool ModifyStopLossTakeProfit(ulong position_ticket, double new_sl, double new_tp)
   {
      if(!PositionGetTicket(position_ticket))
      {
         Print("[CAsyncOrderEngine] 仓位不存在: ", position_ticket);
         return false;
      }

      MqlTradeRequest request = {0};
      request.action          = TRADE_ACTION_MODIFY;
      request.symbol          = PositionGetString(POSITION_SYMBOL);
      request.sl              = new_sl;
      request.tp              = new_tp;
      request.position        = position_ticket;

      return SendOrder(request);
   }

   // 取消挂单
   bool CancelPendingOrder(ulong order_ticket)
   {
      MqlTradeRequest request = {0};
      request.action          = TRADE_ACTION_REMOVE;
      request.order           = order_ticket;

      // 取消订单也通过队列发送，避免集中操作
      return SendOrder(request);
   }

   // --- 周期性更新（需要在OnTimer中调用）---
   void OnTimerUpdate()
   {
      // 1. 处理请求队列中的待发送请求（速率控制）
      m_request_queue.ProcessQueue();

      // 2. 检查重试队列
      m_retry_mgr.CheckAndExecute();

      // 3. 检查超时订单
      m_timeout_checker.CheckTimeouts(&m_result_handler);
   }

   // --- 交易回调处理（需要在OnTradeTransaction中调用）---
   void OnTradeTransactionHandler(const MqlTradeTransaction &trade,
                                  const MqlTradeRequest &request,
                                  const MqlTradeResult &result)
   {
      m_result_handler.OnTradeTransaction(trade, request, result);
   }

   // --- 状态查询 ---
   int GetPendingOrderCount() { return m_result_handler.GetPendingCount(); }
   int GetTotalOrderCount()   { return m_result_handler.GetTotalCount(); }

private:
   // 参数校验
   bool ValidateRequest(const MqlTradeRequest &request)
   {
      // 检查品种
      if(StringLen(request.symbol) == 0)
         return false;
      if(!SymbolSelect(request.symbol, false))
         return false;

      // 检查手数（仅对开仓/平仓类请求）
      if(request.action == TRADE_ACTION_DEAL || request.action == TRADE_ACTION_PENDING)
      {
         double min_vol = SymbolInfoDouble(request.symbol, SYMBOL_VOLUME_MIN);
         double max_vol = SymbolInfoDouble(request.symbol, SYMBOL_VOLUME_MAX);
         if(request.volume < min_vol || request.volume > max_vol)
            return false;
      }

      return true;
   }
};