/// <summary>
        /// Сэмулировать заявки на истории.
        /// </summary>
        /// <param name="orders">Заявки, которые необходимо сэмулировать на истории.</param>
        /// <param name="storageRegistry">Внешнеее хранилище для доступа к исторических данным.</param>
        /// <param name="openedPositions">Сделки, описывающие начальные открытые позиции.</param>
        /// <returns>Виртуальная стратегии, содержащая в себе ход эмуляционных торгов.</returns>
        public static Strategy EmulateOrders(this IEnumerable <Order> orders, IStorageRegistry storageRegistry, IDictionary <Security, decimal> openedPositions)
        {
            if (openedPositions == null)
            {
                throw new ArgumentNullException("openedPositions");
            }

            if (storageRegistry == null)
            {
                throw new ArgumentNullException("storageRegistry");
            }

            if (orders == null)
            {
                throw new ArgumentNullException("orders");
            }

            if (orders.IsEmpty())
            {
                throw new ArgumentOutOfRangeException("orders");
            }

            using (var connector = new RealTimeEmulationTrader <HistoryEmulationConnector>(new HistoryEmulationConnector(orders.Select(o => o.Security).Distinct(), orders.Select(o => o.Portfolio).Distinct())
            {
                StorageRegistry = storageRegistry
            }))
            {
                var from = orders.Min(o => o.Time).Date;
                var to   = from.EndOfDay();

                var strategy = new EquityStrategy(orders, openedPositions)
                {
                    Connector = connector
                };

                var waitHandle = new SyncObject();

                connector.UnderlyingConnector.StateChanged += () =>
                {
                    if (connector.UnderlyingConnector.State == EmulationStates.Started)
                    {
                        strategy.Start();
                    }

                    if (connector.UnderlyingConnector.State == EmulationStates.Stopped)
                    {
                        strategy.Stop();

                        waitHandle.Pulse();
                    }
                };

                connector.Connect();
                connector.StartExport();

                connector.UnderlyingConnector.Start(from, to);

                lock (waitHandle)
                {
                    if (connector.UnderlyingConnector.State != EmulationStates.Stopped)
                    {
                        waitHandle.Wait();
                    }
                }

                return(strategy);
            }
        }
        private void ConnectClick(object sender, RoutedEventArgs e)
        {
            if (!_isConnected)
            {
                if (_connector == null)
                {
                    if (Login.Text.IsEmpty())
                    {
                        MessageBox.Show(this, LocalizedStrings.Str2974);
                        return;
                    }
                    else if (Password.Password.IsEmpty())
                    {
                        MessageBox.Show(this, LocalizedStrings.Str2975);
                        return;
                    }

                    // создаем подключение
                    _connector = new RealTimeEmulationTrader <Connector>(new SmartTrader
                    {
                        Login    = Login.Text,
                        Password = Password.Password,
                        Address  = Address.SelectedAddress
                    });

                    //_trader = new RealTimeEmulationTrader<Connector>(new StockSharp.Plaza.PlazaTrader
                    //{
                    //	IsCGate = true,
                    //}, portfolio);

                    SecurityEditor.SecurityProvider = new FilterableSecurityProvider(_connector);

                    _logManager.Sources.Add(_connector);

                    // очищаем из текстового поля в целях безопасности
                    //Password.Clear();

                    // подписываемся на событие успешного соединения
                    _connector.Connected += () =>
                    {
                        // возводим флаг, что соединение установлено
                        _isConnected = true;

                        // разблокируем кнопку Экспорт
                        this.GuiAsync(() => ChangeConnectStatus(true));

                        _candleManager = new CandleManager(_connector);

                        _connector.NewMarketDepths     += OnDepths;
                        _connector.MarketDepthsChanged += OnDepths;

                        _connector.NewOrders   += orders => Orders.Orders.AddRange(orders);
                        _connector.NewMyTrades += trades => Trades.Trades.AddRange(trades);

                        // подписываемся на событие о неудачной регистрации заявок
                        _connector.OrdersRegisterFailed += OrdersFailed;

                        _candleManager.Processing += (s, candle) =>
                        {
                            if (candle.State == CandleStates.Finished)
                            {
                                _buffer.Add(candle);
                            }
                        };

                        _connector.StartExport();

                        this.GuiAsync(() =>
                        {
                            ConnectBtn.IsEnabled = false;
                        });
                    };

                    // подписываемся на событие разрыва соединения
                    _connector.ConnectionError += error => this.GuiAsync(() =>
                    {
                        // заблокируем кнопку Экспорт (так как соединение было потеряно)
                        ChangeConnectStatus(false);

                        MessageBox.Show(this, error.ToString(), LocalizedStrings.Str2959);
                    });

                    // подписываемся на ошибку обработки данных (транзакций и маркет)
                    _connector.ProcessDataError += error =>
                                                   this.GuiAsync(() => MessageBox.Show(this, error.ToString(), LocalizedStrings.Str2955));

                    // подписываемся на ошибку подписки маркет-данных
                    _connector.MarketDataSubscriptionFailed += (security, type, error) =>
                                                               this.GuiAsync(() => MessageBox.Show(this, error.ToString(), LocalizedStrings.Str2956Params.Put(type, security)));
                }

                _connector.Connect();
            }
            else
            {
                _connector.Disconnect();
            }
        }