public void CheckInitStatus(object obj, System.Timers.ElapsedEventArgs e)
        {
            if (!Initializing)
               {
               lock (this)
               {
                   if (!Initialized && initCdlStatus == DataInitStatus.Initialized  &&
                      initRtdStatus == DataInitStatus.Initialized && initSigStatus == DataInitStatus.Initialized )
                   {
                       Initializing = true;
                       if( handler !=null )
                          handler.IsProcessing = false;
                       if (initRtdStatus == DataInitStatus.Initialized)
                       {
                           Console.WriteLine(" LatesRtds  count  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;  " + LatesRtds.Count);
                           LogUtil.Info(" LatesRtds  count  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;  " + LatesRtds.Count);
                           if (LatesRtds.Count > 0)
                           {
                              if (dataCache.DataUnits.ContainsKey(CurrentTInterval))
                               {
                                     dataCache.DataUnits[CurrentTInterval].AddRange(LatesRtds);
                               }
                               else
                               {
                                   dataCache.DataUnits.Add(CurrentTInterval, LatesRtds);
                               }
                               Console.WriteLine(" dataCache.DataUnits[CurrentTInterval].Count ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;  " + dataCache.DataUnits[CurrentTInterval].Count);
                               LogUtil.Info(" dataCache.DataUnits[CurrentTInterval].Count  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;  " + dataCache.DataUnits[CurrentTInterval].Count);
                           }
                       }

                       RealTimeData[] rtds = null;
                       lock (dataCache.RealTimeDatas)
                       {
                           if (dataCache.RealTimeDatas.Count > 0)
                           {
                               rtds = new RealTimeData[dataCache.RealTimeDatas.Count];
                               dataCache.RealTimeDatas.CopyTo(rtds);
                               dataCache.RealTimeDatas.Clear();
                           }
                       }

                       if (dataCache.DataUnits[CurrentTInterval].Count > 0)
                       {
                           List<BarData> datas = dataCache.DataUnits[CurrentTInterval];
                           BarData lastBar = dataCache.DataUnits[CurrentTInterval][datas.Count - 1];
                           dataCache.RefreshCurrentTime(currentTInterval, lastBar.DateTime);
                           IntervalData data = new IntervalData(lastBar.Open, lastBar.Close, lastBar.Low, lastBar.High);
                           dataCache.InitCurrentData(currentTInterval, data);
                           Console.WriteLine(" Last BAR  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;  " + lastBar );
                           LogUtil.Info(" Last BAR  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;  " + lastBar);
                           if (rtds != null && rtds.Length > 0)
                           {
                               Console.WriteLine(" dataCache.RealTimeDatas.  count  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;  " + rtds.Length);
                               LogUtil.Info(" dataCache.RealTimeDatas.  count  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;  " + rtds.Length);
                               Console.WriteLine(lastBar);
                               if (lastBar.IsCompleted)
                               {
                                   foreach (RealTimeData rtd in rtds)
                                   {
                                       dataCache.UpdateDataSource(rtd);
                                   }
                               }
                               else
                               {
                                   bool isCompleted = false;
                                   double max = lastBar.High;
                                   double min = lastBar.Low;
                                   List<double> prices = new List<double>();

                                   prices.Add(lastBar.Open);
                                   prices.Add(lastBar.Close);
                                   prices.Add(lastBar.Low);
                                   prices.Add(lastBar.High);

                                   for (int k = 0; k < rtds.Length; k++)
                                   {
                                       RealTimeData rtd = rtds[k];
                                       Console.WriteLine(" RealTimeData   ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;  " + rtd);
                                       LogUtil.Info(" RealTimeData   ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;  " + rtd);
                                       if (rtd.dateTime.CompareTo(lastBar.DateTime) < 0)
                                           continue;

                                       if (rtd.dateTime.Subtract(AppConst.AppTimeSpans[CurrentTInterval]) < lastBar.DateTime)
                                       {
                                           foreach (double price in rtd.datas)
                                           {
                                               prices.Add(price);
                                               max = Math.Max(max, price);
                                               min = Math.Min(min, price);
                                           }
                                           if (k == rtds.Length - 1 && prices.Count > 0)
                                           {
                                               lastBar.Close = prices[prices.Count - 1];
                                               lastBar.High = max;
                                               lastBar.Low = min;
                                               IntervalData newdata = new IntervalData(lastBar.Open, lastBar.Close, lastBar.Low, lastBar.High);
                                               dataCache.InitCurrentData(currentTInterval, newdata);
                                               dataCache.DataUnits[CurrentTInterval][datas.Count - 1] = lastBar;
                                           }
                                       }
                                       else if (rtd.dateTime.Subtract(AppConst.AppTimeSpans[CurrentTInterval]) >= lastBar.DateTime)
                                       {
                                           if (!isCompleted)
                                           {
                                               if (prices != null && prices.Count > 0)
                                               {
                                                   lastBar.Close = prices[prices.Count - 1];
                                                   lastBar.High = max;
                                                   lastBar.Low = min;
                                                   prices.Clear();
                                               }
                                               lastBar.IsCompleted = true;
                                               dataCache.DataUnits[CurrentTInterval][datas.Count - 1] = lastBar;
                                               IntervalData newdata = new IntervalData(lastBar.Open, lastBar.Close, lastBar.Low, lastBar.High);
                                               dataCache.InitCurrentData(currentTInterval, newdata);
                                               isCompleted = true;
                                               dataCache.UpdateDataSource(rtd);
                                           }
                                           else
                                           {
                                               dataCache.UpdateDataSource(rtd);
                                           }
                                       }
                                   }
                               }
                           }

                           SAR sar = new SAR(symbol.ToString(), currentTInterval);
                           RSI rsi = new RSI(symbol.ToString(), int.Parse(AppUtil.IntervalToString(currentTInterval)),6);
                           RSI rsi2 = new RSI(symbol.ToString(), int.Parse(AppUtil.IntervalToString(currentTInterval)),42);
                           RSI rsi3 = new RSI(symbol.ToString(), int.Parse(AppUtil.IntervalToString(currentTInterval)),14);
                           RSI rsi4 = new RSI(symbol.ToString(), int.Parse(AppUtil.IntervalToString(currentTInterval)),22);
                           CR cr = new CR(symbol.ToString(), int.Parse(AppUtil.IntervalToString(currentTInterval)));
                           ARBR arbr = new ARBR(symbol.ToString(), int.Parse(AppUtil.IntervalToString(currentTInterval)), 26);
                           ARBR arbr2 = new ARBR(symbol.ToString(), int.Parse(AppUtil.IntervalToString(currentTInterval)),42);
                           CCI cci = new CCI(symbol.ToString(), int.Parse(AppUtil.IntervalToString(currentTInterval)), 14);
                           //CCI cci2 = new CCI(symbol.ToString(), int.Parse(AppUtil.IntervalToString(currentTInterval)), 42);
                           CCI cci2 = new CCI(symbol.ToString(), int.Parse(AppUtil.IntervalToString(currentTInterval)), 24);
                           CCI cci3 = new CCI(symbol.ToString(), int.Parse(AppUtil.IntervalToString(currentTInterval)), 42);
                           WR wr=new WR(symbol.ToString(), int.Parse(AppUtil.IntervalToString(currentTInterval)),14);
                           WR wr2 = new WR(symbol.ToString(), int.Parse(AppUtil.IntervalToString(currentTInterval)), 24);
            LWR lwr=new LWR(symbol.ToString(), int.Parse(AppUtil.IntervalToString(currentTInterval)), 14, 3, 3);
            BOLL boll = new BOLL(symbol.ToString(), int.Parse(AppUtil.IntervalToString(currentTInterval)), 20);
                           for (int i = 0; i < datas.Count; i++)
                           {
                               BarData bar = datas[i];
                               if (bar.IsCompleted)
                               {
                                   sar.handleFullCandle(ref bar);
                                   rsi.handleFullCandle(ref bar, true, 1);
                                   rsi2.handleFullCandle(ref bar, true,2);
                                   rsi3.handleFullCandle(ref bar, true,3);
                                   rsi4.handleFullCandle(ref bar, true,4);
                                   cr.handleFullCandle(ref bar);
                                   arbr.handleFullCandle(ref bar, 1);
                                   arbr2.handleFullCandle(ref bar,2);
                                   cci.handleFullCandle(ref bar,1);
                                   cci2.handleFullCandle(ref bar,2);
                                   cci3.handleFullCandle(ref bar, 3);
                                   wr.handleFullCandle(ref bar, 1);
                                   wr2.handleFullCandle(ref bar,2);
                                   lwr.handleFullCandle(ref bar, 0);
                                   boll.handleFullCandle(ref bar, 0);
                                   datas[i] = bar;
                               }
                           }
                           dataCache.SARs[currentTInterval] = sar;
                           dataCache.RISs[currentTInterval] = rsi;
                           dataCache.RISs2[currentTInterval] = rsi2;
                           dataCache.RISs3[currentTInterval] = rsi3;
                           dataCache.RISs4[currentTInterval] = rsi4;
                           dataCache.CRs[currentTInterval] = cr;
                           dataCache.ARBRs[currentTInterval] = arbr;
                           dataCache.ARBRs2[currentTInterval] = arbr2;
                           dataCache.CCIs[currentTInterval] = cci;
                           dataCache.CCIs2[currentTInterval] = cci2;
                           dataCache.CCIs3[currentTInterval] = cci3;
                           dataCache.WRs[currentTInterval] = wr;
                           dataCache.WRs2[currentTInterval] = wr2;
                           dataCache.LWRs[currentTInterval] = lwr;
                           dataCache.BOLLs[currentTInterval] = boll;

                           List<Signal> signalList = dataCache.SignalUnits[currentTInterval];
                           LogUtil.Info(" SignalList  count  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;  " + signalList.Count);

                           if (signalList.Count > 0)
                           {
                               Signal[] signals = new Signal[signalList.Count];
                               signalList.CopyTo(signals, 0);
                               Array.Sort(signals);
                               Array.Reverse(signals);
                               DateTime currentTime = dataCache.CurrentTimes[currentTInterval];
                               int startIndex = 0;
                               foreach (Signal signal in signals)
                               {
                                   DateTime actTime = signal.ActTime;

                                   for (int i = startIndex; i < dataCache.DataUnits[currentTInterval].Count; i++)
                                   {
                                       bool isUpdate = false;
                                       List<CandleSignal> sigList = new List<CandleSignal>();
                                       BarData candle = dataCache.DataUnits[currentTInterval][i];
                                       if (actTime.CompareTo(candle.DateTime) > 0)
                                       {
                                           continue;
                                       }
                                       else if (actTime.CompareTo(candle.DateTime) == 0)
                                       {
                                           startIndex = i;
                                           isUpdate = true;
                                           LogUtil.Info(" Signal " + signal );
                                           LogUtil.Info(" Candle " + candle);
                                          // LogUtil.Info(" bf1st " + dataCache.DataUnits[currentTInterval][i-1]);
                                           //LogUtil.Info(" bf2nd " + dataCache.DataUnits[currentTInterval][i-2]);
                                           CandleSignal cs = new CandleSignal(signal, 1);
                                           sigList.Add(cs);
                                       }
                                       if (signal.GainTip!=0 && signal.GainTipPrice > 0 && candle.DateTime.CompareTo(signal.GainTipTime) == 0)
                                       {
                                           CandleSignal cs = new CandleSignal(signal, 2);
                                           sigList.Add(cs);
                                           isUpdate = true;
                                       }
                                       if (signal.StopLoss != 0 && signal.StopLossBidPrice > 0 && candle.DateTime.CompareTo(signal.StopLossTime) == 0)
                                       {
                                           CandleSignal cs = new CandleSignal(signal, 3);
                                           sigList.Add(cs);
                                           isUpdate = true;
                                       }
                                       if (signal.StopGain != 0 &&  signal.StopGainPrice > 0 && candle.DateTime.CompareTo(signal.StopGainTime) == 0)
                                       {
                                           CandleSignal cs = new CandleSignal(signal, 4);
                                           sigList.Add(cs);
                                           isUpdate = true;
                                       }
                                       if (isUpdate)
                                       {
                                           if (candle.SignalList != null)
                                               candle.SignalList.AddRange(sigList);
                                           else
                                               candle.SignalList = sigList;
                                           candle.RefreshExValues();
                                           dataCache.DataUnits[currentTInterval][i] = candle;
                                       }
                                   }
                                   List<CandleSignal> sList = new List<CandleSignal>();
                                   if (signal.ActTime.CompareTo(currentTime) <= 0)
                                   {
                                       if (signal.ActTime.CompareTo(currentTime) == 0)
                                       {
                                           CandleSignal cs = new CandleSignal(signal, 1);
                                           sList.Add(cs);
                                       }
                                       if (signal.GainTipPrice > 0 && signal.GainTipTime.CompareTo(currentTime) == 0)
                                       {
                                           CandleSignal cs = new CandleSignal(signal, 2);
                                           sList.Add(cs);
                                       }
                                       if (signal.StopLossBidPrice > 0 && signal.StopLossTime.CompareTo(currentTime) == 0)
                                       {
                                           CandleSignal cs = new CandleSignal(signal, 3);
                                           sList.Add(cs);
                                       }
                                       if (signal.StopGainPrice > 0 && signal.StopGainTime.CompareTo(currentTime) == 0)
                                       {
                                           CandleSignal cs = new CandleSignal(signal, 4);
                                           sList.Add(cs);
                                       }
                                       dataCache.CurrentDatas[currentTInterval].SignalList.AddRange(sList);
                                   }
                               }
                           }
                           Console.WriteLine(" LAST ###### "+lastBar);
                           LogUtil.Info(" LAST ###### " + lastBar);

                           dataCache.RefreshDataUnits(datas);
                       }
                       //dataCache.Start();
                       if (AppContext.IsLoading)
                       {
                           AppContext.IsFirstProviderInit = true;
                           isAddCandle = true;
                           Initialized = true;
                           Initializing = false;
                           ProviderHelper.CleanInitDirs(this);
                       }
                       else
                       {
                           isAddCandle = true;
                           Initialized = true;
                           Process(null, null);
                           timerInit.Stop();
                           timerAuto.Start();
                           Initializing = false;
                           ProviderHelper.CleanInitDirs(this);
                           Console.WriteLine(" End  Now   ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;  " + DateTime.Now.ToLongTimeString());
                       }
                   }
               }
               }
        }
        private void UpdateIntervalData(Interval intervSpan, ref IntervalData intvData, double[] prices, DateTime time, DataProvider provider)
        {
            if (currentTimes.ContainsKey(intervSpan) && currentDatas.ContainsKey(intervSpan))
            {
                DateTime lastTime = currentTimes[intervSpan];
                DateTime currTime = AppUtil.GetCurrentIntervalTime(lastTime, time, intervSpan);
                TimeSpan span     = time.Subtract(lastTime);
                Console.WriteLine("  currentTimes[TInterval.MIN1]  span  " + span + "  lastTime " + lastTime + " real  time " + time + " currTime " + currTime);
                LogUtil.Info("  currentTimes[TInterval.MIN1]  span  " + span + "  lastTime " + lastTime + " real  time " + time + " currTime " + currTime);
                if (lastTime.CompareTo(time) > 0)
                {
                    return;
                }
                else if (span >= AppConst.AppTimeSpans[intervSpan])
                {
                    lastTime = AppUtil.GetLatestIntervalTime(lastTime, time, intervSpan);
                    Console.WriteLine("   span > interval  span:::   " + span + "  lastTime " + lastTime + " real  time " + time);
                    BarData barData = dataUnits[intervSpan][dataUnits[intervSpan].Count - 1];
                    barData.DateTime   = lastTime;
                    barData.Open       = intvData.Open;
                    barData.Close      = intvData.Close;
                    barData.Low        = intvData.Min;
                    barData.High       = intvData.Max;
                    barData.SignalList = intvData.SignalList;

                    Console.WriteLine(" BarData  #### time " + barData);

                    List <CandleSignal> currSignalList = new List <CandleSignal>();
                    Signal[]            signals        = null;
                    lock (AppConst.SignalDatasLocker)
                    {
                        signals = new Signal[AppContext.SignalDatas.Count];
                        AppContext.SignalDatas.CopyTo(signals);
                    }
                    if (signals != null)
                    {
                        int count = 0;
                        Array.Sort(signals);
                        foreach (Signal s in signals)
                        {
                            if (s.Symbol == provider.Symbol && s.Interval == provider.CurrentTInterval)
                            {
                                if (s.ActTime.CompareTo(lastTime) == 0 && s.Arrow != 0)
                                {
                                    CandleSignal cs = new CandleSignal(s, 1);
                                    if (!barData.SignalList.Contains(cs))
                                    {
                                        barData.SignalList.Add(cs);
                                    }
                                }
                                if (s.Arrow != 0 && s.ActTime.CompareTo(currTime) == 0)
                                {
                                    CandleSignal cs = new CandleSignal(s, 1);
                                    currSignalList.Add(cs);
                                }
                                if (s.StopLoss != 0 && s.StopLossTime.CompareTo(lastTime) == 0)
                                {
                                    CandleSignal cs = new CandleSignal(s, 3);
                                    if (!barData.SignalList.Contains(cs))
                                    {
                                        barData.SignalList.Add(cs);
                                    }
                                }
                                if (s.StopLoss != 0 && s.StopLossTime.CompareTo(currTime) == 0)
                                {
                                    CandleSignal cs = new CandleSignal(s, 3);
                                    currSignalList.Add(cs);
                                }
                                if (s.GainTip != 0 && s.GainTipTime.CompareTo(lastTime) == 0)
                                {
                                    CandleSignal cs = new CandleSignal(s, 2);
                                    if (!barData.SignalList.Contains(cs))
                                    {
                                        barData.SignalList.Add(cs);
                                    }
                                }
                                if (s.GainTip != 0 && s.GainTipTime.CompareTo(currTime) == 0)
                                {
                                    CandleSignal cs = new CandleSignal(s, 2);
                                    currSignalList.Add(cs);
                                }
                                if (s.StopGain != 0 && s.StopGainTime.CompareTo(lastTime) == 0)
                                {
                                    CandleSignal cs = new CandleSignal(s, 4);
                                    if (!barData.SignalList.Contains(cs))
                                    {
                                        barData.SignalList.Add(cs);
                                    }
                                }
                                if (s.StopGain != 0 && s.StopGainTime.CompareTo(currTime) == 0)
                                {
                                    CandleSignal cs = new CandleSignal(s, 4);
                                    currSignalList.Add(cs);
                                }
                                if (count > 5)
                                {
                                    break;
                                }
                                count++;
                            }
                        }
                    }
                    barData.RefreshExValues();
                    Console.WriteLine(" BarData  ############ time " + barData);
                    LogUtil.Info(" Last BarData  #####  " + barData);
                    SAR  sar   = null;
                    CR   cr    = null;
                    RSI  rsi   = null;
                    RSI  rsi2  = null;
                    RSI  rsi3  = null;
                    RSI  rsi4  = null;
                    ARBR arbr  = null;
                    ARBR arbr2 = null;
                    CCI  cci   = null;
                    CCI  cci2  = null;
                    CCI  cci3  = null;
                    WR   wr    = null;
                    WR   wr2   = null;
                    LWR  lwr   = null;
                    BOLL boll  = null;
                    if (!provider.Initializing && provider.Initialized)
                    {
                        sar   = iSARs[intervSpan];
                        cr    = iCRs[intervSpan];
                        rsi   = iRISs[intervSpan];
                        rsi2  = iRISs2[intervSpan];
                        rsi3  = iRISs3[intervSpan];
                        rsi4  = iRISs4[intervSpan];
                        arbr  = iARBRs[intervSpan];
                        arbr2 = iARBRs2[intervSpan];
                        cci   = iCCIs[intervSpan];
                        cci2  = iCCIs2[intervSpan];
                        cci3  = iCCIs3[intervSpan];
                        wr    = iWRs[intervSpan];
                        wr2   = iWRs2[intervSpan];
                        lwr   = iLWRs[intervSpan];
                        boll  = iBOLLs[intervSpan];

                        sar.handleFullCandle(ref barData);
                        rsi.handleFullCandle(ref barData, true, 1);
                        rsi2.handleFullCandle(ref barData, true, 2);
                        rsi3.handleFullCandle(ref barData, true, 3);
                        rsi4.handleFullCandle(ref barData, true, 4);
                        cr.handleFullCandle(ref barData);
                        arbr.handleFullCandle(ref barData, 1);
                        arbr2.handleFullCandle(ref barData, 2);
                        cci.handleFullCandle(ref barData, 1);
                        cci2.handleFullCandle(ref barData, 2);
                        cci3.handleFragCandle(ref barData, 3);
                        wr.handleFullCandle(ref barData, 1);
                        wr2.handleFullCandle(ref barData, 2);
                        lwr.handleFullCandle(ref barData, 0);
                        boll.handleFullCandle(ref barData, 0);
                    }

                    if (dataUnits.ContainsKey(intervSpan))
                    {
                        dataUnits[intervSpan][dataUnits[intervSpan].Count - 1] = (barData);
                    }
                    else
                    {
                        List <BarData> list = new List <BarData>();
                        list.Add(barData);
                        dataUnits.Add(intervSpan, list);
                    }

                    if (provider.CurrentTInterval == intervSpan)
                    {
                        provider.IsUpdateCandle = false;
                        provider.IsAddCandle    = true;
                    }

                    Console.WriteLine(" New BarData  #### time " + currTime);
                    currentTimes[intervSpan] = currTime;
                    Console.WriteLine("  currentTimes[" + intervSpan + "]  " + currentTimes[intervSpan]);
                    Console.WriteLine(" NEW RTD.symbol    time  " + time + " price " + prices[0]);
                    intvData = new IntervalData(0);
                    double p = prices[0];
                    intvData.Max   = p;
                    intvData.Min   = p;
                    intvData.Open  = p;
                    intvData.Close = p;
                    intvData.PriceList.Clear();
                    foreach (double price in prices)
                    {
                        intvData.PriceList.Add(price);
                        intvData.Max = Math.Max(intvData.Max, price);
                        intvData.Min = Math.Min(intvData.Min, price);
                    }

                    barData            = new BarData(currTime, intvData.Open, intvData.Close, intvData.Min, intvData.Max, 0);
                    barData.SignalList = currSignalList;
                    barData.RefreshExValues();


                    if (!provider.Initializing && provider.Initialized)
                    {
                        barData.Sar = sar.getNextSAR();
                        rsi.handleFullCandle(ref barData, false, 1);
                        rsi2.handleFullCandle(ref barData, false, 2);
                        rsi3.handleFullCandle(ref barData, false, 3);
                        rsi4.handleFullCandle(ref barData, false, 4);
                        cr.handleFullCandle(ref barData);
                        cci.handleFragCandle(ref barData, 2);
                        cci2.handleFragCandle(ref barData, 2);


                        iSARs[intervSpan]   = sar;
                        iRISs[intervSpan]   = rsi;
                        iRISs2[intervSpan]  = rsi2;
                        iRISs3[intervSpan]  = rsi3;
                        iRISs4[intervSpan]  = rsi4;
                        iCRs[intervSpan]    = cr;
                        iARBRs[intervSpan]  = arbr;
                        iARBRs2[intervSpan] = arbr2;
                        iCCIs[intervSpan]   = cci;
                        iCCIs2[intervSpan]  = cci2;
                        iCCIs3[intervSpan]  = cci3;
                        iWRs[intervSpan]    = wr;
                        iWRs2[intervSpan]   = wr2;
                        iLWRs[intervSpan]   = lwr;
                        iBOLLs[intervSpan]  = boll;
                    }

                    LogUtil.Info(" New BarData  ####  " + barData);
                    dataUnits[intervSpan].Add(barData);

                    Console.WriteLine(" New  intvData  ############ op " + intvData.Open + " cls " + intvData.Close + "  max  " + intvData.Max + "  low " + intvData.Min);
                    Console.WriteLine("   allDataUnits[provider.Symbol][intervSpan]..Count  ::::::::::::::::::::::::::: " + dataUnits[intervSpan].Count);
                }
                else
                {
                    Console.WriteLine(" IN  currentTimes[" + intervSpan + "]  " + currentTimes[intervSpan]);
                    foreach (double price in prices)
                    {
                        intvData.PriceList.Add(price);
                        intvData.Max = Math.Max(intvData.Max, price);
                        intvData.Min = Math.Min(intvData.Min, price);
                    }
                    Signal[] signals = null;
                    lock (AppConst.SignalDatasLocker)
                    {
                        signals = new Signal[AppContext.SignalDatas.Count];
                        AppContext.SignalDatas.CopyTo(signals);
                    }
                    if (signals != null)
                    {
                        Array.Sort(signals);
                        int count = 0;
                        foreach (Signal s in signals)
                        {
                            if (s.Symbol == provider.Symbol && s.Interval == provider.CurrentTInterval)
                            {
                                if (s.Arrow != 0 && s.ActTime.CompareTo(lastTime) == 0)
                                {
                                    CandleSignal cs = new CandleSignal(s, 1);
                                    if (!intvData.SignalList.Contains(cs))
                                    {
                                        intvData.SignalList.Add(cs);
                                    }
                                }
                                if (s.GainTip != 0 && s.GainTipTime.CompareTo(lastTime) == 0)
                                {
                                    CandleSignal cs = new CandleSignal(s, 2);
                                    if (!intvData.SignalList.Contains(cs))
                                    {
                                        intvData.SignalList.Add(cs);
                                    }
                                }
                                if (s.StopLoss != 0 && s.StopLossTime.CompareTo(lastTime) == 0)
                                {
                                    CandleSignal cs = new CandleSignal(s, 3);
                                    if (!intvData.SignalList.Contains(cs))
                                    {
                                        intvData.SignalList.Add(cs);
                                    }
                                }
                                if (s.StopGain != 0 && s.StopGainTime.CompareTo(lastTime) == 0)
                                {
                                    CandleSignal cs = new CandleSignal(s, 4);
                                    if (!intvData.SignalList.Contains(cs))
                                    {
                                        intvData.SignalList.Add(cs);
                                    }
                                }
                                if (count > 5)
                                {
                                    break;
                                }
                                count++;
                            }
                        }
                    }

                    intvData.Close = intvData.PriceList.Last <double>();

                    //intvData.isInitialized = true;
                    if (provider.CurrentTInterval == intervSpan)
                    {
                        provider.IsUpdateCandle = true;
                        provider.IsAddCandle    = false;
                    }
                    LogUtil.Info(" Updated intvData  ############  " + intvData);
                }
                Console.WriteLine(" Update  intvData  ############ op " + intvData.Open + " cls " + intvData.Close + "  max  " + intvData.Max + "  low " + intvData.Min);
                //}
                //intvData.isUpdated = true;
            }
        }