/// <summary> /// 停止平仓追单对齐。 /// </summary> public void StopCloseChaseOrder() { if (m_backgroundWorkerType != AutoTraderWorkType.CloseChaseOrder || m_backgroundRunFlag == false) { string text = "当前未进行平仓追单"; AutoTraderNotice notice = CreateTraderNotice(text); SafeFireAutoTraderNotice(notice); WriteTraderNoticeLog(notice); return; } { string text = "停止平仓追单"; AutoTraderNotice notice = CreateTraderNotice(text); SafeFireAutoTraderNotice(notice); WriteTraderNoticeLog(notice); } lock (m_syncObj) { if (m_backgroundWorkerType == AutoTraderWorkType.CloseChaseOrder) { m_backgroundRunFlag = false; } } m_operatorEvent.Reset(); }
/// <summary> /// 委托回报变更。 /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void OrderDriver_OnOrderBookChanged(object sender, USeOrderBookChangedEventArgs e) { try { OrderBookUpdateResult result = null; lock (m_syncObj) { result = m_arbitrageOrder.UpdateOrderBook(e.OrderBook); if (result != null) { result.Task.UpdateTaskState(); m_arbitrageOrder.UpdataArbitrageOrderState(); m_operatorEvent.Set(); } } if (result != null) { //委托更新触发流程监控运行 m_operatorEvent.Set(); SafeFireArbitrageOrderChanged(); AutoTraderNotice tradeNotice = result.CreateNotice(this.TraderIdentify, this.Alias); if (tradeNotice != null) { SafeFireAutoTraderNotice(tradeNotice); } } } catch (Exception ex) { Debug.Assert(false, ex.Message); } }
/// <summary> /// 强制平仓完成。 /// </summary> public void ForceCloseFinish() { CheckBackgroundWorker("强制平仓完成"); lock (m_syncObj) { if (m_arbitrageOrder.HasUnFinishOrderBook) { throw new Exception(string.Format("{0}有未完成委托单", this)); } if (m_arbitrageOrder.State != ArbitrageOrderState.Closeing) { throw new Exception(string.Format("{0}为{1}状态,不能强制设定为平仓完成", this, this.ArbitrageOrderState.ToDescription())); } m_arbitrageOrder.State = ArbitrageOrderState.Closed; } SafeFireArbitrageOrderChanged(); { string text = "强制平仓完成"; AutoTraderNotice notice = CreateTraderNotice(text); SafeFireAutoTraderNotice(notice); WriteTraderNoticeLog(notice); } }
/// <summary> /// 停止开仓对齐。 /// </summary> public void StopOpenAlignment() { if (m_backgroundWorkerType != AutoTraderWorkType.OpenAlignment || m_backgroundRunFlag == false) { string text = "当前未进行开仓对齐操作"; AutoTraderNotice notice = CreateTraderNotice(text); SafeFireAutoTraderNotice(notice); WriteTraderNoticeLog(notice); return; } { string text = "停止开仓对齐"; AutoTraderNotice notice = CreateTraderNotice(text); SafeFireAutoTraderNotice(notice); WriteTraderNoticeLog(notice); } lock (m_syncObj) { if (m_backgroundWorkerType == AutoTraderWorkType.OpenAlignment) { m_backgroundRunFlag = false; } } m_operatorEvent.Reset(); }
/// <summary> /// 记录通知日志。 /// </summary> /// <param name="notice"></param> public void WriteTraderNoticeLog(AutoTraderNotice notice) { string text = string.Format("[Notice][Alias:{1}][NoticeType:{2}][Message:{3}][TradeIdentity:{0}]", notice.TradeIdentity, notice.Alias, notice.NoticeType, notice.Message); m_recordLogger.WriteInformation(text); }
/// <summary> /// 开始平仓。 /// </summary> public void BeginClose() { lock (m_syncObj) { Debug.Assert(m_arbitrageOrder.Argument != null); Debug.Assert(m_arbitrageOrder.Argument.CloseArg != null); //Debug.Assert(m_arbitrageOrder.Argument.StopLossArg != null); if (m_arbitrageOrder.State != ArbitrageOrderState.Opened) { throw new Exception(string.Format("{0}为{1}状态,不能进入平仓状态", this, m_arbitrageOrder.State.ToDescription())); } string errorMessage = string.Empty; if (VerfiyArbitrageArgument(m_arbitrageOrder.Argument, out errorMessage) == false) { throw new Exception(string.Format("{0}平仓参数错误,{1}", this, errorMessage)); } //创建平仓任务组 ArbitrageTaskGroup closeTaskGroup = CreateCloseTaskGroup(m_arbitrageOrder.OpenTaskGroup, m_arbitrageOrder.Argument); m_arbitrageOrder.CloseTaskGroup = closeTaskGroup; m_arbitrageOrder.State = ArbitrageOrderState.Closeing; } m_operatorEvent.Set(); SafeFireArbitrageOrderChanged(); string text = "进入平仓流程"; AutoTraderNotice notice = CreateTraderNotice(text); SafeFireAutoTraderNotice(notice); WriteTraderNoticeLog(notice); }
/// <summary> /// 转移为历史记录(不在更改)。 /// </summary> public void TransferToHistoryArbitrage() { lock (m_syncObj) { if (m_arbitrageOrder.State != ArbitrageOrderState.Closed) { throw new Exception(string.Format("{0}为{1}状态,未结束不能转移", this, this.ArbitrageOrderState.ToDescription())); } } ArbitrageOrderSettlement settlemetResult = CalculateSettlementResult(); lock (m_syncObj) { m_arbitrageOrder.State = ArbitrageOrderState.Finish; m_arbitrageOrder.FinishTime = DateTime.Now; m_arbitrageOrder.SettlementResult = settlemetResult; } SafeFireArbitrageOrderChanged(); string text = "交易结束,转移到历史记录"; AutoTraderNotice notice = CreateTraderNotice(text); SafeFireAutoTraderNotice(notice); WriteTraderNoticeLog(notice); }
private BackgroundWorker m_worker = null; //工作线程 #endregion #region 开平仓 /// <summary> /// 开仓/平仓监控下单。 /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void WorkerDoWorkForOpenAndClose(object sender, DoWorkEventArgs e) { string text = string.Format("启动跟单流程,当前状态为{0}", this.ArbitrageOrderState.ToDescription()); AutoTraderNotice notice = CreateTraderNotice(text); SafeFireAutoTraderNotice(notice); WriteTraderNoticeLog(notice); SafeFireAutoTraderStateChanged(AutoTraderWorkType.OpenOrClose, AutoTraderState.Enable); lock (m_syncObj) { m_arbitrageOrder.ResetTryOrderErrorCount(); } while (true) { ArbitrageOrderState arbitrageOrderState = ArbitrageOrderState.None; lock (m_syncObj) { if (m_backgroundRunFlag == false) { break; // 退出跟单 } arbitrageOrderState = m_arbitrageOrder.State; } switch (arbitrageOrderState) { case ArbitrageOrderState.Opening: //建仓中 ProcessArbitrageOrderOpenTask(); break; case ArbitrageOrderState.Closeing: ProcessArbitrageOrderCloseTask(); //平仓中 break; case ArbitrageOrderState.None: //无下一步指示,等待 m_operatorEvent.WaitOne(EVENT_WAIT_Time); break; case ArbitrageOrderState.Opened: BeginClose(); return; case ArbitrageOrderState.Closed: //已结束,流程退出 return; default: Debug.Assert(false, "未知类型的套利单状态"); return; } } }
private void AutoTraderManager_OnAutoTraderNotify(AutoTraderNotice notice) { if (this.InvokeRequired) { this.BeginInvoke(new AutoTraderNotifyEventHandle(AutoTraderManager_OnAutoTraderNotify), notice); return; } string text = string.Format("套利单<{0}>{1}", notice.Alias, notice.Message); this.lblAutoTradeInfo.Text = text; }
/// <summary> /// 安全触发报告事件。 /// </summary> /// <param name="notice">通知。</param> private void SafeFireAutoTraderNotice(AutoTraderNotice notice) { AutoTraderNotifyEventHandle handle = this.OnAutoTraderNotify; if (handle != null) { try { handle(notice); } catch (Exception ex) { Debug.Assert(false, ex.Message); } } }
private void AutoTraderManager_OnNotify(AutoTraderNotice notice) { if (this.InvokeRequired) { this.BeginInvoke(new AutoTraderNotifyEventHandle(AutoTraderManager_OnNotify), notice); return; } ArbitrageLogViewModel log = new ArbitrageLogViewModel() { TraderIdentify = notice.TradeIdentity, Alias = notice.Alias, LogTime = notice.NoticeTime, Message = notice.Message, NoticeType = notice.NoticeType }; m_dataSource.Insert(0, log); }
/// <summary> /// 移除自动下单机。 /// </summary> /// <param name="traderIdentify">自动下单机标识。</param> public void RemoveAutoTrader(Guid traderIdentify) { AutoTrader trader = null; lock (m_syncObj) { if (m_autoTraderDic.TryGetValue(traderIdentify, out trader) == false) { Debug.Assert(false); return; } } if (trader.State == AutoTraderState.Enable) { throw new Exception(string.Format("套利单[{0}]为运行状态,请先停止在移除", trader.Alias)); } if (trader.IsFinish == false) { throw new Exception(string.Format("套利单[{0}]当前状态为 {1} ,不能移除", trader, trader.ArbitrageOrderState.ToDescription())); } if (trader.HasUnFinishOrderBook) { throw new Exception(string.Format("套利单[{0}]有未完成委托单 ,不能移除", trader)); } trader.OnNotify -= AutoTrader_OnNotify; trader.OnAlarm -= AutoTrader_OnAlarm; trader.OnArbitrageOrderChanged -= AutoTrader_OnArbitrageOrderChanged; lock (m_syncObj) { m_autoTraderDic.Remove(traderIdentify); } string text = "移除套利单成功"; AutoTraderNotice notice = new AutoTraderNotice(trader.TraderIdentify, trader.Alias, AutoTraderNoticeType.Infomation, text); SafeFireAutoTraderNotice(notice); trader.WriteTraderNoticeLog(notice); SafeFireRemoveAutoTrader(traderIdentify); }
/// <summary> /// 检查后台流程是否在运行。 /// </summary> /// <returns></returns> private bool CheckBackgroundWorker(string action) { if (m_initialized == false) { throw new ApplicationException(string.Format("{0}未初始化", this)); } if (this.BackgroundWorkerIsBusy) { string text = string.Format("{0}正在进行{1}操作,请先停止后台流程在进行{2}操作", this, this.BackgroundWorkerType.ToDescription(), action); AutoTraderNotice notice = CreateTraderNotice(text); SafeFireAutoTraderNotice(notice); WriteTraderNoticeLog(notice); throw new ApplicationException(text); } return(true); }
/// <summary> /// 撤销挂单。 /// </summary> public void CancelOpenHangingOrder() { CheckBackgroundWorker("未成交撤单"); if (m_arbitrageOrder.HasUnFinishOrderBook == false) { AutoTraderNotice notice = CreateTraderNotice(AutoTraderNoticeType.Order, "没有未完成委托单,无需撤单"); SafeFireAutoTraderNotice(notice); return; } else { string text = "正在进行撤单操作"; AutoTraderNotice notice = CreateTraderNotice(text); SafeFireAutoTraderNotice(notice); WriteTraderNoticeLog(notice); } //未完成单先撤单 foreach (ArbitrageTask task in m_arbitrageOrder.OpenTaskGroup.TaskList) { if (task.HasUnFinishOrderBook) { List <USeOrderBook> unFinishOrderBooks = task.UnFinishOrderBooks; foreach (USeOrderBook orderBook in unFinishOrderBooks) { string message = string.Empty; bool cancelResult = m_orderDriver.CancelOrder(orderBook.OrderNum, orderBook.Instrument, out message); if (cancelResult == false) { AutoTraderNotice errorNotice = CreateTraderNotice(AutoTraderNoticeType.Order, "撤单失败"); SafeFireAutoTraderNotice(errorNotice); } } } } { AutoTraderNotice notice = CreateTraderNotice("撤单完成,等待撤单结果"); SafeFireAutoTraderNotice(notice); WriteTraderNoticeLog(notice); } }
/// <summary> /// 创建新的套利订单。 /// </summary> /// <param name="argument">套利单参数。</param> /// <param name="currentInvestor">当前投资者帐号。</param> public AutoTrader CreateNewAutoTrader(ArbitrageArgument argument, InvestorAccount currentInvestor) { Guid traderIdentify = CreateNewAutoTraderIdentify(); int aliasNum = CreateNewAutoTraderAliasNum(); USeArbitrageOrder arbitrageOrder = new USeArbitrageOrder(); arbitrageOrder.TraderIdentify = traderIdentify; arbitrageOrder.AliasNum = aliasNum; arbitrageOrder.State = ArbitrageOrderState.None; arbitrageOrder.BrokerId = currentInvestor.BrokerId; arbitrageOrder.Account = currentInvestor.Account; arbitrageOrder.Argument = argument.Clone(); arbitrageOrder.CreateTime = DateTime.Now; TaskOrderSetting taskOrderSetting = m_systemConfigManager.GetTaskOrderSetting(); //任务组待开仓或者平仓时在创建 AutoTrader trader = new AutoTrader(); trader.SetRecordLogger(USeManager.Instance.CommandLogger); trader.SetTryOrderCondition(taskOrderSetting.TaskMaxTryCount, taskOrderSetting.TryOrderMinInterval); trader.Initialize(arbitrageOrder, m_orderDriver, m_quoteDriver, m_alarmManager); trader.OnNotify += AutoTrader_OnNotify; trader.OnAlarm += AutoTrader_OnAlarm; trader.OnArbitrageOrderChanged += AutoTrader_OnArbitrageOrderChanged; trader.OnStateChanged += AutoTrader_OnStateChanged; lock (m_syncObj) { m_autoTraderDic.Add(traderIdentify, trader); } SafeFireAddAutoTrader(traderIdentify); string text = "创建套利单成功"; AutoTraderNotice notice = new AutoTraderNotice(trader.TraderIdentify, trader.Alias, AutoTraderNoticeType.Infomation, text); SafeFireAutoTraderNotice(notice); trader.WriteTraderNoticeLog(notice); return(trader); }
public AutoTraderNotice CreateNotice(Guid traderIdentify, string alias) { AutoTraderNotice notice = null; if (this.CancelQty > 0) { string text = string.Format("{0} {1}撤单{2}手", this.TaskDesc, this.Instrument, this.CancelQty); notice = new AutoTraderNotice(traderIdentify, alias, AutoTraderNoticeType.Trade, text); } else if (this.BlankQty > 0) { string text = string.Format("{0} {1}废单{2}手", this.TaskDesc, this.Instrument, this.BlankQty); notice = new AutoTraderNotice(traderIdentify, alias, AutoTraderNoticeType.Trade, text); } else if (this.TradeQty > 0) { string text = string.Format("{0} {1}成交{2}手", this.TaskDesc, this.Instrument, this.TradeQty); notice = new AutoTraderNotice(traderIdentify, alias, AutoTraderNoticeType.Trade, text); } return(notice); }
/// <summary> /// 开平仓流程结束。 /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void WorkerForOpenAndCloseCompleted(object sender, RunWorkerCompletedEventArgs e) { if (m_worker != null) { m_worker.ProgressChanged -= WorkerForOpenAndCloseProgressChanged; m_worker.RunWorkerCompleted -= WorkerForOpenAndCloseCompleted; m_worker.DoWork -= WorkerDoWorkForOpenAndClose; m_worker = null; } //流程结束,置位运行标识 m_backgroundRunFlag = false; m_backgroundWorkerType = AutoTraderWorkType.None; string text = "下单机已停止"; AutoTraderNotice notice = CreateTraderNotice(text); SafeFireAutoTraderNotice(notice); WriteTraderNoticeLog(notice); SafeFireAutoTraderStateChanged(AutoTraderWorkType.None, AutoTraderState.Disable); }
/// <summary> /// 设定流程进入开仓流程。 /// </summary> public void BeginOpen() { lock (m_syncObj) { if (m_arbitrageOrder.OpenArgument == null) { throw new Exception(string.Format("{0}开仓参数未设定", this)); } if (m_arbitrageOrder.State != ArbitrageOrderState.None) { throw new Exception(string.Format("{0}为{1}状态,不能进入开仓状态", this, m_arbitrageOrder.State.ToDescription())); } string errorMessage = string.Empty; if (VerfiyOpenArgument(m_arbitrageOrder.OpenArgument, out errorMessage) == false) { throw new Exception(string.Format("{0}开仓参数错误,{1}", this, errorMessage)); } //创建开仓任务组 ArbitrageTaskGroup openTaskGroup = CreateOpenTaskGroup(m_arbitrageOrder.Argument); m_arbitrageOrder.OpenTaskGroup = openTaskGroup; m_arbitrageOrder.State = ArbitrageOrderState.Opening; } m_operatorEvent.Set(); SafeFireArbitrageOrderChanged(); string text = "进入开仓流程"; AutoTraderNotice notice = CreateTraderNotice(text); SafeFireAutoTraderNotice(notice); WriteTraderNoticeLog(notice); }
/// <summary> /// 平仓追单。 /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void WorkerDoWorkForCloseChaseOrder(object sender, DoWorkEventArgs e) { { AutoTraderNotice notice = CreateTraderNotice("平仓追单对齐操作"); SafeFireAutoTraderNotice(notice); WriteTraderNoticeLog(notice); } //开仓追单 //1.撤销掉当前所有未成交委托单 //2.检查不对齐欠缺仓位,对欠缺仓位进行开仓追单 //3.开仓以市价委托,尽量保证成交 Debug.Assert(m_arbitrageOrder.State == ArbitrageOrderState.Closeing); if (m_arbitrageOrder.HasUnFinishOrderBook) { string text = "平仓追单有未完成委托单正在撤单"; AutoTraderNotice notice = CreateTraderNotice(AutoTraderNoticeType.Order, text); SafeFireAutoTraderNotice(notice); WriteTraderNoticeLog(notice); List <USeOrderBook> unFinishOrderBook = m_arbitrageOrder.GetAllUnfinishOrderBooks(); foreach (USeOrderBook orderBook in unFinishOrderBook) { string errorMessage = string.Empty; bool cancelResult = m_orderDriver.CancelOrder(orderBook.OrderNum, orderBook.Instrument, out errorMessage); if (cancelResult == false) { text = string.Format("平仓追单{0} 撤单失败", orderBook.OrderNum); notice = CreateTraderNotice(AutoTraderNoticeType.Order, text); SafeFireAutoTraderNotice(notice); WriteTraderNoticeLog(notice); return; // 退出流程,触发预警 } } text = "平仓追单操作完成,等待撤单成功"; notice = CreateTraderNotice(AutoTraderNoticeType.Order, text); SafeFireAutoTraderNotice(notice); WriteTraderNoticeLog(notice); while (true) { //等待撤单完成 m_operatorEvent.WaitOne(EVENT_WAIT_Time); if (m_backgroundRunFlag == false) { text = string.Format("平仓追单流程退出"); notice = CreateTraderNotice(AutoTraderNoticeType.Infomation, text); SafeFireAutoTraderNotice(notice); WriteTraderNoticeLog(notice); return; } if (m_arbitrageOrder.HasUnFinishOrderBook == false) { text = string.Format("平仓追单已完成撤单"); notice = CreateTraderNotice(AutoTraderNoticeType.Order, text); SafeFireAutoTraderNotice(notice); WriteTraderNoticeLog(notice); break; } } } List <OrderCommand> commandList = new List <OrderCommand>(); // 对欠缺仓位进行补单 foreach (ArbitrageTask task in m_arbitrageOrder.CloseTaskGroup.TaskList) { if (task.FirstSubTask.TradeQty == task.SecondSubTask.TradeQty) { continue; } Debug.Assert(task.FirstSubTask.TradeQty > task.SecondSubTask.TradeQty); //追单 USeInstrument instrument = task.SecondSubTask.Instrument; USeOrderSide orderSide = task.SecondSubTask.OrderSide; int orderQty = task.FirstSubTask.TradeQty - task.SecondSubTask.TradeQty; Debug.Assert(orderQty > 0); decimal orderPrice = GetFirstInstrumentOrderPrice(instrument, ArbitrageOrderPriceType.OpponentPrice, orderSide); Debug.Assert(orderPrice > 0); USeOffsetType offsetType = USeOffsetType.Close; List <OrderCommand> subCommandList = CreateOrderCommands(task.TaskId, instrument, orderSide, offsetType, orderQty, orderPrice, "平仓追单"); foreach (OrderCommand command in subCommandList) { bool orderResult = PlaceOrderForOrderCommand(command); if (orderResult) { task.SecondSubTask.AddPositiveOrderBook(command.CreateOrignalOrderBook()); task.UpdateTaskState(); //task.TaskState = ArbitrageTaskState.FirstPlaceOrder; } } commandList.AddRange(subCommandList); } #region 通知 foreach (OrderCommand command in commandList) { AutoTraderNotice notice = CreateTraderNotice(AutoTraderNoticeType.Order, command.ToDescription()); SafeFireAutoTraderNotice(notice); WriteTraderNoticeLog(notice); } #endregion { string text = "平仓追单已完成追单,等待成交"; AutoTraderNotice notice = CreateTraderNotice(AutoTraderNoticeType.Order, text); SafeFireAutoTraderNotice(notice); WriteTraderNoticeLog(notice); } }
/// <summary> /// 套利单任务 -- 优先合约下单。 /// </summary> /// <param name="taskGroup">开仓/平仓 任务组。</param> /// <param name="differentialUnit">最大仓差。</param> /// <returns></returns> private bool ProcessFirstSubTask(ArbitrageTaskGroup taskGroup, int differentialUnit) { #region 校验 PriceSpreadCheckResult priceSpeadResult = CheckPriceSpread(taskGroup.OpenCloseType, m_arbitrageOrder.Argument); if (priceSpeadResult.OrderReason == TaskOrderReason.None) { WriteTraderDebugInfo("优先合约检查,不满足价差条件"); return(false); } int firstUnExeTaskIndex = taskGroup.GetFirstTaskUnExecutIndex(); if (firstUnExeTaskIndex < 0) { // 优先合约全部完成下单 return(false); } bool secondTaskIsPlaceOrder = taskGroup.CheckSecondTaskIsPlaceOrder(firstUnExeTaskIndex); if (secondTaskIsPlaceOrder == false) { WriteTraderDebugInfo("反手合约还未下单,不许下单"); return(false); } //反手仓位未成交任务数 int secondUnTradeTaskCount = taskGroup.GetUnTradeSecondTaskCount(firstUnExeTaskIndex); if (secondUnTradeTaskCount >= differentialUnit) { WriteTraderDebugInfo("优先合约反手合约任务仓差大于等于允许最大仓差,不许下单"); return(false); } ArbitrageTask task = taskGroup.TaskList[firstUnExeTaskIndex]; Debug.Assert(task != null && task.TaskState == ArbitrageTaskState.None); ArbitrageSubTask firstSubTask = task.FirstSubTask; if (firstSubTask.TryOrderCount >= m_tryOrderCondition.MaxTryOrderCount) { m_backgroundRunFlag = false; string text = string.Format("流程暂停,{2}下单任务[{0}]超出最大尝试下单次数{1}次", task.TaskId, m_tryOrderCondition.MaxTryOrderCount, firstSubTask.Instrument.InstrumentCode); AutoTraderNotice notice = CreateTraderNotice(AutoTraderNoticeType.Order, text); SafeFireAutoTraderNotice(notice); AlarmNotice alarm = new AlarmNotice(AlarmType.AutoTraderWarning, text); SafeFireAutoTraderAlarm(alarm); WriteTraderNoticeLog(notice); return(false); } if (firstSubTask.CanPlaceNextOrder(m_tryOrderCondition.NextOrderInterval) == false) { WriteTraderDebugInfo("优先合约检查,距离上次下单时间过近,暂时不下单"); return(false); } #endregion #region 单 Debug.Assert(priceSpeadResult.OrderReason == TaskOrderReason.Open || priceSpeadResult.OrderReason == TaskOrderReason.Close || priceSpeadResult.OrderReason == TaskOrderReason.StopLoss); task.OrderReason = priceSpeadResult.OrderReason; task.PriceSpread = priceSpeadResult.PriceSpreadThreshold; //获取优先合约下单价格 decimal orderPrice = GetFirstInstrumentOrderPrice(firstSubTask.Instrument, firstSubTask.OrderPriceType, firstSubTask.OrderSide); Debug.Assert(orderPrice > 0); int orderQty = firstSubTask.UnOrderQty; Debug.Assert(orderQty > 0); USeInstrument instrument = firstSubTask.Instrument; USeOffsetType offsetType = firstSubTask.OffsetType; USeOrderSide orderSide = firstSubTask.OrderSide; List <OrderCommand> commandList = null; lock (ms_orderSyncObj) { commandList = CreateOrderCommands(task.TaskId, instrument, orderSide, offsetType, orderQty, orderPrice, "优先合约"); Debug.Assert(commandList != null && commandList.Count > 0); foreach (OrderCommand command in commandList) { bool orderResult = PlaceOrderForOrderCommand(command); if (orderResult) { firstSubTask.AddPositiveOrderBook(command.CreateOrignalOrderBook()); task.UpdateTaskState(); //task.TaskState = ArbitrageTaskState.FirstPlaceOrder; } } } firstSubTask.AddTryOrderCount(); // 下单累加1次 #endregion #region 通知 foreach (OrderCommand command in commandList) { AutoTraderNotice notice = CreateTraderNotice(AutoTraderNoticeType.Order, command.ToDescription()); SafeFireAutoTraderNotice(notice); WriteTraderNoticeLog(notice); } #endregion return(true); }
/// <summary> /// 套利单任务--反手合约下单(优先合约已成交) /// </summary> /// <param name="taskGroup">开仓/平仓 任务组。</param> private bool ProcessSecondSubTask(ArbitrageTaskGroup taskGroup) { for (int i = 0; i < taskGroup.TaskList.Count; i++) { #region 校验 ArbitrageTask task = taskGroup.TaskList[i]; if (task.TaskState != ArbitrageTaskState.FirstTradeFinish) { //优先合约未成交,无需做反手合约检查 continue; } ArbitrageSubTask secondSubTask = task.SecondSubTask; if (secondSubTask.TryOrderCount >= m_tryOrderCondition.MaxTryOrderCount) { m_backgroundRunFlag = false; string text = string.Format("流程暂停,{2}下单任务[{0}]超出最大尝试下单次数{1}次", task.TaskId, m_tryOrderCondition.MaxTryOrderCount, secondSubTask.Instrument.InstrumentCode); AutoTraderNotice notice = CreateTraderNotice(AutoTraderNoticeType.Order, text); SafeFireAutoTraderNotice(notice); AlarmNotice alarm = new AlarmNotice(AlarmType.AutoTraderWarning, text); SafeFireAutoTraderAlarm(alarm); WriteTraderNoticeLog(notice); return(false); } if (secondSubTask.CanPlaceNextOrder(m_tryOrderCondition.NextOrderInterval) == false) { WriteTraderDebugInfo("反手合约检查,距离上次下单时间过近,暂时不下单"); continue; } #endregion #region 单 //获取反手合约下单价格 decimal orderPrice = GetSecondTaskOrderPrice(taskGroup.OperationSide, taskGroup.PreferentialSide, task.FirstSubTaskAvgTradePrice, task.PriceSpread); orderPrice = TrimOrderPrice(secondSubTask.Instrument, orderPrice, secondSubTask.OrderSide); int orderQty = secondSubTask.UnOrderQty; Debug.Assert(orderQty > 0); USeInstrument instrument = secondSubTask.Instrument; USeOffsetType offsetType = secondSubTask.OffsetType; USeOrderSide orderSide = secondSubTask.OrderSide; List <OrderCommand> commandList = null; lock (ms_orderSyncObj) { commandList = CreateOrderCommands(task.TaskId, instrument, orderSide, offsetType, orderQty, orderPrice, "反手合约"); Debug.Assert(commandList != null && commandList.Count > 0); foreach (OrderCommand command in commandList) { bool orderResult = PlaceOrderForOrderCommand(command); if (orderResult) { secondSubTask.AddPositiveOrderBook(command.CreateOrignalOrderBook()); task.UpdateTaskState(); //task.TaskState = ArbitrageTaskState.FirstPlaceOrder; } } } secondSubTask.AddTryOrderCount(); // 下单累加1次 #endregion #region 通知 foreach (OrderCommand command in commandList) { AutoTraderNotice notice = CreateTraderNotice(AutoTraderNoticeType.Order, command.ToDescription()); SafeFireAutoTraderNotice(notice); WriteTraderNoticeLog(notice); } #endregion } return(false); }
/// <summary> /// 安全触发报告事件。 /// </summary> /// <param name="tradeIdentity"></param> /// <param name="alias"></param> /// <param name="noticeType">通知类型。</param> /// <param name="message">通知消息。</param> private void SafeFireAutoTraderNotice(Guid tradeIdentity, string alias, AutoTraderNoticeType noticeType, string message) { AutoTraderNotice notice = new AutoTraderNotice(tradeIdentity, alias, noticeType, message); SafeFireAutoTraderNotice(notice); }
private AutoTraderNotice CreateTraderNotice(string message) { AutoTraderNotice notice = new AutoTraderNotice(this.TraderIdentify, this.Alias, AutoTraderNoticeType.Infomation, message); return(notice); }
private void AutoTrader_OnNotify(AutoTraderNotice notice) { SafeFireAutoTraderNotice(notice); }
private AutoTraderNotice CreateTraderNotice(AutoTraderNoticeType noticeType, string message) { AutoTraderNotice notice = new AutoTraderNotice(this.TraderIdentify, this.Alias, noticeType, message); return(notice); }
/// <summary> /// 初始化套利下单机。 /// </summary> /// <param name="arbitrageOrder">套利单信息。</param> /// <param name="orderDriver">下单驱动。</param> /// <param name="quoteDriver">行情驱动。</param> /// <param name="alarmManager">预警管理类。</param> public void Initialize(USeArbitrageOrder arbitrageOrder, USeOrderDriver orderDriver, USeQuoteDriver quoteDriver, AlarmManager alarmManager) { if (m_initialized) { throw new ApplicationException(string.Format("{0} already initialized.", this)); } if (arbitrageOrder == null) { throw new ArgumentNullException("arbitrageOrder", "arbitrageOrder is null"); } if (orderDriver == null) { throw new ArgumentNullException("orderDriver", "orderDriver is null"); } if (quoteDriver == null) { throw new ArgumentNullException("quoteDrvier", "quoteDrvier is null"); } if (alarmManager == null) { throw new ArgumentNullException("alarmManager", "alarmManager is null"); } try { lock (m_syncObj) { m_arbitrageOrder = arbitrageOrder.Clone(); m_orderDriver = orderDriver; m_quoteDriver = quoteDriver; } m_orderDriver.OnOrderBookChanged += OrderDriver_OnOrderBookChanged; m_quoteDriver.OnMarketDataChanged += QuoteDriver_OnMarketDataChanged; if (arbitrageOrder.OpenArgument != null) { m_quoteDriver.Subscribe(arbitrageOrder.OpenArgument.BuyInstrument); m_quoteDriver.Subscribe(arbitrageOrder.OpenArgument.SellInstrument); } string text = string.Format("初始化套利单完成,当前状态为[{0}]", arbitrageOrder.State.ToDescription()); AutoTraderNotice notice = CreateTraderNotice(text); SafeFireAutoTraderNotice(notice); WriteTraderNoticeLog(notice); } catch (Exception ex) { string text = string.Format("初始化套利单失败,原因:{0}", ex.Message); AutoTraderNotice notice = CreateTraderNotice(text); SafeFireAutoTraderNotice(notice); WriteTraderNoticeLog(notice); throw new Exception("初始化自定下单机失败"); } m_initialized = true; }