Esempio n. 1
0
        public void Initialize()
        {
            Console.WriteLine("Strategy.Sample3.Initialize()");

            strategyHeader = new StrategyHeader(1, "Strategy Sample3",
                                                AppSettings.GetStringValue("Portfolio"),
                                                AppSettings.GetStringValue("Symbol"),
                                                AppSettings.GetValue <double>("Amount"));
            barSettings = new BarSettings(strategyHeader,
                                          strategyHeader.Symbol,
                                          AppSettings.GetValue <int>("Interval"),
                                          AppSettings.GetValue <int>("Period"));

            //Отправляем данные клиентам
            {
                /// отправляем Bar клиентам
                sendItemBar = new SendItemOnBar(barSettings, TradingData.Instance);
                sendItemBar.AddItemHandler(TradeConsole.ConsoleWriteLineBar);
                if (AppSettings.GetValue <bool>("SignalHub"))
                {
                    //отправляем через signalR
                    sendItemBar.AddItemHandler(TradeHubStarter.sendBar);
                }
            }

            //private static ProfitPointsSettings ppSettings =
            //    new ProfitPointsSettings(strategyHeader, AppSettings.GetValue<double>("ProfitPoints"), false);

            //private static TakeProfitOrderSettings poSettings =
            //    new TakeProfitOrderSettings(strategyHeader, 86400);

            //private static StopPointsSettings spSettings =
            //    new StopPointsSettings(strategyHeader, AppSettings.GetValue<double>("StopPoints"), false);

            //private static StopLossOrderSettings soSettings =
            //    new StopLossOrderSettings(strategyHeader, 86400);

            //SmartComHandlers.Instance.Add<_IStClient_DisconnectedEventHandler>(IsDisconnected);
            //SmartComHandlers.Instance.Add<_IStClient_ConnectedEventHandler>(IsConnected);


            AddStrategySettings();
            //TradingData.Instance.Get<ICollection<StrategyHeader>>().Add(strategyHeader);
            //TradingData.Instance.Get<ICollection<BarSettings>>().Add(barSettings);

            AddStrategySubscriptions();
            //DefaultSubscriber.Instance.Portfolios.Add(strategyHeader.Portfolio);
            //DefaultSubscriber.Instance.BidsAndAsks.Add(strategyHeader.Symbol);
            //DefaultSubscriber.Instance.Ticks.Add(strategyHeader.Symbol);
        }
