Получение свечки реального времени от Альфа-Директ

using System;
using System.Collections.Generic;
using System.Windows;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Globalization;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Shapes;
using Ecng.Common;
using Ecng.Collections;
using Ecng.ComponentModel;
using Ecng.Xaml;
using StockSharp.Algo.Candles;
using StockSharp.Algo.Indicators;
using StockSharp.Algo.Indicators.Trend;
using StockSharp.BusinessEntities;
using StockSharp.AlfaDirect;
using StockSharp.Logging;
using StockSharp.Xaml;
using StockSharp.Xaml.Charting;

namespace MARKET_SUCCESS_ALFA
{
    /// <summary>
    /// Логика взаимодействия для MainWindow.xaml
    /// </summary>
    public partial class MainWindow
    {
        private AlfaTrader _trader;
        private CandleManager _candleManager;
        private CandleSeries _series;
        private bool _isExportStarted;
        private readonly ObservableCollection<Security> _securitiesSource = new ObservableCollection<Security>();
        private readonly ObservableCollection<Portfolio> _portfoliosSource = new ObservableCollection<Portfolio>();

        private readonly LogManager _logManager = new LogManager();
        private readonly MonitorWindow _monitor = new MonitorWindow();

        //окно для отображения графика со свечками
        private ChartWindow _chartWindow;
        private ChartCandleElement _candlesElem;
        private ChartIndicatorElement _chartBollingerElement; 

        public MainWindow()
        {
            InitializeComponent();

            var items = HistoryInterval.Items;
            items.Add(new ComboBoxItem { Content = "1 минута", Tag = AlfaTimeFrames.Minute1 });
            items.Add(new ComboBoxItem { Content = "5 минут", Tag = AlfaTimeFrames.Minute5 });
            items.Add(new ComboBoxItem { Content = "10 минут", Tag = AlfaTimeFrames.Minute10 });
            items.Add(new ComboBoxItem { Content = "15 минут", Tag = AlfaTimeFrames.Minute15 });
            items.Add(new ComboBoxItem { Content = "30 минут", Tag = AlfaTimeFrames.Minute30 });
            items.Add(new ComboBoxItem { Content = "1 час", Tag = AlfaTimeFrames.Hour });
            items.Add(new ComboBoxItem { Content = "День", Tag = AlfaTimeFrames.Day });
            items.Add(new ComboBoxItem { Content = "Неделя", Tag = AlfaTimeFrames.Week });
            items.Add(new ComboBoxItem { Content = "Месяц", Tag = AlfaTimeFrames.Month });
            items.Add(new ComboBoxItem { Content = "Год", Tag = AlfaTimeFrames.Year });

            HistoryInterval.SelectedIndex = 2;
            
            From.Value = DateTime.Today - TimeSpan.FromDays(7);
            To.Value = DateTime.Today;

            Security.ItemsSource = _securitiesSource;
            Portfolio.ItemsSource = _portfoliosSource;

            _logManager.Listeners.Add(new FileLogListener());
            _logManager.Listeners.Add(new GuiLogListener(_monitor));
            _monitor.Show();
        }

        private void ConnectClick(object sender, RoutedEventArgs e)
        {
            // создаем шлюз
            _trader = new AlfaTrader();

            _logManager.Sources.Add(_trader);

            _trader.ProcessDataError += error => this.GuiAsync(() => MessageBox.Show(this, error.ToString(), "Ошибка обработки данных"));
            _trader.NewSecurities += securities =>
            {
                this.GuiAsync(() => _securitiesSource.AddRange(securities));

                // начинаем получать текущие сделки (для построения свечек в реальном времени)
                securities.ForEach(_trader.RegisterTrades);
            };
            _trader.NewPortfolios += portfolios => this.GuiAsync(() => _portfoliosSource.AddRange(portfolios));
            _trader.Connected += () => this.GuiAsync(() =>
            {
                ExportBtn.IsEnabled = true;
                ConnectBtn.IsEnabled = false;
            });

            _trader.Connect();
        }

        protected override void OnClosing(CancelEventArgs e)
        {
            if (_trader != null)
            {
                if (_isExportStarted)
                    StopExport();

                _logManager.Sources.Remove(_trader);

                _trader.Dispose();
            }

            base.OnClosing(e);
        }

        private void StartExport()
        {
            _isExportStarted = true;
            _trader.StartExport();
        }

        private void StopExport()
        {
            _trader.StopExport();
            _isExportStarted = false;
        }

        private void ExportClick(object sender, RoutedEventArgs e)
        {
            if (_isExportStarted)
                StopExport();
            else
                StartExport();
        }

        private Security SelectedSecurity
        {
            get { return (Security)Security.SelectedValue; }
        }

        private Portfolio SelectedPortfolio
        {
            get { return (Portfolio)Portfolio.SelectedValue; }
        }

        private void SecuritySelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            ShowChart.IsEnabled = SelectedSecurity != null;
        }

