public override void Subscribe(Instrument instrument)
 {
     if (instrument.Parent != null)
     {
         this.strategyBySynthInstrument[instrument.Id] = this.strategyBySynthInstrument[instrument.Parent.Id];
         this.strategyBySynthInstrument[instrument.Id].OnSubscribe(instrument);
         return;
     }
     SellSideInstrumentStrategy sellSideInstrumentStrategy = (SellSideInstrumentStrategy)Activator.CreateInstance(base.GetType(), new object[]
     {
         this.framework,
         string.Concat(new object[]
         {
             base.Name,
             "(",
             instrument,
             ")"
         })
     });
     this.SetupStrategy(sellSideInstrumentStrategy);
     sellSideInstrumentStrategy.Instrument = instrument;
     this.strategyBySynthInstrument[instrument.Id] = sellSideInstrumentStrategy;
     sellSideInstrumentStrategy.OnSubscribe(instrument);
     sellSideInstrumentStrategy.dataProvider = base.DataProvider;
     sellSideInstrumentStrategy.executionProvider = base.ExecutionProvider;
     sellSideInstrumentStrategy.raiseEvents = true;
     base.AddStrategy(sellSideInstrumentStrategy, false);
     sellSideInstrumentStrategy.OnStrategyStart();
 }

        // 从分类好的目录中取中所有合约
        private SortedDictionary<int, FileInfo> GetData_Instrument(Instrument inst)
        {
            SortedDictionary<int, FileInfo> resultList = new SortedDictionary<int, FileInfo>();

            if (string.IsNullOrEmpty(DataPath_Instrument))
                return resultList;            

            // 直接查找某一目录是否存在
            string instrument = inst.Symbol;
            int i = inst.Symbol.IndexOf('.');
            if(i>=0)
            {
                instrument = instrument.Substring(0,i);
            }

            var di = new DirectoryInfo(DataPath_Instrument);

            if (!di.Exists)
                return resultList;

            var list = di.GetDirectories(instrument, System.IO.SearchOption.AllDirectories);
            foreach(var l in list)
            {
                UnionAndUpdate(resultList, GetFiles(l, inst.Symbol));
            }

            return resultList;
        }

 public HistoricalDataRequest(Instrument instrument, DateTime dateTime1, DateTime dateTime2, byte dataType)
 {
     this.Instrument = instrument;
     this.DateTime1 = dateTime1;
     this.DateTime2 = dateTime2;
     this.DataType = dataType;
 }

		protected BarFactoryItem(Instrument instrument, BarType barType, long barSize)
		{
			this.factory = null;
			this.instrument = instrument;
			this.barType = barType;
			this.barSize = barSize;
		}

 protected override void OnInit()
 {
   this.instrument = (Instrument) this.args[0];
   this.InitDataSeriesList();
   this.InitDataSeriesViewer();
   this.Text = string.Format("Data [{0}]", (object) this.instrument.Symbol);
 }

		public override object Read(BinaryReader reader)
		{
			reader.ReadByte();
			int id = reader.ReadInt32();
			InstrumentType type = (InstrumentType)reader.ReadByte();
			string symbol = reader.ReadString();
			string description = reader.ReadString();
			byte currencyId = reader.ReadByte();
			string exchange = reader.ReadString();
			Instrument instrument = new Instrument(id, type, symbol, description, currencyId, exchange);
			instrument.tickSize = reader.ReadDouble();
			instrument.maturity = new DateTime(reader.ReadInt64());
			instrument.factor = reader.ReadDouble();
			instrument.strike = reader.ReadDouble();
			instrument.putcall = (PutCall)reader.ReadByte();
			instrument.margin = reader.ReadDouble();
			int num = reader.ReadInt32();
			for (int i = 0; i < num; i++)
			{
				AltId altId = new AltId();
				altId.providerId = reader.ReadByte();
				altId.symbol = reader.ReadString();
				altId.exchange = reader.ReadString();
				instrument.altId.Add(altId);
			}
			return instrument;
		}

 public void Subscribe(IDataProvider provider, Instrument instrument)
 {
     if (provider.Status != ProviderStatus.Connected)
     {
         provider.Connect();
     }
     Dictionary<Instrument, int> dictionary = null;
     if (!this.subscriptions.TryGetValue((int)provider.Id, out dictionary))
     {
         dictionary = new Dictionary<Instrument, int>();
         this.subscriptions[(int)provider.Id] = dictionary;
     }
     int num = 0;
     bool flag = false;
     if (!dictionary.TryGetValue(instrument, out num))
     {
         flag = true;
         num = 1;
     }
     else
     {
         if (num == 0)
         {
             flag = true;
         }
         num++;
     }
     dictionary[instrument] = num;
     if (flag)
     {
         provider.Subscribe(instrument);
     }
 }

 public ImportTask(Instrument instrument)
 {
   this.Instrument = instrument;
   this.State = ImportTaskState.Pending;
   this.Count = 0;
   this.TotalNum = 0;
   this.Message = string.Empty;
 }

 private void textBox_Instrument_Validating(object sender, CancelEventArgs e)
 {
     Instrument = SmartQuant.Shared.Global.Framework.InstrumentManager.Get((sender as TextBox).Text);
     errorProvider1.Clear();
     if (Instrument == null)
     {
         errorProvider1.SetError(textBox_Instrument,"合约不存在");
     }
 }

		public void Delete(Instrument instrument)
		{
			this.instruments.Remove(instrument);
			if (this.server != null && instrument.isPersistent)
			{
				this.server.Delete(instrument);
			}
			this.framework.eventServer.OnInstrumentDeleted(instrument);
		}

		public Instrument GetById(int id)
		{
			Instrument instrument = this.instruments.GetById(id);
			if (instrument == null)
			{
				instrument = new Instrument(id, InstrumentType.Synthetic, Guid.NewGuid().ToString(), "", 1);
				this.instruments.Add(instrument);
			}
			return instrument;
		}

 public InstrumentViewItem(Instrument instrument)
   : base(new string[5])
 {
   this.Instrument = instrument;
   this.SubItems[0].Text = instrument.Symbol;
   this.SubItems[1].Text = instrument.Type.ToString();
   this.SubItems[2].Text = instrument.Exchange;
   this.SubItems[3].Text = CurrencyId.GetName(instrument.CurrencyId);
   this.SubItems[4].Text = instrument.Maturity == DateTime.MinValue ? string.Empty : instrument.Maturity.ToShortDateString();
 }

 public Order(IExecutionProvider provider, Instrument instrument, OrderType type, OrderSide side, double qty, double price = 0.0, double stopPx = 0.0, TimeInForce timeInForce = TimeInForce.Day, string text = "")
     : this()
 {
     this.provider = provider;
     this.instrument = instrument;
     this.type = type;
     this.side = side;
     this.qty = qty;
     this.price = price;
     this.stopPx = stopPx;
     this.timeInForce = timeInForce;
     this.text = text;
     this.portfolio = null;
 }

		public void Add(Instrument instrument, bool save = true)
		{
			if (this.Contains(instrument.symbol))
			{
				throw new ApplicationException("Instrument with the same symbol is already present in the framework : " + instrument.symbol);
			}
			instrument.Id = this.next_id;
			this.next_id++;
			this.instruments.Add(instrument);
			if (save && this.server != null)
			{
				this.server.Save(instrument);
			}
			this.framework.eventServer.OnInstrumentAdded(instrument);
		}

		public void AddInstance(Instrument instrument, InstrumentStrategy strategy)
		{
			strategy.instruments.Add(instrument);
			strategy.instrument = instrument;
			strategy.raiseEvents = true;
			strategy.dataProvider = this.dataProvider;
			strategy.executionProvider = this.executionProvider;
			this.Add(strategy);
			if (base.Instruments.GetById(instrument.id) == null)
			{
				base.Instruments.Add(instrument);
			}
			strategy.status = StrategyStatus.Running;
			strategy.OnStrategyStart();
		}

 public Stop(Strategy strategy, Position position, DateTime time)
 {
     this.strategy = strategy;
     this.position = position;
     this.instrument = position.instrument;
     this.qty = position.qty;
     this.side = position.Side;
     this.type = StopType.Time;
     this.creationTime = strategy.framework.Clock.DateTime;
     this.completionTime = time;
     this.stopPrice = this.GetInstrumentPrice();
     if (this.completionTime > this.creationTime)
     {
         strategy.framework.Clock.AddReminder(new Reminder(new ReminderCallback(this.OnClock), this.completionTime, null));
     }
 }

        protected override void OnBar(Instrument instrument, Bar bar)
        {
            // Add bar to bar series.
            Bars.Add(bar);

            // Add bar to group.
            Log(bar, barsGroup);

            // Add upper bollinger band value to group.
            if (bbu.Count > 0)
                Log(bbu.Last, bbuGroup);

            // Add lower bollinger band value to group.
            if (bbl.Count > 0)
                Log(bbl.Last, bblGroup);

            // Add simple moving average value bands to group.
            if (sma.Count > 0)
                Log(sma.Last, smaGroup);

            // Calculate performance.
            Portfolio.Performance.Update();

            // Add equity to group.
            Log(Portfolio.Value, equityGroup);

            // Check strategy logic.
            if (!HasPosition(instrument))
            {
                if (bbu.Count > 0 && bar.Close >= bbu.Last)
                {
                    Order enterOrder = SellOrder(Instrument, Qty, "Enter");
                    Send(enterOrder);
                }
                else if (bbl.Count > 0 && bar.Close <= bbl.Last)
                {
                    Order enterOrder = BuyOrder(Instrument, Qty, "Enter");
                    Send(enterOrder);
                }
            }
            else
                UpdateExitLimit();
        }

		public void Add(Instrument instrument, BarType barType, long barSize)
		{
			BarFactoryItem item;
			switch (barType)
			{
			case BarType.Time:
				item = new TimeBarFactoryItem(instrument, barSize);
				break;
			case BarType.Tick:
				item = new TickBarFactoryItem(instrument, barSize);
				break;
			case BarType.Volume:
				item = new VolumeBarFactoryItem(instrument, barSize);
				break;
			default:
				throw new ArgumentException(string.Format("Unknown bar type - {0}", barType));
			}
			this.Add(item);
		}

		public TickSeries GetHistoricalTrades(IHistoricalDataProvider provider, Instrument instrument, DateTime dateTime1, DateTime dateTime2)
		{
			HistoricalDataRequest request = new HistoricalDataRequest(instrument, dateTime1, dateTime2, 4);
			provider.Send(request);
			this.handle = new ManualResetEventSlim(false);
			this.handle.Wait();
			TickSeries tickSeries = new TickSeries("");
			if (this.historicalData != null)
			{
				foreach (HistoricalData current in this.historicalData)
				{
					DataObject[] objects = current.Objects;
					for (int i = 0; i < objects.Length; i++)
					{
						DataObject dataObject = objects[i];
						tickSeries.Add((Trade)dataObject);
					}
				}
			}
			this.historicalData = null;
			return tickSeries;
		}

        // 得到API中的合约名与交易所
        private void GetApi_Symbol_Exchange_TickSize(Instrument instrument,
            out string altSymbol, out string altExchange,
            out string apiSymbol, out string apiExchange,
            out double apiTickSize)
        {
            // 取合约别名
            altSymbol = instrument.GetSymbol(this.id);
            altExchange = instrument.GetExchange(this.id);
            apiTickSize = instrument.TickSize;

            // 取合约在API中的名字
            apiSymbol = altSymbol;
            apiExchange = altExchange;

            InstrumentField _Instrument;
            if (_dictInstruments.TryGetValue(altSymbol, out _Instrument))
            {
                apiSymbol = _Instrument.InstrumentID;
                apiExchange = _Instrument.ExchangeID;
                apiTickSize = _Instrument.PriceTick;
            }
        }