Пример #1
0
 private void OnRtnTrade_callback(IntPtr pTraderApi, ref CZQThostFtdcTradeField pTrade)
 {
     if (null != OnRtnTrade)
     {
         OnRtnTrade(this, new OnRtnTradeArgs(pTraderApi, ref pTrade));
     }
 }
        /// <summary>
        /// 返回交易模块编号
        /// </summary>
        /// <param name="field"></param>
        /// <returns></returns>
        public static string GetModelID(object field)
        {
            //委托单
            if (field is CZQThostFtdcInputOrderField)
            {
                CZQThostFtdcInputOrderField ctpOrder = (CZQThostFtdcInputOrderField)field;
                return(GetModelIDByOrderRef(ctpOrder.OrderRef));
            }

            //撤单
            if (field is CZQThostFtdcOrderActionField)
            {
                CZQThostFtdcOrderActionField ctpOrder = (CZQThostFtdcOrderActionField)field;
                return(GetModelIDByOrderRef(ctpOrder.OrderRef));
            }

            //订单
            if (field is CZQThostFtdcOrderField)
            {
                CZQThostFtdcOrderField ctpOrder = (CZQThostFtdcOrderField)field;
                return(GetModelIDByOrderRef(ctpOrder.OrderRef));
            }

            //成交单
            if (field is CZQThostFtdcTradeField)
            {
                CZQThostFtdcTradeField ctpOrder = (CZQThostFtdcTradeField)field;
                return(GetModelIDByOrderRef(ctpOrder.OrderRef));
            }

            throw new Exception("unknow field:" + field.ToString(), null);
        }
Пример #3
0
 private void OnRspQryTrade_callback(IntPtr pTraderApi, ref CZQThostFtdcTradeField pTrade, ref CZQThostFtdcRspInfoField pRspInfo, int nRequestID, bool bIsLast)
 {
     if (null != OnRspQryTrade)
     {
         OnRspQryTrade(this, new OnRspQryTradeArgs(pTraderApi, ref pTrade, ref pRspInfo, nRequestID, bIsLast));
     }
 }
Пример #4
0
 public OnRspQryTradeArgs(IntPtr pTraderApi, ref CZQThostFtdcTradeField pTrade, ref CZQThostFtdcRspInfoField pRspInfo, int nRequestID, bool bIsLast)
 {
     this.pTraderApi = pTraderApi;
     this.pTrade     = pTrade;
     this.pRspInfo   = pRspInfo;
     this.nRequestID = nRequestID;
     this.bIsLast    = bIsLast;
 }
Пример #5
0
        public bool UpdateByTrade(CZQThostFtdcTradeField pTrade)
        {
            lock (this)
            {
                TZQThostFtdcPosiDirectionType PosiDirection = TZQThostFtdcPosiDirectionType.Net;
                TZQThostFtdcPositionDateType  PositionDate  = TZQThostFtdcPositionDateType.Today;
                TZQThostFtdcHedgeFlagType     HedgeFlag     = TZQThostFtdcHedgeFlagType.Speculation;

                return(InsertOrReplaceForTrade(
                           pTrade.InstrumentID,
                           PosiDirection,
                           pTrade.Direction,
                           HedgeFlag,
                           PositionDate,
                           pTrade.Volume));
            }
        }
