Метод Chart.Draw(StockSharp.Xaml.Charting.ChartDrawData data)

using System;
using MoreLinq;
using System.Collections.Generic;
using System.Diagnostics;
using System.Windows;
using System.Windows.Media;
using Ecng.Xaml;
using StockSharp.Algo.Strategies;
using StockSharp.Algo.Candles;
using StockSharp.Algo.Indicators;
using StockSharp.Quik;
using StockSharp.TraderConnection;
using StockSharp.Messages;
using StockSharp.Algo;
using StockSharp.Xaml.Charting;
using StockSharp.Logging;
using StockSharp.Xaml;
using Ecng.Serialization;


namespace CandlesChartProject
{

// Изменения в коде относительно видеоурока
// ------------------------------------------------------------------------------------------
// Теперь отрисовка элементов графика выполняется
// при помощи метода Chart.Draw. Методы Chart.ProcessValues и Chart.ProcessCandles - устарели.
// Метод TimeFrame.GetCandleBounds(Security) больше не используется, нужно использовать одну из новых перегрузок
// TimeFrame.GetCandleBounds(DateTime), TimeFrame.GetCandleBounds(DateTime, ExchangeBoard), TimeFrame.GetCandleBounds(DateTime, WorkingTime)

public partial class MainWindow : Window
{
private CandleManager _candleManager;
private CandleSeries _candleSeries;

private ChartArea _chartArea1;
private ChartArea _chartArea2;

private ChartCandleElement _chartCandleElement;
private ChartIndicatorElement _chartIndicatorSmaElement;
private ChartIndicatorElement _chartIndicatorMyElement;
private ChartTradeElement _chartTradeElement;
private ChartOrderElement _chartOrderElement;

private SimpleMovingAverage _indicatorSma;
private MyIndicator _indicatorMy;

private SmaStrategy _smaStrategy;

private ChartDrawData _data;

public MainWindow()
{
InitializeComponent();

ConnectionInterFace.SafeConnection = new SafeConnection(new QuikTrader(QuikTerminal.GetDefaultPath()));

_logmanager.Listeners.Add(new GuiLogListener(_monitor));
_logmanager.Listeners.Add(new FileLogListener("log.txt"));
_logmanager.Sources.Add(ConnectionInterFace.SafeConnection.Trader);
_monitor.Show();
}

MonitorWindow _monitor = new MonitorWindow();
LogManager _logmanager = new LogManager();


private void GetCandlesClick(object sender, RoutedEventArgs e)
{
_chartCandleElement = new ChartCandleElement();
_chartArea1.Elements.Add(_chartCandleElement);

_chartTradeElement = new ChartTradeElement();
_chartArea1.Elements.Add(_chartTradeElement);

_chartOrderElement = new ChartOrderElement();
_chartArea1.Elements.Add(_chartOrderElement);

InitIndicators();

RunProcessGetCandles();

InitStrategy();
}

private void RunProcessGetCandles()
{
_candleManager = new CandleManager(ConnectionInterFace.SafeConnection.Trader);

var security = ConnectionInterFace.SelectedSecurity;

var timeFrame = TimeSpan.FromMinutes(1);

_candleSeries = new CandleSeries(typeof(TimeFrameCandle), security, timeFrame);

_candleManager.Processing += Draw;

_logmanager.Sources.Add(_candleManager);

_candleManager.Start(_candleSeries);
}

private void Draw(CandleSeries series, Candle candle)
{

//--------------
var timeFrame = (TimeSpan) candle.Arg;
            var candleBounds = timeFrame.GetCandleBounds(DateTimeOffset.Now);
//--------------

var valueSma = _indicatorSma.Process(candle);
//var chartValueSma = new ChartIndicatorValue(_indicatorSma, valueSma);

var valueMy = _indicatorMy.Process(candle);
//var chartValueMy = new ChartIndicatorValue(_indicatorMy, valueMy);

//lastCandleTime = candle.CloseTime;



if (candle.State == CandleStates.Finished || candle.OpenTime >= candleBounds.Min)
{
Debug.Print("Candle: {0}", candle);
//var data = new
var dataItem = _data.Group(candle.OpenTime);
dataItem.Add(_chartCandleElement, candle);
dataItem.Add(_chartIndicatorSmaElement, valueSma);
dataItem.Add(_chartIndicatorMyElement, valueMy);

this.GuiAsync(() => Chart.Draw(_data));

//this.GuiAsync(() => Chart.Draw(candle.OpenTime, new Dictionary<IChartElement, object>
// {
// {_chartCandleElement, candle},
// {_chartIndicatorSmaElement, valueSma},
// {_chartIndicatorMyElement, valueMy}
// }));



}
}

private void InitChart()
{
_data = new ChartDrawData();

Chart.IsAutoScroll = true;

_chartArea1 = new ChartArea();
Chart.Areas.Add(_chartArea1);

_chartArea2 = new ChartArea();
Chart.Areas.Add(_chartArea2);
}

private void WindowLoaded(object sender, RoutedEventArgs e)
{
InitChart();
}

private void InitIndicators()
{
_indicatorSma = new SimpleMovingAverage
{
Length = 10
};

_chartIndicatorSmaElement = new ChartIndicatorElement
{
Title = "SMA",
Color = Colors.BlueViolet,
//Indicator = _indicatorSma
};

_chartArea1.Elements.Add(_chartIndicatorSmaElement);


_indicatorMy = new MyIndicator();

_chartIndicatorMyElement = new ChartIndicatorElement
{
Title = "My Indicator",
Color = Colors.Blue,
//Indicator = _indicatorMy
};

_chartArea2.Elements.Add(_chartIndicatorMyElement);
}

private void InitStrategy()
{
_smaStrategy = new SmaStrategy(_indicatorSma, _candleSeries)
{
Connector = ConnectionInterFace.SafeConnection.Trader,
Security = ConnectionInterFace.SelectedSecurity,
Portfolio = ConnectionInterFace.SelectedPortfolio,
Volume = 1
};

_smaStrategy.SetCandleManager(_candleManager);

var timeFrame = TimeSpan.FromMinutes(1);

_smaStrategy.WhenNewMyTrade() //WhenNewMyTrades()
.Do(mytrade => this.GuiAsync(() =>
{
var dataItem = _data.Group(timeFrame.GetCandleBounds(mytrade.Trade.Time.DateTime).Min);
dataItem.Add(_chartTradeElement, mytrade);
//mytrades.ForEach(t =>
//{
// var dataItem = _data.Group(timeFrame.GetCandleBounds(t.Trade.Time.DateTime).Min);
// dataItem.Add(_chartTradeElement, t);
//});
Chart.Draw(_data);
}
)).Apply();

_smaStrategy.WhenOrderRegistered()
.Do(order => this.GuiAsync(() =>
{
var dataItem = _data.Group(order.Time);
dataItem.Add(_chartOrderElement, order);
Chart.Draw(_data);
}))
.Apply();

_logmanager.Sources.Add(_smaStrategy);

_smaStrategy.Start();
}
}
}