コード例 #1
0
        public void Handlers_Make_First_Bar_For_Hour()
        {
            StrategyHeader s           = new StrategyHeader(1, "Strategy 1", "BP12345-RF-01", "RTS-12.12_FT", 10);
            BarSettings    barSettings = new BarSettings(s, "RTS-12.12_FT", 3600, 19);

            DateTime start = new DateTime(2013, 5, 15, 10, 0, 0);

            FakeTimeTracker tt = new FakeTimeTracker(start, start);

            UpdateBarsOnTick updateBars = new UpdateBarsOnTick(barSettings, tt, this.tradingData, new NullLogger());

            Assert.AreEqual(0, this.tradingData.Get <ObservableCollection <Bar> >().Count);


            for (int i = 0; i < barSettings.Interval; i++)
            {
                this.tradingData.Get <ObservableCollection <Tick> >().Add(new Tick {
                    DateTime = start.AddSeconds(i), Symbol = "RTS-12.12_FT", Price = 150000 + i, TradeAction = TradeAction.Buy, Volume = 100
                });

                if (i == 1000)
                {
                    this.tradingData.Get <ObservableCollection <Tick> >().Add(new Tick {
                        DateTime = start.AddSeconds(1000), Symbol = "RTS-12.12_FT", Price = 149000, TradeAction = TradeAction.Buy, Volume = 100
                    });
                    this.tradingData.Get <ObservableCollection <Tick> >().Add(new Tick {
                        DateTime = start.AddSeconds(2000), Symbol = "RTS-12.12_FT", Price = 154500, TradeAction = TradeAction.Buy, Volume = 100
                    });
                }

                tt.IncrementStopDate(1);
            }

            this.tradingData.Get <ObservableCollection <Tick> >().Add(new Tick {
                DateTime = start.AddSeconds(-1), Symbol = "RTS-12.12_FT", Price = 148000, TradeAction = TradeAction.Buy, Volume = 100
            });
            Assert.AreEqual(0, this.tradingData.Get <ObservableCollection <Bar> >().Count);

            this.tradingData.Get <ObservableCollection <Tick> >().Add(new Tick {
                DateTime = start.AddSeconds(3600), Symbol = "RTS-12.12_FT", Price = 155500, TradeAction = TradeAction.Buy, Volume = 100
            });
            Assert.AreEqual(1, this.tradingData.Get <ObservableCollection <Bar> >().Count);


            Bar bar = this.tradingData.Get <ObservableCollection <Bar> >().First();

            Assert.AreEqual("RTS-12.12_FT", bar.Symbol);
            Assert.AreEqual(start.AddHours(1), bar.DateTime);
            Assert.AreEqual(149000, bar.Low);
            Assert.AreEqual(154500, bar.High);
            Assert.AreEqual(150000, bar.Open);
            Assert.AreEqual(153599, bar.Close);
            Assert.AreEqual(360200, bar.Volume);
        }
コード例 #2
0
        public void Handlers_make_bar_for_one_strategy_test()
        {
            StrategyHeader strategyHeader = new StrategyHeader(2, "Strategy 2", "BP12345-RF-01", "RTS-9.13_FT", 10);

            this.tradingData.Get <ObservableHashSet <StrategyHeader> >().Add(strategyHeader);

            BarSettings barSettings = new BarSettings(strategyHeader, strategyHeader.Symbol, 60, 0);

            this.tradingData.Get <ObservableHashSet <BarSettings> >().Add(barSettings);

            DateTime start = new DateTime(2013, 7, 10, 10, 0, 0, 0);

            FakeTimeTracker ftt = new FakeTimeTracker(start, start);

            UpdateBarsOnTick handler = new UpdateBarsOnTick(barSettings, ftt, this.tradingData, new NullLogger());

            Assert.AreEqual(0, this.tradingData.Get <ObservableCollection <Bar> >().Count);

            this.tradingData.Get <ObservableCollection <Tick> >().Add(new Tick(barSettings.Symbol, start.AddMilliseconds(-500), 150000, 25));

            for (int i = 0; i < barSettings.Interval * 2; i++)
            {
                this.tradingData.Get <ObservableCollection <Tick> >().Add(new Tick(barSettings.Symbol, start.AddMilliseconds(i * 500), 150000, 25));
            }

            ftt.IncrementStopDate(barSettings.Interval);

            Assert.AreEqual(121, this.tradingData.Get <ObservableCollection <Tick> >().Count);
            Assert.AreEqual(new DateTime(2013, 7, 10, 10, 0, 59, 500), this.tradingData.Get <ObservableCollection <Tick> >().Last().DateTime);
            Assert.AreEqual(0, this.tradingData.Get <ObservableCollection <Bar> >().Count);

            this.tradingData.Get <ObservableCollection <Tick> >().Add(new Tick(barSettings.Symbol, new DateTime(2013, 7, 10, 10, 0, 59, 600), 151000, 25));
            this.tradingData.Get <ObservableCollection <Tick> >().Add(new Tick(barSettings.Symbol, new DateTime(2013, 7, 10, 10, 0, 59, 700), 149000, 25));
            this.tradingData.Get <ObservableCollection <Tick> >().Add(new Tick(barSettings.Symbol, new DateTime(2013, 7, 10, 10, 0, 59, 800), 150000, 25));
            this.tradingData.Get <ObservableCollection <Tick> >().Add(new Tick(barSettings.Symbol, new DateTime(2013, 7, 10, 10, 0, 59, 900), 149500, 25));
            Assert.AreEqual(0, this.tradingData.Get <ObservableCollection <Bar> >().Count);

            // Обработчик генерирует новый бар, только когда время пришедшего тика располагается в диапазоне следующего бара.
            this.tradingData.Get <ObservableCollection <Tick> >().Add(new Tick(barSettings.Symbol, new DateTime(2013, 7, 10, 10, 1, 0, 0), 150000, 25));
            Assert.AreEqual(1, this.tradingData.Get <ObservableCollection <Bar> >().Count);

            Bar bar = this.tradingData.Get <ObservableCollection <Bar> >().Last();

            Assert.AreEqual(start.AddSeconds(60), bar.DateTime);
            Assert.AreEqual(barSettings.Symbol, bar.Symbol);
            Assert.AreEqual(barSettings.Interval, bar.Interval);
            Assert.AreEqual(150000, bar.Open);
            Assert.AreEqual(151000, bar.High);
            Assert.AreEqual(149000, bar.Low);
            Assert.AreEqual(149500, bar.Close);
            Assert.AreEqual(3100, bar.Volume);
        }