Пример #6
0
        public bool OnTrade(ref SingleOrder order, ref CZQThostFtdcTradeField pTrade, ref double Price, ref int Volume)
        {
            //先保存到两个队例,排序是为了配对
            //if (TZQThostFtdcDirectionType.Buy == pTrade.Direction)
            //{
            //    qBuy.Add(pTrade);
            //    qBuy.Sort(SortCZQThostFtdcTradeField);
            //}
            //else
            //{
            //    qSell.Add(pTrade);
            //    qSell.Sort(SortCZQThostFtdcTradeField);
            //}

            ////取已经配对好的
            //if (qBuy.Count > 0 && qSell.Count > 0)
            //{
            //    if (qBuy[0].Volume == qSell[0].Volume)//如果不等就有问题了
            //    {
            //        Volume = qBuy[0].Volume;
            //        if (order.Side == Side.Buy)
            //        {
            //            Price = qBuy[0].Price - qSell[0].Price;
            //        }
            //        else
            //        {
            //            Price = qSell[0].Price - qBuy[0].Price;
            //        }
            //        //用完就清除
            //        qBuy.RemoveAt(0);
            //        qSell.RemoveAt(0);
            //        return true;
            //    }
            //}
            return(false);
        }
        public static string GetOrderUniqueKey(object field)
        {
            //委托单
            //if (field is CZQThostFtdcInputOrderField)
            //{
            //  CZQThostFtdcInputOrderField ctpOrder = (CZQThostFtdcInputOrderField)field;
            //  return string.Format("{0}_{1}_{2}_{3}", ctpOrder.BrokerID, ctpOrder.InvestorID, ctpOrder.InstrumentID, ctpOrder.OrderRef);
            //}

            //撤单
            if (field is CZQThostFtdcOrderActionField)
            {
                CZQThostFtdcOrderActionField ctpOrder = (CZQThostFtdcOrderActionField)field;
                return(string.Format("{0:X}_{1:X}_{2}", ctpOrder.FrontID, ctpOrder.SessionID, ctpOrder.OrderRef.Trim()));
            }

            //订单
            if (field is CZQThostFtdcOrderField)
            {
                CZQThostFtdcOrderField ctpOrder = (CZQThostFtdcOrderField)field;
                return(string.Format("{0:X}_{1:X}_{2}", ctpOrder.FrontID, ctpOrder.SessionID, ctpOrder.OrderRef.Trim()));
            }

            //预埋单
            if (field is CZQThostFtdcParkedOrderField)
            {
                CZQThostFtdcParkedOrderField ctpOrder = (CZQThostFtdcParkedOrderField)field;
                return(string.Format("{0}_{1}_{2}", ctpOrder.BrokerID, ctpOrder.InvestorID, ctpOrder.ParkedOrderID));
            }

            //删除预埋单
            if (field is CZQThostFtdcRemoveParkedOrderField)
            {
                CZQThostFtdcRemoveParkedOrderField ctpOrder = (CZQThostFtdcRemoveParkedOrderField)field;
                return(string.Format("{0}_{1}_{2}", ctpOrder.BrokerID, ctpOrder.InvestorID, ctpOrder.ParkedOrderID));
            }


            //成交单
            if (field is CZQThostFtdcTradeField)
            {
                CZQThostFtdcTradeField ctpData = (CZQThostFtdcTradeField)field;
                return(string.Format("{0}_{1}_{2}_{3}", ctpData.BrokerID, ctpData.InvestorID, ctpData.TradingDay, ctpData.TradeID));
            }

            //持仓
            if (field is CZQThostFtdcInvestorPositionField)
            {
                CZQThostFtdcInvestorPositionField ctpData = (CZQThostFtdcInvestorPositionField)field;
                return(string.Format("{0}_{1}_{2}_{3}_{4}", ctpData.BrokerID, ctpData.InvestorID, ctpData.TradingDay, ctpData.InstrumentID, ctpData.PosiDirection));
            }

            //持仓明细
            if (field is CZQThostFtdcInvestorPositionDetailField)
            {
                //注意!!成交单ID可能重复
                CZQThostFtdcInvestorPositionDetailField ctpData = (CZQThostFtdcInvestorPositionDetailField)field;
                return(string.Format("{0}_{1}_{2}_{3}", ctpData.BrokerID, ctpData.InvestorID, ctpData.TradingDay, ctpData.TradeID));
            }

            throw new Exception("Unknow type : " + field.GetType().ToString());
        }
        public static string GetUserKey(object field)
        {
            //委托单
            if (field is CZQThostFtdcInputOrderField)
            {
                CZQThostFtdcInputOrderField ctpOrder = (CZQThostFtdcInputOrderField)field;
                return(GetUserKey(ctpOrder.InvestorID, ctpOrder.BrokerID));
            }

            //撤单
            if (field is CZQThostFtdcOrderActionField)
            {
                CZQThostFtdcOrderActionField ctpOrder = (CZQThostFtdcOrderActionField)field;
                return(GetUserKey(ctpOrder.InvestorID, ctpOrder.BrokerID));
            }

            //预埋单
            if (field is CZQThostFtdcParkedOrderField)
            {
                CZQThostFtdcParkedOrderField ctpOrder = (CZQThostFtdcParkedOrderField)field;
                return(GetUserKey(ctpOrder.InvestorID, ctpOrder.BrokerID));
            }

            //删除预埋单
            if (field is CZQThostFtdcRemoveParkedOrderField)
            {
                CZQThostFtdcRemoveParkedOrderField ctpOrder = (CZQThostFtdcRemoveParkedOrderField)field;
                return(GetUserKey(ctpOrder.InvestorID, ctpOrder.BrokerID));
            }

            //预埋撤单
            if (field is CZQThostFtdcParkedOrderActionField)
            {
                CZQThostFtdcRemoveParkedOrderField ctpOrder = (CZQThostFtdcRemoveParkedOrderField)field;
                return(GetUserKey(ctpOrder.InvestorID, ctpOrder.BrokerID));
            }

            //删除预埋撤单
            if (field is CZQThostFtdcRemoveParkedOrderActionField)
            {
                CZQThostFtdcRemoveParkedOrderActionField ctpOrder = (CZQThostFtdcRemoveParkedOrderActionField)field;
                return(GetUserKey(ctpOrder.InvestorID, ctpOrder.BrokerID));
            }

            //订单
            if (field is CZQThostFtdcOrderField)
            {
                CZQThostFtdcOrderField ctpOrder = (CZQThostFtdcOrderField)field;
                return(GetUserKey(ctpOrder.InvestorID, ctpOrder.BrokerID));
            }

            //成交单
            if (field is CZQThostFtdcTradeField)
            {
                CZQThostFtdcTradeField ctpData = (CZQThostFtdcTradeField)field;
                return(GetUserKey(ctpData.InvestorID, ctpData.BrokerID));
            }

            //持仓
            if (field is CZQThostFtdcInvestorPositionField)
            {
                CZQThostFtdcInvestorPositionField ctpData = (CZQThostFtdcInvestorPositionField)field;
                return(GetUserKey(ctpData.InvestorID, ctpData.BrokerID));
            }

            //持仓明细
            if (field is CZQThostFtdcInvestorPositionDetailField)
            {
                CZQThostFtdcInvestorPositionDetailField ctpData = (CZQThostFtdcInvestorPositionDetailField)field;
                return(GetUserKey(ctpData.InvestorID, ctpData.BrokerID));
            }

            //持仓明细
            if (field is CZQThostFtdcInvestorPositionCombineDetailField)
            {
                CZQThostFtdcInvestorPositionCombineDetailField ctpData = (CZQThostFtdcInvestorPositionCombineDetailField)field;
                return(GetUserKey(ctpData.InvestorID, ctpData.BrokerID));
            }

            //资金账户
            if (field is CZQThostFtdcTradingAccountField)
            {
                CZQThostFtdcTradingAccountField ctpData = (CZQThostFtdcTradingAccountField)field;
                return(GetUserKey(ctpData.AccountID, ctpData.BrokerID));
            }

            throw new Exception("unknow type : " + field.GetType().FullName);
        }
        //用于计算组合成交
        //private Dictionary<SingleOrder, DbInMemTrade> _Orders4Combination = new Dictionary<SingleOrder, DbInMemTrade>();

        private void OnRtnTrade(IntPtr pTraderApi, ref CZQThostFtdcTradeField pTrade)
        {
            tdlog.Info("时{0},合约{1},方向{2},开平{3},价{4},量{5},引用{6},成交编号{7}",
                       pTrade.TradeTime, pTrade.InstrumentID, pTrade.Direction, pTrade.OffsetFlag,
                       pTrade.Price, pTrade.Volume, pTrade.OrderRef, pTrade.TradeID);

            //由于证券比较复杂,此处的持仓计算目前不准
            if (_dbInMemInvestorPosition.UpdateByTrade(pTrade))
            {
            }
            else
            {
                //本地计算更新失败,重查一次
                TraderApi.TD_ReqQryInvestorPosition(m_pTdApi, pTrade.InstrumentID);
            }

            SingleOrder order;
            //找到自己发送的订单,标记成交
            string strSysID = string.Format("{0}:{1}", pTrade.ExchangeID, pTrade.OrderSysID);
            string strKey;

            if (!_OrderSysID2OrderRef.TryGetValue(strSysID, out strKey))
            {
                return;
            }

            //找到自己发送的订单,标记成交
            if (_OrderRef2Order.TryGetValue(strKey, out order))
            {
                double Price  = 0;
                int    Volume = 0;
                //if (TZQThostFtdcTradeTypeType.CombinationDerived == pTrade.TradeType)
                //{
                //    //组合,得特别处理
                //    DbInMemTrade _trade;//用此对象维护组合对
                //    if (!_Orders4Combination.TryGetValue(order, out _trade))
                //    {
                //        _trade = new DbInMemTrade();
                //        _Orders4Combination[order] = _trade;
                //    }

                //    double Price = 0;
                //    int Volume = 0;
                //    //找到成对交易的,得出价差
                //    if (_trade.OnTrade(ref order, ref pTrade, ref Price, ref Volume))
                //    {
                //        EmitFilled(order, Price, Volume);

                //        //完成使命了,删除
                //        if (_trade.isEmpty())
                //        {
                //            _Orders4Combination.Remove(order);
                //        }
                //    }
                //}
                //else
                {
                    //普通订单,直接通知即可
                    Price  = Convert.ToDouble(pTrade.Price);
                    Volume = pTrade.Volume;
                }

                int LeavesQty = (int)order.LeavesQty - Volume;
                EmitFilled(order, Price, Volume, CommType.Absolute, 0);

                //成交完全,清理
                if (LeavesQty <= 0)
                {
                    _OrderRef2Order.Remove(strKey);
                    _OrderSysID2OrderRef.Remove(strSysID);
                    _Orders4Cancel.Remove(order);
                }
            }
        }
Пример #10
0
 private static int SortCZQThostFtdcTradeField(CZQThostFtdcTradeField a1, CZQThostFtdcTradeField a2)
 {
     return(a1.TradeID.CompareTo(a2.TradeID));
 }
Пример #11
0
 public OnRtnTradeArgs(IntPtr pTraderApi, ref CZQThostFtdcTradeField pTrade)
 {
     this.pTraderApi = pTraderApi;
     this.pTrade     = pTrade;
 }