_C

容错重试函数，用于对接口调用进行容错处理。

    
    
    
_C(pfn)

    
    
    
_C(pfn, ...args)

示例

• 针对无参数函数的容错处理：

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main(){
      // 由于是测试代码，未采用商品期货策略的通用架构，此处仅通过exchange.IO("status")函数进行判断，在成功连接期货公司前置机后立即执行测试代码。股票证券无需使用exchange.IO("status")判断连接状态
      while(!exchange.IO("status")) {
          Sleep(1000)
      }
  
      // 测试代码部分
      // 将合约设置为rb888，即螺纹钢主力连续合约；或设置为股票代码
      exchange.SetContractType("rb888")
  
      var ticker = _C(exchange.GetTicker)
      // 将_C()函数的重试时间间隔调整为2秒
      _CDelay(2000)
      var depth = _C(exchange.GetDepth)
      Log(ticker)
      Log(depth)
  }
  

  
      python
      
      
  def main():
      while not exchange.IO("status"):
          Sleep(1000)
  
      exchange.SetContractType("rb888")
  
      ticker = _C(exchange.GetTicker)
      _CDelay(2000)
      depth = _C(exchange.GetDepth)
      Log(ticker)
      Log(depth)
  

  
      rust
      
      
  fn main() {
      // 由于是测试代码，未采用商品期货策略的通用架构，此处仅通过exchange.IO("status")函数进行判断，在成功连接期货公司前置机后立即执行测试代码。股票证券无需使用exchange.IO("status")判断连接状态
      while exchange.IO("status").unwrap_or_default() != "true" {
          Sleep(1000);
      }
  
      // 测试代码部分
      // 将合约设置为rb888，即螺纹钢主力连续合约；或设置为股票代码
      exchange.SetContractType("rb888").unwrap();
  
      let ticker = _C!(exchange.GetTicker(None));
      // 将_C!()宏的重试时间间隔调整为2秒
      _CDelay(2000);
      let depth = _C!(exchange.GetDepth(None));
      Log!(ticker);
      Log!(depth);
  }
  

  
      c++
      
      
  void main() {
      while(exchange.IO("status") == 0) {
          Sleep(1000);
      }
  
      exchange.SetContractType("rb888");
  
      auto ticker = _C(exchange.GetTicker);
      _CDelay(2000);
      auto depth = _C(exchange.GetDepth);
      Log(ticker);
      Log(depth);
  }
  

• 针对有参数函数的容错处理：

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  function main(){
      // 由于是测试代码，未采用商品期货策略的通用架构，此处仅通过exchange.IO("status")函数进行判断，在成功连接期货公司前置机后立即执行测试代码。股票证券无需使用exchange.IO("status")判断连接状态
      while(!exchange.IO("status")) {
          Sleep(1000)
      }
  
      // 测试代码部分
      // 将合约设置为rb888，即螺纹钢主力连续合约；或设置为股票代码
      exchange.SetContractType("rb888")
  
      var records = _C(exchange.GetRecords, PERIOD_D1)
      Log(records)
  }
  

  
      python
      
      
  def main():
      while not exchange.IO("status"):
          Sleep(1000)
  
      exchange.SetContractType("rb888")
  
      records = _C(exchange.GetRecords, PERIOD_D1)
      Log(records)
  

  
      rust
      
      
  fn main() {
      while exchange.IO("status").unwrap_or_default() != "true" {
          Sleep(1000);
      }
  
      exchange.SetContractType("rb888").unwrap();
  
      let records = _C!(exchange.GetRecords(None, PERIOD_D1, None));
      Log!(records);
  }
  

  
      c++
      
      
  void main() {
      while(exchange.IO("status") == 0) {
          Sleep(1000);
      }
  
      exchange.SetContractType("rb888");
  
      auto records = _C(exchange.GetRecords, PERIOD_D1);
      Log(records);
  }
  

• 也可用于自定义函数的容错处理：

  • javascript
  • python
  • rust
  • cpp

  
      javascript
      
      
  var test = function(a, b){
      var time = new Date().getTime() / 1000
      if(time % b == 3){
          Log("符合条件！", "#FF0000")
          return true
      }
      Log("重试！", "#FF0000")
      return false
  }
  
  function main(){
      // 此测试不通过接口获取数据，因此无需调用 exchange.IO("status") 函数判断连接状态，也无需设置合约代码，因为这里仅用于测试自定义函数
      var ret = _C(test, 1, 5)
      Log(ret)
  }
  

  
      python
      
      
  import time
  def test(a, b):
      ts = time.time()
      if ts % b == 3:
          Log("符合条件！", "#FF0000")
          return True
      Log("重试！", "#FF0000")
      return False
  
  def main():
      ret = _C(test, 1, 5)
      Log(ret)
  

  
      rust
      
      
  fn test(a: i64, b: i64) -> Result<bool> {
      let time = Unix();
      if time % b == 3 {
          Log!("符合条件！", "#FF0000");
          return Ok(true);
      }
      Log!("重试！", "#FF0000");
      Err(Error::Api("retry".to_string()))
  }
  
  fn main() {
      // 此测试不通过接口获取数据，因此无需调用 exchange.IO("status") 函数判断连接状态，也无需设置合约代码，因为这里仅用于测试自定义函数
      // 在 Rust 中，自定义函数返回 Result 类型即可使用 _C! 宏进行容错，返回 Err 时会自动重试
      let ret = _C!(test(1, 5));
      Log!(ret);
  }
  

  
      c++
      
      
  // C++ 不支持以这种方式对自定义函数进行容错处理

返回值

参数

备注

_C()函数会反复调用指定的函数，直到其成功返回为止（当参数pfn所引用的函数返回空值或假值时，_C()会重试调用pfn）。

例如_C(exchange.GetTicker)。默认的重试间隔为3秒，可以调用_CDelay()函数来设置重试间隔。

例如_CDelay(1000)，表示将_C()函数的重试间隔改为1秒。

可以对以下函数进行容错处理，但不限于此：

• exchange.GetTicker()

• exchange.GetDepth()

• exchange.GetTrades()

• exchange.GetRecords()

• exchange.GetAccount()

• exchange.GetOrders()

• exchange.GetOrder()

• exchange.GetPositions()

以上函数均可通过_C()函数调用来实现容错。_C()函数的容错能力并不局限于上述列出的函数。参数pfn为函数引用而非函数调用，请注意应写作_C(exchange.GetTicker)，而不是_C(exchange.GetTicker())。