Урок 4. Свечи, графики, история

private void ChartButton_Click(object sender, RoutedEventArgs e)
        {
                
                if (TpTimeFrame.Value == null)
                {
                    MessageBox.Show("Введите значение таймфрейм");
                    return;
                }
                
                var timeFrame = TpTimeFrame.Value.Value.TimeOfDay;
                
                GetHistoryCandles();???????
                
                RunProcessGetCandles(timeFrame);
                ChartButton.Content = "Очистить график";
         }
        /// <summary>
        /// Исторические свечки
        /// </summary>
        /// <returns>Коллекция свечей</returns>
        private IEnumerable<Candle> GetHistoryCandles()
        {
            try
            {
                if (SourceHistoryComboBox.SelectedIndex == 0)
                {
                   //закачка с сайта финама
                   return Finam.History.GetHistoryCandles(
                       ConnectionInterface.SelectedSecurity,
                       TpTimeFrame.Value.Value.TimeOfDay,
                       BeginDataPicker.SelectedDate.Value,
                       EndDataPicker.SelectedDate.Value);
                }
                else
                return new Candle[0];
            }
            catch (Exception ex)
            {
                MessageBox.Show("Unable to retrive historical candles. " + ex.Message);
                return new Candle[0];
            }
        }
         
        /// <summary>
        /// Метод инициирования среды для получения свечей и дальнейшей отрисовки
        /// </summary>
        /// <param name="timeFrame">Тайм-фрейм для свечей</param>
        private void RunProcessGetCandles(TimeSpan timeFrame)
        {
            _candleManager = new CandleManager(ConnectionInterface.SafeConnection.Trader);

            var security = ConnectionInterface.SelectedSecurity;

            var series = new CandleSeries(typeof(TimeFrameCandle), security, timeFrame);
            series.WorkingTime.Times[0].Min = TimeSpan.FromHours(0);
            series.WorkingTime.Times[0].Max = TimeSpan.FromHours(23);
            
            _candleManager.Processing += ProcessCandle;
            
            _candleManager.Start(series);
        }

        private void ProcessCandle(CandleSeries series, Candle candle)
        {
            try
            {
                if (candle.State == CandleStates.Finished)
                {
                    var valueSar = _chartParabolicElement.Indicator.Process(new CandleIndicatorValue(candle) { IsFinal = true });
                    var valueBb = _chartBollingerElement.Indicator.Process(new CandleIndicatorValue(candle) { IsFinal = true });
                    this.GuiAsync(() => Chart.ProcessValues(candle.OpenTime, new Dictionary<IChartElement, object>
                {
                    {_chartCandleElement, candle},
                    {_chartParabolicElement, new ChartIndicatorValue(_chartParabolicElement.Indicator, valueSar)},
                    {_chartBollingerElement, new ChartIndicatorValue(_chartBollingerElement.Indicator, valueBb)}
                }));
                }
                else
                {
                    this.GuiAsync(() => Chart.ProcessCandle(_chartCandleElement, candle));
                }
            }
            catch (Exception exc)
            {
                MessageBox.Show(exc.ToString());
            }
        }

private IEnumerable<Candle> GetHistoryCandles1()
        {
            try
            {
                    //закачка с сайта финама
                    if (TpTimeFrame1.Value != null)
                        if (BeginDataPicker.SelectedDate != null)
                            if (EndDataPicker.SelectedDate != null)
                                return Finam.History.GetHistoryCandles(
                                    ConnectionInterface.SelectedSecurity,
                                    TpTimeFrame1.Value.Value.TimeOfDay,
                                    BeginDataPicker.SelectedDate.Value,
                                    EndDataPicker.SelectedDate.Value);
            }
            catch (Exception ex)
            {
                MessageBox.Show("Unable to retrive historical candles. " + ex.Message);
                return new Candle[0];
            }
            return null;
        }
private IEnumerable<Candle> GetHistoryCandles2()
        {
            try
            {
                //закачка с сайта финама
                if (TpTimeFrame2.Value != null)
                    if (BeginDataPicker.SelectedDate != null)
                        if (EndDataPicker.SelectedDate != null)
                            return Finam.History.GetHistoryCandles(
                                ConnectionInterface.SelectedSecurity,
                                TpTimeFrame2.Value.Value.TimeOfDay,
                                BeginDataPicker.SelectedDate.Value,
                                EndDataPicker.SelectedDate.Value);
            }
            catch (Exception ex)
            {
                MessageBox.Show("Unable to retrive historical candles. " + ex.Message);
                return new Candle[0];
            }
            return null;
        }

    public class History : FinamHistorySource
    {
        public History(ISecurityStorage securityStorage) : base(securityStorage)
        {
        }

        /// <summary>
        /// Все инструменты у источника финама
        /// </summary>
        private IEnumerable<FinamSecurityInfo> Securities { get { return DownloadSecurityInfo(); } }
        public IEnumerable<Candle> GetHistoryCandles(Security security, TimeSpan timeFrame, DateTime from, DateTime to)
        {
            //находим финамовский инструмент по коду инструмента
            var fi = Securities.FirstOrDefault(f => f.Code == security.Code);

            var marketId = new KeyValuePair<object, object>(FinamMarketIdField, fi.FinamMarketId);
            var securityId = new KeyValuePair<object, object>(FinamSecurityIdField, fi.FinamSecurityId);

            if (!security.ExtensionInfo.Contains(marketId) && !security.ExtensionInfo.Contains(securityId))
            {
                //добавляем дополнительную информацию в инструмент, чтобы получить свечки через основной метод GetCandles()
                security.ExtensionInfo.Add(marketId); //идентификатор секции рынка
                security.ExtensionInfo.Add(securityId); //идентификатор инструмента
            }

            //запрашиваем свечки
            return GetCandles(security, from, to, timeFrame);
        }

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 obj)
        {
            if (obj.State == CandleStates.Finished || obj.State == CandleStates.Changed)
            {
                var final = obj.State == CandleStates.Finished;

                //значения у индикаторов в данный момент времени(finished,changed)

                var val = _chartBollingerElement.Indicator.Process(new DecimalIndicatorValue(obj.ClosePrice) {IsFinal = final});
                var bollingerValue = new ChartIndicatorValue(_chartBollingerElement.Indicator, val);
                //определеяем время последней свечки
                var timeFrame = (TimeSpan)_series.Arg;
                var time = timeFrame.GetCandleBounds(_series.Security).Min - timeFrame;

                //добавляем свечки и график индикаторов на чарт
                if (obj.State == CandleStates.Finished || (obj.State == CandleStates.Changed && obj.OpenTime >= time))
                {
                    this.GuiAsync(() => _chartWindow.Chart.ProcessValues(obj.OpenTime, new Dictionary<IChartElement, object>
                                                                                          {
                                                                                              {_candlesElem, obj},
                                                                                              {_chartBollingerElement, bollingerValue},
                                                                                          }));
                }
            }
        }
    }
}