private void UpdateRealtimeCandles()
{
if (!_historyLoaded || !_isRealTime)
{
return;
}
var nextTick = (ExecutionMessage)_tradeGenerator.Process(new TimeMessage {
ServerTime = _lastTime
});
if (nextTick != null)
{
if (_candleTransform.Process(nextTick))
{
var candles = _candleBuilder.Process(_mdMsg, _currCandle, _candleTransform);
foreach (var candle in candles)
{
_currCandle = candle;
_updatedCandles.Add((CandleMessage)candle.Clone());
}
}
}
_lastTime += TimeSpan.FromMilliseconds(RandomGen.GetInt(100, 2000));
}
private IEnumerable <CandleMessage> ProcessCandlePart(Level1Fields part, CandleMessage message)
{
_transform.Part = part;
_transform.Process(message);
return(_builder.Process(this, _transform));
}
public override bool MoveNext()
{
while (_finishedCandles.Count == 0)
{
if (!_messagesEnumerator.MoveNext())
{
break;
}
if (!_transform.Process(_messagesEnumerator.Current))
{
continue;
}
_lastActiveCandle = null;
foreach (var candleMessage in _candleBuilder.Process(_mdMsg, _lastCandle, _transform))
{
_lastCandle = candleMessage;
if (candleMessage.State == CandleStates.Finished)
{
_finishedCandles.Add(candleMessage);
}
if (!_onlyFormed)
{
if (candleMessage.State != CandleStates.Finished)
{
_lastActiveCandle = candleMessage;
}
}
}
}
if (_finishedCandles.Count > 0)
{
Current = _finishedCandles[0];
_finishedCandles.RemoveAt(0);
return(true);
}
if (_lastActiveCandle != null)
{
Current = _lastActiveCandle;
_lastActiveCandle = null;
return(true);
}
Current = null;
return(false);
}
private IEnumerable <CandleMessage> ProcessCandlePart(Level1Fields part, CandleMessage message)
{
_transform.Part = part;
_transform.Process(message);
foreach (var builtCandle in _builder.Process(_subscription, _currentCandle, _transform))
{
_currentCandle = builtCandle;
yield return(builtCandle);
}
}
private void LoadData(CandleSeries series)
{
var msgType = series.CandleType.ToCandleMessageType();
_transactionId = _transactionIdGenerator.GetNextId();
_holder.Clear();
_holder.CreateCandleSeries(_transactionId, series);
_candleTransform.Process(new ResetMessage());
_candleBuilder = _builderProvider.Get(msgType.ToCandleMarketDataType());
var storage = new StorageRegistry();
BusyIndicator.IsBusy = true;
var path = HistoryPath.Folder;
var isBuild = BuildFromTicks.IsChecked == true;
var format = Format.SelectedFormat;
var maxDays = (isBuild || series.CandleType != typeof(TimeFrameCandle))
? 2
: 30 * (int)((TimeSpan)series.Arg).TotalMinutes;
_mdMsg = series.ToMarketDataMessage(true);
Task.Factory.StartNew(() =>
{
var date = DateTime.MinValue;
if (isBuild)
{
foreach (var tick in storage.GetTickMessageStorage(series.Security, new LocalMarketDataDrive(path), format).Load())
{
_tradeGenerator.Process(tick);
if (_candleTransform.Process(tick))
{
var candles = _candleBuilder.Process(_mdMsg, _currCandle, _candleTransform);
foreach (var candle in candles)
{
_currCandle = candle;
_updatedCandles.Add((CandleMessage)candle.Clone());
}
}
_lastTime = tick.ServerTime;
if (date != tick.ServerTime.Date)
{
date = tick.ServerTime.Date;
var str = date.To <string>();
this.GuiAsync(() => BusyIndicator.BusyContent = str);
maxDays--;
if (maxDays == 0)
{
break;
}
}
}
}
else
{
foreach (var candleMsg in storage.GetCandleMessageStorage(msgType, series.Security, series.Arg, new LocalMarketDataDrive(path), format).Load())
{
if (candleMsg.State != CandleStates.Finished)
{
candleMsg.State = CandleStates.Finished;
}
_currCandle = candleMsg;
_updatedCandles.Add(candleMsg);
_lastTime = candleMsg.OpenTime;
if (candleMsg is TimeFrameCandleMessage)
{
_lastTime += (TimeSpan)series.Arg;
}
_tradeGenerator.Process(new ExecutionMessage
{
ExecutionType = ExecutionTypes.Tick,
SecurityId = series.Security.ToSecurityId(),
ServerTime = _lastTime,
TradePrice = candleMsg.ClosePrice,
});
if (date != candleMsg.OpenTime.Date)
{
date = candleMsg.OpenTime.Date;
var str = date.To <string>();
this.GuiAsync(() => BusyIndicator.BusyContent = str);
maxDays--;
if (maxDays == 0)
{
break;
}
}
}
}
_historyLoaded = true;
})
.ContinueWith(t =>
{
if (t.Exception != null)
{
Error(t.Exception.Message);
}
BusyIndicator.IsBusy = false;
Chart.IsAutoRange = false;
ModifyAnnotationBtn.IsEnabled = true;
NewAnnotationBtn.IsEnabled = true;
}, TaskScheduler.FromCurrentSynchronizationContext());
}
private void ChartUpdateTimerOnTick(object sender, EventArgs eventArgs)
{
if (_historyLoaded && IsRealtime.IsChecked == true)
{
var nextTick = (ExecutionMessage)_tradeGenerator.Process(new TimeMessage {
ServerTime = _lastTime
});
if (nextTick != null)
{
if (_candleTransform.Process(nextTick))
{
var candles = _candleBuilder.Process(_mdMsg, _currCandle, _candleTransform);
lock (_lock)
{
foreach (var candle in candles)
{
_currCandle = candle;
_updatedCandles[candle.OpenTime] = Tuple.Create(candle, candle.State == CandleStates.Finished);
}
}
}
}
_lastTime += TimeSpan.FromSeconds(RandomGen.GetInt(1, 10));
}
Tuple <Candle, bool>[] candlesToUpdate;
lock (_updatedCandles.SyncRoot)
{
candlesToUpdate = _updatedCandles.OrderBy(p => p.Key).Select(p => Tuple.Create(p.Value.Item1.ToCandle(_security), p.Value.Item2)).ToArray();
_updatedCandles.Clear();
}
var lastCandle = _allCandles.LastOrDefault();
_allCandles.AddRange(candlesToUpdate.Where(c => lastCandle == null || c.Item1.OpenTime != lastCandle.OpenTime).Select(t => t.Item1));
ChartDrawData chartData = null;
foreach (var tuple in candlesToUpdate)
{
var candle = tuple.Item1;
var needToFinish = tuple.Item2;
if (chartData == null)
{
chartData = new ChartDrawData();
}
if (needToFinish && candle.State != CandleStates.Finished)
{
candle.State = CandleStates.Finished;
}
var chartGroup = chartData.Group(candle.OpenTime);
lock (_lock)
{
chartGroup.Add(_candleElement, candle);
}
foreach (var pair in _indicators.CachedPairs)
{
chartGroup.Add(pair.Key, pair.Value.Process(candle));
}
}
if (chartData != null)
{
Chart.Draw(chartData);
}
}
private void LoadData(CandleSeries series)
{
_currCandle = null;
_historyLoaded = false;
_allCandles.Clear();
_candleTransform.Process(new ResetMessage());
_candleBuilder = series.CandleType.ToCandleMessageType().ToCandleMarketDataType().CreateCandleBuilder();
Chart.Reset(new IChartElement[] { _candleElement });
var storage = new StorageRegistry();
BusyIndicator.IsBusy = true;
var path = HistoryPath.Folder;
var isBuild = BuildFromTicks.IsChecked == true;
var format = Format.SelectedFormat;
var maxDays = (isBuild || series.CandleType != typeof(TimeFrameCandle))
? 5
: 30 * (int)((TimeSpan)series.Arg).TotalMinutes;
_mdMsg = series.ToMarketDataMessage(true);
Task.Factory.StartNew(() =>
{
var date = DateTime.MinValue;
if (isBuild)
{
foreach (var tick in storage.GetTickMessageStorage(series.Security, new LocalMarketDataDrive(path), format).Load())
{
_tradeGenerator.Process(tick);
if (_candleTransform.Process(tick))
{
var candles = _candleBuilder.Process(_mdMsg, _currCandle, _candleTransform);
lock (_lock)
{
foreach (var candle in candles)
{
_currCandle = candle;
_updatedCandles[candle.OpenTime] = Tuple.Create(candle, candle.State == CandleStates.Finished);
}
}
}
_lastTime = tick.ServerTime;
if (date != tick.ServerTime.Date)
{
date = tick.ServerTime.Date;
var str = date.To <string>();
this.GuiAsync(() => BusyIndicator.BusyContent = str);
maxDays--;
if (maxDays == 0)
{
break;
}
}
}
}
else
{
foreach (var candleMsg in storage.GetCandleMessageStorage(series.CandleType.ToCandleMessageType(), series.Security, series.Arg, new LocalMarketDataDrive(path), format).Load())
{
lock (_updatedCandles.SyncRoot)
{
_currCandle = candleMsg;
_updatedCandles[candleMsg.OpenTime] = Tuple.Create(candleMsg, true);
}
_lastTime = candleMsg.OpenTime;
if (candleMsg is TimeFrameCandleMessage)
{
_lastTime += (TimeSpan)series.Arg;
}
_tradeGenerator.Process(new ExecutionMessage
{
ExecutionType = ExecutionTypes.Tick,
SecurityId = series.Security.ToSecurityId(),
ServerTime = _lastTime,
TradePrice = candleMsg.ClosePrice,
});
if (date != candleMsg.OpenTime.Date)
{
date = candleMsg.OpenTime.Date;
var str = date.To <string>();
this.GuiAsync(() => BusyIndicator.BusyContent = str);
maxDays--;
if (maxDays == 0)
{
break;
}
}
}
}
_historyLoaded = true;
})
.ContinueWith(t =>
{
if (t.Exception != null)
{
Error(t.Exception.Message);
}
this.GuiAsync(() =>
{
BusyIndicator.IsBusy = false;
Chart.IsAutoRange = false;
//_areaComb.YAxises.First().AutoRange = false;
});
}, TaskScheduler.FromCurrentSynchronizationContext());
}