コード例 #3
0
ファイル: Proboy.cs プロジェクト: w1r2p1/TRx
        static void Main(string[] args)
        {
            LogAssemblyInfo();

            AddStrategySettings();

            StrategiesPlaceStopLossByPointsOnTradeHandlers stopLossOnTradeHandlers =
                new StrategiesPlaceStopLossByPointsOnTradeHandlers(TradingData.Instance,
                                                                   SignalQueue.Instance,
                                                                   DefaultLogger.Instance,
                                                                   AppSettings.GetValue <bool>("MeasureStopFromSignalPrice"));

            StrategiesStopLossByPointsOnTickHandlers stopLossOnTickHandlers =
                new StrategiesStopLossByPointsOnTickHandlers(TradingData.Instance,
                                                             SignalQueue.Instance,
                                                             DefaultLogger.Instance,
                                                             AppSettings.GetValue <bool>("MeasureStopFromSignalPrice"));

            StrategiesPlaceTakeProfitByPointsOnTradeHandlers takeProfitOnTradeHandlers =
                new StrategiesPlaceTakeProfitByPointsOnTradeHandlers(TradingData.Instance,
                                                                     SignalQueue.Instance,
                                                                     DefaultLogger.Instance,
                                                                     AppSettings.GetValue <bool>("MeasureProfitFromSignalPrice"));

            StrategiesTakeProfitByPointsOnTickHandlers takeProfitOnTickHandlers =
                new StrategiesTakeProfitByPointsOnTickHandlers(TradingData.Instance,
                                                               SignalQueue.Instance,
                                                               DefaultLogger.Instance,
                                                               AppSettings.GetValue <bool>("MeasureProfitFromSignalPrice"));

            SmartComHandlers.Instance.Add <_IStClient_DisconnectedEventHandler>(ScalperIsDisconnected);
            SmartComHandlers.Instance.Add <_IStClient_ConnectedEventHandler>(ScalperIsConnected);

            BreakOutOnTick openHandler =
                new BreakOutOnTick(strategyHeader,
                                   TradingData.Instance,
                                   SignalQueue.Instance,
                                   DefaultLogger.Instance);

            UpdateBarsOnTick updateBarsHandler =
                new UpdateBarsOnTick(barSettings,
                                     new TimeTracker(),
                                     TradingData.Instance,
                                     DefaultLogger.Instance);

            AddStrategySubscriptions();

            adapter.Start();

            while (true)
            {
                try
                {
                    string command = Console.ReadLine();

                    if (command == "x")
                    {
                        adapter.Stop();

                        ExportData <Order>(AppSettings.GetValue <bool>("ExportOrdersOnExit"));
                        ExportData <Trade>(AppSettings.GetValue <bool>("ExportTradesOnExit"));

                        break;
                    }

                    if (command == "p")
                    {
                        Console.Clear();

                        Console.WriteLine(String.Format("Реализованный профит и лосс составляет {0} пунктов",
                                                        TradingData.Instance.GetProfitAndLossPoints(strategyHeader)));
                    }

                    if (command == "t")
                    {
                        Console.Clear();

                        foreach (Trade item in TradingData.Instance.Get <IEnumerable <Trade> >())
                        {
                            Console.WriteLine(item.ToString());
                        }
                    }

                    if (command == "b")
                    {
                        Console.Clear();

                        foreach (Bar item in TradingData.Instance.Get <IEnumerable <Bar> >())
                        {
                            Console.WriteLine(item.ToString());
                        }
                    }
                }
                catch (System.Runtime.InteropServices.COMException e)
                {
                    DefaultLogger.Instance.Log(e.Message);

                    adapter.Restart();
                }
            }
        }