        private void PortfolioSelectionChanged(object sender, SelectionChangedEventArgs e)
        {
            TradingBtn.IsEnabled = SelectedPortfolio != null;
        }
        private void ShowChartClick(object sender, RoutedEventArgs e)
        {
            var security = SelectedSecurity;

            var timeFrame = (AlfaTimeFrames)((ComboBoxItem)HistoryInterval.SelectedItem).Tag;

            if (From.Value != null)
            {
                var from = From.Value.Value;
                if (To.Value != null)
                {
                    var to = To.Value.Value;

                    if (@from > to)
                    {
                        return;
                    }

                    var candles = _trader.GetHistoryData(security, timeFrame, new Range<DateTime>(@from, to));
                    
                    _chartWindow = new ChartWindow
                    {
                        Title = "{0}, {1}, {2} - {3}".Put(security.Code,
                                                          ((ComboBoxItem)HistoryInterval.SelectedItem).Content,
                                                          @from.ToString(CultureInfo.InvariantCulture), to.ToString(CultureInfo.InvariantCulture))
                    };

                    var area = new ChartArea();
                    _chartWindow.Chart.ChartTheme = "ExpressionDark";
                    _chartWindow.Chart.IsAutoScroll = true;
                    _chartWindow.Chart.Areas.Add(area);

                    _candlesElem = new ChartCandleElement
                    {
                        Antialiasinig = false,
                        UpBodyColor = Colors.Chartreuse,
                        UpWickColor = Colors.Chartreuse,
                        DownBodyColor = Colors.Red,
                        DownWickColor = Colors.Red,
                        IsLegend = true,
                    };

                    _chartBollingerElement = new ChartIndicatorElement
                    {
                        Antialiasinig = false,
                        Color = Colors.DeepSkyBlue,
                        IsLegend = true,
                        Indicator = new BollingerBands
                        {
                            Length = 20,
                            Width = 2
                        },
                        Title = "Bollinger Bands",
                        DrawStyle = ChartIndicatorDrawStyles.Line,
                    };
                    _chartBollingerElement.DrawTemplate.VisualTree.SetValue(Shape.FillProperty, new SolidColorBrush(Colors.DeepSkyBlue));

                    area.Elements.Add(_candlesElem);
                    area.Elements.Add(_chartBollingerElement);

                    this.GuiAsync(() => DrawCandles(candles));

                    _candleManager = new CandleManager(_trader);
                    
                    _series = new CandleSeries(typeof(TimeFrameCandle), security, timeFrame);
                    
                    _series.ProcessCandle += Draw;
                    
                    _candleManager.Start(_series);

                    _chartWindow.Show();
                }
            }
        }

        private void DrawCandles(IEnumerable<Candle> candles)
        {
            foreach (var candle in candles)
                _chartWindow.Chart.ProcessCandle(_candlesElem, candle);
        }

        private void Draw(Candle candle)
        {
            if (candle.State == CandleStates.Finished || candle.State == CandleStates.Changed)
            {
                var final = candle.State == CandleStates.Finished;
                
                var val = _chartBollingerElement.Indicator.Process(new DecimalIndicatorValue(candle.ClosePrice) {IsFinal = final});
                var bollingerValue = new ChartIndicatorValue(_chartBollingerElement.Indicator, val);
                
                var timeFrame = (TimeSpan)_series.Arg;
                var time = timeFrame.GetCandleBounds(_series.Security).Min - timeFrame;

                if (candle.State == CandleStates.Finished || (candle.State == CandleStates.Changed && candle.OpenTime >= time))
                {
                    this.GuiAsync(() => _chartWindow.Chart.ProcessValues(candle.OpenTime, new Dictionary<IChartElement, object>
                                                                                          {
                                                                                              {_candlesElem, candle},
                                                                                              {_chartBollingerElement, bollingerValue},
                                                                                          }));
                }
            }
        }
    }
}

private void ShowChartClick(object sender, RoutedEventArgs e)
        {
            try
            {
                var security = SelectedSecurity;
                
                var timeFrame = (AlfaTimeFrames)((ComboBoxItem)HistoryInterval.SelectedItem).Tag;
                                
                if (From.Value != null)
                {
                    var from = From.Value.Value;
                    if (To.Value != null)
                    {
                        var to = To.Value.Value;
                
                        if (@from > to)
                        {
                            return;
                        }
                
                        var candles = _trader.GetHistoryData(security, timeFrame, new Range<DateTime>(@from, to));
                        
                        _chartWindow = new ChartWindow
                        {
                            Title = "{0}, {1}, {2} - {3}".Put(security.Code,
                                                              ((ComboBoxItem)HistoryInterval.SelectedItem).Content,
                                                              @from.ToString(CultureInfo.InvariantCulture),                                                                      to.ToString(CultureInfo.InvariantCulture))
                        };

                        this.GuiAsync(() => 
                            {
                                foreach (var candle in candles)
                                    _chartWindow.Chart.ProcessCandle(_candlesElem, candle);
                            });
                
                        _candleManager = new CandleManager(_trader);
                
                        _series = new CandleSeries(typeof(TimeFrameCandle), security, (TimeSpan)AlfaTimeFrames.Minute10);
                        
                        _series.ProcessCandle += candle =>
                            {
                                if (candle.State == CandleStates.Finished)
                                {
                                    var val = _chartBollingerElement.Indicator.Process(new DecimalIndicatorValue(candle.ClosePrice));
                                    var bollingerValue = new ChartIndicatorValue(_chartBollingerElement.Indicator, val);
                                    this.GuiAsync(() => _chartWindow.Chart.ProcessValues(candle.OpenTime, new Dictionary<IChartElement, object>
                                                                                          {
                                                                                              {_candlesElem, candle},
                                                                                              {_chartBollingerElement, bollingerValue},
                                                                                          }));
                                }
                            };
                        
                        _candleManager.Start(_series);
                
                        _chartWindow.Show();
                    }
                }
            }
            catch (Exception exc)
            {
                MessageBox.Show(exc.ToString());
            }
        }