Esempio n. 2
0
        static void Main(string[] args)
        {
            try
            {
                Console.BufferHeight = 300;
                Console.BufferWidth  = 230;

                Console.WindowHeight = 90;
                Console.WindowWidth  = 110;

                Console.WindowTop  = 0;
                Console.WindowLeft = 0;
            }
            catch
            {
                Console.WriteLine(String.Format("Error Console.Window Size"));
            }

            Console.WriteLine(String.Format("Console.BufferHeight {0}", Console.BufferHeight));
            Console.WriteLine(String.Format("Console.BufferWidth {0}", Console.BufferWidth));
            Console.WriteLine(String.Format("Console.WindowHeight {0}", Console.WindowHeight));
            Console.WriteLine(String.Format("Console.WindowWidth {0}", Console.WindowWidth));
            Console.WriteLine(String.Format("Console.WindowTop {0}", Console.WindowTop));
            Console.WriteLine(String.Format("Console.WindowLeft {0}", Console.WindowLeft));

            LogAssemblyInfo();

            //AddStrategySettings();
            {
                TradingData.Instance.Get <ICollection <Strategy> >().Add(strategy);
                TradingData.Instance.Get <ICollection <BarSettings> >().Add(barSettings);
                TradingData.Instance.Get <ICollection <ProfitPointsSettings> >().Add(ppSettings);
                TradingData.Instance.Get <ICollection <TakeProfitOrderSettings> >().Add(poSettings);
                TradingData.Instance.Get <ICollection <StopPointsSettings> >().Add(spSettings);
                TradingData.Instance.Get <ICollection <StopLossOrderSettings> >().Add(soSettings);

                //SMASettings smaSettings = new SMASettings(strategy, 7, 14);
                int         maf         = AppSettings.GetValue <int>("MaFast");
                int         mas         = AppSettings.GetValue <int>("MaSlow");
                SMASettings smaSettings = new SMASettings(strategy, maf, mas);
                TradingData.Instance.Get <ICollection <SMASettings> >().Add(smaSettings);
            }

            ////stopLoss
            //StrategiesPlaceStopLossByPointsOnTradeHandlers stopLossOnTradeHandlers =
            //    new StrategiesPlaceStopLossByPointsOnTradeHandlers(TradingData.Instance,
            //        SignalQueue.Instance,
            //        DefaultLogger.Instance,
            //        AppSettings.GetValue<bool>("MeasureStopFromSignalPrice"));
            ////stopLoss
            //StrategiesStopLossByPointsOnTickHandlers stopLossOnTickHandlers =
            //    new StrategiesStopLossByPointsOnTickHandlers(TradingData.Instance,
            //        SignalQueue.Instance,
            //        DefaultLogger.Instance,
            //        AppSettings.GetValue<bool>("MeasureStopFromSignalPrice"));
            ////takeProfit
            //StrategiesPlaceTakeProfitByPointsOnTradeHandlers takeProfitOnTradeHandlers =
            //    new StrategiesPlaceTakeProfitByPointsOnTradeHandlers(TradingData.Instance,
            //        SignalQueue.Instance,
            //        DefaultLogger.Instance,
            //        AppSettings.GetValue<bool>("MeasureProfitFromSignalPrice"));
            ////takeProfit
            //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(strategy,
            //        TradingData.Instance,
            //        SignalQueue.Instance,
            //        DefaultLogger.Instance);

            //ReversOnTick openHandler =
            //    new ReversOnTick(strategy,
            //        TradingData.Instance,
            //        SignalQueue.Instance,
            //        DefaultLogger.Instance);


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

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

            //отправляем бар через signalR
            SendItemOnBar barItemSender =
                new SendItemOnBar(barSettings,
                                  TradingData.Instance);

            barItemSender.AddItemHandler(TradeHubStarter.sendBar);
            barItemSender.AddItemHandler(ConsoleWriteLineBar);

            ReversOnBar reversHandler =
                new ReversOnBar(strategy,
                                TradingData.Instance,
                                SignalQueue.Instance,
                                DefaultLogger.Instance);

            reversHandler.AddMa1Handler(TradeHubStarter.sendIndicator1);
            reversHandler.AddMa2Handler(TradeHubStarter.sendIndicator2);


            //отправляем бар через signalR
            SendItemOnTrade tradeItemSender =
                new SendItemOnTrade(TradingData.Instance, DefaultLogger.Instance);

            tradeItemSender.AddItemHandler(TradeHubStarter.sendTrade);

            //отправляем ордер через signalR
            //SendItemOnOrder senderItemOrder =
            //    new SendItemOnOrder(TradingData.Instance.Get<ObservableQueue<Order>>());
            //senderItemOrder.AddedItemHandler(TradeHubStarter.sendOrder);

            //список доступных команд
            ConsoleWriteCommands();

            //AddStrategySubscriptions();
            {
                DefaultSubscriber.Instance.Portfolios.Add(strategy.Portfolio);
                DefaultSubscriber.Instance.BidsAndAsks.Add(strategy.Symbol);
                DefaultSubscriber.Instance.Ticks.Add(strategy.Symbol);
            }

            TradeHubStarter tradeHubStarter = new TradeHubStarter();

            //StartServer();
            Task.Run(() => tradeHubStarter.StartServer());
            Console.WriteLine(String.Format("Starting server..."));

            if (AppSettings.GetValue <bool>("ConsoleReadKey"))
            {
                Console.WriteLine(String.Format("Press 's' to start..."));
                while (Console.ReadKey().KeyChar != 's')
                {
                    Console.WriteLine(String.Format("Press 's' to start..."));
                }
            }

            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"));
                        ExportData <Bar>(AppSettings.GetValue <bool>("ExportBarsOnExit"));

                        break;
                    }

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

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

                    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> >().OrderBy(i => i.DateTime))
                        //foreach (Bar item in TradingData.Instance.Get<IEnumerable<Bar>>())
                        {
                            ConsoleWriteLineBar(item);
                            //TradeHubStarter.sendBarString(item);
                            TradeHubStarter.sendBar(item);
                        }
                    }
                    if (command == "c")
                    {
                        //Console.Clear();
                        Console.WriteLine("clearChart");
                        TradeHubStarter.clearChart();
                    }
                    if (command == "h")
                    {
                        Console.Clear();
                        ConsoleWriteCommands();
                    }

                    if (command == "d")
                    {
                        TradeHubStarter.ConsoleWriteTime = !TradeHubStarter.ConsoleWriteTime;
                        Console.WriteLine(String.Format("ConsoleWriteTime {0}",
                                                        TradeHubStarter.ConsoleWriteTime));
                    }
                }
                catch (System.Runtime.InteropServices.COMException e)
                {
                    DefaultLogger.Instance.Log(e.Message);

                    adapter.Restart();
                }
            }
            if (tradeHubStarter.SignalR != null)
            {
                tradeHubStarter.SignalR.Dispose();
            }
        }
