private void UpddateMarketData(object sender, USeMarketDataChangedEventArgs e)
        {
            USeOrderSide orderSide = GetChoiceDirection();

            this.labelUpper.Text = e.MarketData.AskPrice.ToString();
            this.labelLower.Text = e.MarketData.BidPrice.ToString();

            USeFundDetail fundDetail = USeManager.Instance.FundCalculator.FundDetail;

            Debug.Assert(fundDetail != null);
            decimal   available  = fundDetail.Available;
            decimal   priceScole = USeManager.Instance.OrderDriver.QueryInstrumentVolumeMultiple(m_selectedInstrument);
            USeMargin useMargin  = USeManager.Instance.OrderDriver.QueryInstrumentMargin(m_selectedInstrument);
            decimal   margin     = 0m;

            if (orderSide == USeOrderSide.Buy)
            {
                this.numericUpDownPrice.Value = e.MarketData.AskPrice;
                margin = (useMargin.BrokerLongMarginRatioByMoney * priceScole * this.numericUpDownPrice.Value) + useMargin.BrokerLongMarginRatioByVolume;
            }
            else if (orderSide == USeOrderSide.Sell)
            {
                this.numericUpDownPrice.Value = e.MarketData.BidPrice;
                margin = (useMargin.BrokerShortMarginRatioByMoney * priceScole * this.numericUpDownPrice.Value) + useMargin.BrokerShortMarginRatioByVolume;
            }
            else
            {
                Debug.Assert(false);
            }
            decimal miniVolumnMoney = margin > 0 ? decimal.Divide(available, margin) : 0;

            this.Label_CanVolumn.Text = (Math.Floor(miniVolumnMoney)).ToString();
        }
        private void QuoteDriver_OnMarketDataChanged(object sender, USeMarketDataChangedEventArgs e)
        {
            if (IsMyCareInstrument(e.MarketData.Instrument) == false)
            {
                return;
            }

            UpdateMarketData(e.MarketData);
        }
        /// <summary>
        /// 行情通知
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void QuoteDriver_OnMarketDataChanged(object sender, USeMarketDataChangedEventArgs e)
        {
            if (this.InvokeRequired)
            {
                this.BeginInvoke(new EventHandler <USeMarketDataChangedEventArgs>(QuoteDriver_OnMarketDataChanged), sender, e);
                return;
            }

            UpdateMarketData(e.MarketData);
        }
        private void QuoteDriver_OnMarketDataChanged(object sender, USeMarketDataChangedEventArgs e)
        {
            if (this.InvokeRequired)
            {
                this.BeginInvoke(new EventHandler <USeMarketDataChangedEventArgs>(QuoteDriver_OnMarketDataChanged), sender, e);
                return;
            }

            MarketDataViewModel marketModel = m_quoteDataSource.FirstOrDefault(p => p.Instrument == e.MarketData.Instrument);

            if (marketModel != null)
            {
                marketModel.Update(e.MarketData);
            }
        }
        /// <summary>
        /// 行情变更通知事件。
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void QuoteDriver_OnMarketDataChanged(object sender, USeMarketDataChangedEventArgs e)
        {
            if (m_backgroundRunFlag == false)
            {
                //监控流程未启动
                return;
            }
            if (IsMyCareInstrument(e.MarketData.Instrument) == false)
            {
                //不是自己关心的行情
                return;
            }

            //行情触发流程监控运行
            m_operatorEvent.Set();
        }
        private void QuoteDriver_OnMarketDataChanged(object sender, USeMarketDataChangedEventArgs e)
        {
            if (this.InvokeRequired)
            {
                this.BeginInvoke(new EventHandler <USeMarketDataChangedEventArgs>(QuoteDriver_OnMarketDataChanged), sender, e);
                return;
            }

            ////找到对应ins的合约根据多空方向计算浮动盈亏
            //PositionDataViewModel Position_Model = m_position_data_source.FirstOrDefault(p => (p.InstrumentCode == e.MarketData.Instrument.InstrumentCode));

            //Position_Model

            //if (Position_Model != null)
            //{
            //    marketModel.Update(e.MarketData);
            //}
        }
        public void QuoteDriver_OnMarketDataChanged(object sender, USeMarketDataChangedEventArgs e)
        {
            USeMarketData marketData = e.MarketData;

            #region 测试观察早盘的集合竞价的数据
            string str = string.Format("InsName:{0} ,Open:{1} ,High:{2} ,Low:{3},Close:{4},LastPrice:{5},OpenInterest:{6},SettlementPrice:{7},Volume{8},DateTime:{9}",
                                       marketData.Instrument.InstrumentCode, marketData.OpenPrice, marketData.HighPrice, marketData.LowPrice, marketData.ClosePrice,
                                       marketData.LastPrice, marketData.OpenInterest, marketData.SettlementPrice, marketData.Volume, marketData.UpdateTime);

            WriteMessage(str);
            #endregion


            if (IgnoreMarketData(marketData))    // 行情忽略检查
            {
                return;
            }

            ProcessUSeMarketData(marketData);

            if (m_listenerList != null && m_listenerList.Count > 0)
            {
                foreach (IMarketDataListener listener in m_listenerList)
                {
                    try
                    {
                        listener.ReceiveMarketData(marketData);
                    }
                    catch (Exception ex)
                    {
                        Debug.Assert(false, ex.Message);
                    }
                }
            }

            Interlocked.Increment(ref m_receiverCount);
            m_lastMarketDataTime = marketData.UpdateTime;
        }
        /// <summary>
        /// 更新交易面板的跟踪价格
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void QuoteDriver_OnMarketDataChanged(object sender, USeMarketDataChangedEventArgs e)
        {
            lock (m_syncObj)
            {
                if (m_freshOrderPrice == false)
                {
                    return;
                }
                if (m_selectedInstrument == null)
                {
                    return;
                }
                if (m_selectedInstrument != e.MarketData.Instrument)
                {
                    return;
                }
            }

            if (this.InvokeRequired)
            {
                this.BeginInvoke(new EventHandler <USeMarketDataChangedEventArgs>(UpddateMarketData), sender, e);
                return;
            }
        }
