コード例 #1
0
 public static TimeSpan PeriodTimeSpan(MT4Bridge.PeriodType period)
 {
     if ((int)period < 60)
     {
         return(TimeSpan.FromMinutes((int)period));
     }
     else if ((int)period < 1440)
     {
         return(TimeSpan.FromHours((int)period));
     }
     else if ((int)period == 1440)
     {
         return(TimeSpan.FromDays(1));
     }
     else if ((int)period == 10080)
     {
         return(TimeSpan.FromDays(7));
     }
     else
     {
         return(TimeSpan.FromDays(30));
     }
 }
コード例 #2
0
        /// <summary>
        /// Copies data to Data and calculates.
        /// </summary>
        void SetDataAndCalculate(string symbol, MT4Bridge.PeriodType period, DateTime time, bool isPriceChange, bool isUpdateData)
        {
            lock (lockerDataFeed)
            {
                bool isUpdateChart = isUpdateData;

                MT4Bridge.Bars bars = bridge.GetBars(symbol, period);

                if (bars == null && JournalShowSystemMessages)
                {
                    isSetRootDataError = true;
                    Data.SoundError.Play();
                    JournalMessage jmsg = new JournalMessage(JournalIcons.Error, DateTime.Now,
                                                             symbol + " " + period.ToString() + " " + Language.T("Cannot receive bars!"));
                    AppendJournalMessage(jmsg);
                    return;
                }
                if (bars.Count < MaxBarsCount((int)period) && JournalShowSystemMessages)
                {
                    isSetRootDataError = true;
                    Data.SoundError.Play();
                    JournalMessage jmsg = new JournalMessage(JournalIcons.Error, DateTime.Now,
                                                             symbol + " " + period.ToString() + " " + Language.T("Cannot receive enough bars!"));
                    AppendJournalMessage(jmsg);
                    return;
                }
                if (isSetRootDataError && JournalShowSystemMessages)
                {
                    isSetRootDataError = false;
                    JournalMessage jmsg = new JournalMessage(JournalIcons.Information, DateTime.Now,
                                                             symbol + " " + period.ToString() + " " + Language.T("Enough bars received!"));
                    AppendJournalMessage(jmsg);
                }

                int countBars = bars.Count;

                if (countBars < 400)
                {
                    return;
                }

                if (Data.Bars != countBars || Data.Time[countBars - 1] != bars.Time[countBars - 1] ||
                    Data.Volume[countBars - 1] != bars.Volume[countBars - 1] || Data.Close[countBars - 1] != bars.Close[countBars - 1])
                {
                    if (Data.Bars == countBars && Data.Time[countBars - 1] == bars.Time[countBars - 1] && Data.Time[countBars - 10] == bars.Time[countBars - 10])
                    {   // Update the last bar only.
                        Data.Open  [countBars - 1] = bars.Open  [countBars - 1];
                        Data.High  [countBars - 1] = bars.High  [countBars - 1];
                        Data.Low   [countBars - 1] = bars.Low   [countBars - 1];
                        Data.Close [countBars - 1] = bars.Close [countBars - 1];
                        Data.Volume[countBars - 1] = bars.Volume[countBars - 1];
                    }
                    else
                    {   // Update all the bars.
                        Data.Bars   = countBars;
                        Data.Time   = new DateTime[countBars];
                        Data.Open   = new double[countBars];
                        Data.High   = new double[countBars];
                        Data.Low    = new double[countBars];
                        Data.Close  = new double[countBars];
                        Data.Volume = new int[countBars];
                        bars.Time.CopyTo(Data.Time, 0);
                        bars.Open.CopyTo(Data.Open, 0);
                        bars.High.CopyTo(Data.High, 0);
                        bars.Low.CopyTo(Data.Low, 0);
                        bars.Close.CopyTo(Data.Close, 0);
                        bars.Volume.CopyTo(Data.Volume, 0);
                    }

                    // Calculate the strategy indicators.
                    CalculateStrategy(true);
                    isUpdateChart = true;
                }

                bool isBarChanged = IsBarChanged(Data.Time[Data.Bars - 1]);

                if (isTrading)
                {
                    TickType tickType = GetTickType((DataPeriods)(int)period, Data.Time[Data.Bars - 1], time, Data.Volume[Data.Bars - 1]);

                    if (tickType == TickType.Close || isPriceChange || isBarChanged)
                    {
                        if (JournalShowSystemMessages && tickType != TickType.Regular)
                        {
                            JournalIcons icon = JournalIcons.Warning;
                            string       text = string.Empty;
                            if (tickType == TickType.Open)
                            {
                                icon = JournalIcons.BarOpen;
                                text = Language.T("A Bar Open event!");
                            }
                            else if (tickType == TickType.Close)
                            {
                                icon = JournalIcons.BarClose;
                                text = Language.T("A Bar Close event!");
                            }
                            else if (tickType == TickType.AfterClose)
                            {
                                icon = JournalIcons.Warning;
                                text = Language.T("A new tick arrived after a Bar Close event!");
                            }
                            JournalMessage jmsg = new JournalMessage(icon, DateTime.Now, symbol + " " + Data.PeriodMTStr + " " + time.ToString("HH:mm:ss") + " " + text);
                            AppendJournalMessage(jmsg);
                        }

                        if (isBarChanged && tickType == TickType.Regular)
                        {
                            if (JournalShowSystemMessages)
                            {
                                JournalMessage jmsg = new JournalMessage(JournalIcons.Warning, DateTime.Now, symbol + " " +
                                                                         Data.PeriodMTStr + " " + time.ToString("HH:mm:ss") + " A Bar Changed event!");
                                AppendJournalMessage(jmsg);
                            }

                            tickType = TickType.Open;
                        }

                        if (tickType == TickType.Open && barOpenTimeForLastCloseEvent == Data.Time[Data.Bars - 3])
                        {
                            if (JournalShowSystemMessages)
                            {
                                JournalMessage jmsg = new JournalMessage(JournalIcons.Warning, DateTime.Now, symbol + " " +
                                                                         Data.PeriodMTStr + " " + time.ToString("HH:mm:ss") + " A secondary Bar Close event!");
                                AppendJournalMessage(jmsg);
                            }
                            tickType = TickType.OpenClose;
                        }

                        CalculateTrade(tickType);
                        isUpdateChart = true;

                        if (tickType == TickType.Close || tickType == TickType.OpenClose)
                        {
                            barOpenTimeForLastCloseEvent = Data.Time[Data.Bars - 1];
                        }
                    }
                }

                if (isUpdateChart)
                {
                    UpdateChart();
                }
            }

            return;
        }