Esempio n. 3
0
        /// <summary>
        /// пример
        /// </summary>
        private void SetupRevers()
        {
            //AddStrategySettings();
            {
                TradingData.Instance.Get <ICollection <StrategyHeader> >().Add(strategyHeader);
                TradingData.Instance.Get <ICollection <BarSettings> >().Add(barSettings);

                //TradingData.Instance.Get<ICollection<ProfitPointsSettings>>().Add(ppSettings);
                //TradingData.Instance.Get<ICollection<TakeProfitOrderSettings>>().Add(poSettings);
                //TradingData.Instance.Get<ICollection<StopPointsSettings>>().Add(spSettings);
                //TradingData.Instance.Get<ICollection<StopLossOrderSettings>>().Add(soSettings);

                //SMASettings smaSettings = new SMASettings(strategyHeader, 7, 14);
                int         mafast      = AppSettings.GetValue <int>("MaFast");
                int         maslow      = AppSettings.GetValue <int>("MaSlow");
                SMASettings smaSettings = new SMASettings(strategyHeader, mafast, maslow);
                TradingData.Instance.Get <ICollection <SMASettings> >().Add(smaSettings);
            }

            //SmartComHandlers.Instance.Add<_IStClient_DisconnectedEventHandler>(IsDisconnected);
            //SmartComHandlers.Instance.Add<_IStClient_ConnectedEventHandler>(IsConnected);

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

            SendItemOnBar barItemSender =
                new SendItemOnBar(barSettings,
                                  TradingData.Instance);
            //barItemSender.AddItemHandler(TradeConsole.ConsoleWriteLineBar);

            IndicatorOnBar2Ma indicatorsOnBar =
                new IndicatorOnBar2Ma(strategyHeader,
                                      TradingData.Instance,
                                      SignalQueue.Instance,
                                      DefaultLogger.Instance);

            indicatorsOnBar.AddMa1Handler(TradeConsole.ConsoleWriteLineValueDouble);
            indicatorsOnBar.AddMa2Handler(TradeConsole.ConsoleWriteLineValueDouble);
            indicatorsOnBar.AddCrossUpHandler(TradeConsole.ConsoleWriteLineValueBool);
            indicatorsOnBar.AddCrossDnHandler(TradeConsole.ConsoleWriteLineValueBool);

            ReversMaOnBar reversHandler =
                new ReversMaOnBar(strategyHeader,
                                  TradingData.Instance,
                                  SignalQueue.Instance,
                                  DefaultLogger.Instance)
            {
                IndicatorsOnBar = indicatorsOnBar
            };

            SendItemOnTrade tradeItemSender =
                new SendItemOnTrade(TradingData.Instance, DefaultLogger.Instance);
            //tradeItemSender.AddItemHandler(TradeConsole.ConsoleWriteLineTrade);

            //SendItemOnOrder senderItemOrder =
            //    new SendItemOnOrder(TradingData.Instance.Get<ObservableQueue<Order>>());
            //senderItemOrder.AddedItemHandler(TradeHubStarter.sendOrder);

            //AddStrategySubscriptions();
            {
                DefaultSubscriber.Instance.Portfolios.Add(strategyHeader.Portfolio);
                DefaultSubscriber.Instance.BidsAndAsks.Add(strategyHeader.Symbol);
                DefaultSubscriber.Instance.Ticks.Add(strategyHeader.Symbol);
            }

            //Отправляем данные клиентам
            {
                barItemSender.AddItemHandler(TradeConsole.ConsoleWriteLineBar);
                tradeItemSender.AddItemHandler(TradeConsole.ConsoleWriteLineTrade);
                //senderItemOrder.AddedItemHandler(TradeHubStarter.sendOrder);

                //SetupHubHandlers();
                if (AppSettings.GetValue <bool>("SignalHub"))
                {
                    //отправляем через signalR
                    barItemSender.AddItemHandler(TradeHubStarter.sendBar);
                    tradeItemSender.AddItemHandler(TradeHubStarter.sendTrade);
                    indicatorsOnBar.AddMa1Handler(TradeHubStarter.sendValueDouble1);
                    indicatorsOnBar.AddMa2Handler(TradeHubStarter.sendValueDouble2);
                    indicatorsOnBar.AddCrossUpHandler(TradeHubStarter.sendValueBool);
                    indicatorsOnBar.AddCrossDnHandler(TradeHubStarter.sendValueBool);

                    //reversHandler.AddMa1Handler(TradeHubStarter.sendIndicator1);
                    //reversHandler.AddMa2Handler(TradeHubStarter.sendIndicator2);
                }
            }
        }