Beispiel #9
0
        //public void OnArbitrageCombineInstrumentAdd_Changed(ArbitrageCombineInstrument arbitrageInstrument)
        //{
        //    Debug.Assert(arbitrageInstrument != null);

        //    //ToDo::
        //    if (arbitrageInstrument.ProductID != m_product.ProductCode) return;

        //    ArbitrageCombineInstrumentData combineMarketData = new ArbitrageCombineInstrumentData();
        //    combineMarketData.ArbitrageCombineInstrument = arbitrageInstrument;
        //    combineMarketData.FarDistanceBuyPrice = 0m;
        //    combineMarketData.FarDistanceBuyVolumn = 0;
        //    combineMarketData.FarDistanceSellPrice = 0m;
        //    combineMarketData.FarDistanceSellVolumn = 0;

        //    combineMarketData.NearDistanceBuyPrice = 0m;
        //    combineMarketData.NearDistanceBuyVolumn = 0;
        //    combineMarketData.NearDistanceSellPrice = 0m;
        //    combineMarketData.NearDistanceSellVolumn = 0;

        //    combineMarketData.NearLastPrice = 0m;
        //    combineMarketData.FarLastPrice = 0m;

        //    ArbitrageCombineInstrumentViewModel combineMarketDataModel = ArbitrageCombineInstrumentViewModel.CreatArbitrageCombineInstrumentViewModel(combineMarketData);

        //    m_CombineInstrumentList.Add(combineMarketDataModel.ArbitrageCombineInstrument);
        //    m_dataSource.Insert(0, combineMarketDataModel);

        //    USeManager.Instance.QuoteDriver.Subscribe(arbitrageInstrument.FirstInstrument);
        //    USeManager.Instance.QuoteDriver.Subscribe(arbitrageInstrument.SecondInstrument);
        //}


        //public void OnArbitrageCombineInstrumentRemove_Changed(ArbitrageCombineInstrument arbitrageInstrument)
        //{
        //    Debug.Assert(arbitrageInstrument != null);

        //    //Todo::
        //    if (arbitrageInstrument.ProductID != m_product.ProductCode) return;
        //    ArbitrageCombineInstrumentViewModel combinIns = (from ins in m_dataSource
        //                                                     where ins.ArbitrageCombineInstrument == arbitrageInstrument
        //                                                     select ins).FirstOrDefault();
        //    if (combinIns != null)
        //    {
        //        m_dataSource.Remove(combinIns);
        //        m_CombineInstrumentList.Remove(combinIns.ArbitrageCombineInstrument);
        //    }
        //}


        /// <summary>
        /// 订阅的市场价格更改。
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void QuoteDriver_OnMarketDataChanged(object sender, USeMarketDataChangedEventArgs e)
        {
            if (this.InvokeRequired)
            {
                this.BeginInvoke(new EventHandler <USeMarketDataChangedEventArgs>(QuoteDriver_OnMarketDataChanged), sender, e);
                return;
            }

            if (USeTraderProtocol.GetVarieties(e.MarketData.Instrument.InstrumentCode) != m_product.ProductCode)
            {
                return;
            }


            m_marketDataDic[e.MarketData.Instrument] = e.MarketData;

            foreach (ArbitrageCombineInstrument combineIns in m_CombineInstrumentList)
            {
                USeInstrument firIns = combineIns.FirstInstrument;
                USeInstrument secIns = combineIns.SecondInstrument;

                if (m_marketDataDic.ContainsKey(firIns) && m_marketDataDic.ContainsKey(secIns))
                {
                    ArbitrageCombineInstrumentData combineMarketData = new ArbitrageCombineInstrumentData();
                    combineMarketData.ArbitrageCombineInstrument = combineIns;
                    combineMarketData.FarDistanceBuyPrice        = m_marketDataDic[secIns].BidPrice;
                    combineMarketData.FarDistanceBuyVolumn       = m_marketDataDic[secIns].BidSize;
                    combineMarketData.FarDistanceSellPrice       = m_marketDataDic[secIns].AskPrice;
                    combineMarketData.FarDistanceSellVolumn      = m_marketDataDic[secIns].AskSize;

                    combineMarketData.NearDistanceBuyPrice   = m_marketDataDic[firIns].BidPrice;
                    combineMarketData.NearDistanceBuyVolumn  = m_marketDataDic[firIns].BidSize;
                    combineMarketData.NearDistanceSellPrice  = m_marketDataDic[firIns].AskPrice;
                    combineMarketData.NearDistanceSellVolumn = m_marketDataDic[firIns].AskSize;

                    combineMarketData.NearLastPrice = m_marketDataDic[firIns].LastPrice;
                    combineMarketData.FarLastPrice  = m_marketDataDic[secIns].LastPrice;

                    if (m_dataSource.Count == 0)
                    {
                        continue;
                    }
                    Debug.WriteLine(DateTime.Now.ToString() + "--" + m_dataSource.Count() + combineIns.ArbitrageInstrumentOneCode + combineIns.ArbitrageInstrumentTwoCode);

                    ArbitrageCombineInstrumentViewModel combineMarketModel = (from p in m_dataSource
                                                                              where p.ArbitrageCombineInstrument == combineIns
                                                                              select p).FirstOrDefault();


                    if (combineMarketModel != null)
                    {
                        combineMarketModel.Update(combineMarketData);
                    }
                    else
                    {
                        m_dataSource.Add(combineMarketModel);
                    }
                }
                else
                {
                    continue;
                }
            }
        }