public ChartWindow(CandleSeries candleSeries, DateTime from, DateTime to) { InitializeComponent(); if (candleSeries == null) throw new ArgumentNullException("candleSeries"); _candleSeries = candleSeries; _trader = MainWindow.Instance.Trader; Chart.ChartTheme = "ExpressionDark"; var area = new ChartArea(); Chart.Areas.Add(area); _candleElem = new ChartCandleElement { Antialiasing = false, UpFillColor = Colors.White, UpBorderColor = Colors.Black, DownFillColor = Colors.Black, DownBorderColor = Colors.Black, }; area.Elements.Add(_candleElem); _trader.NewCandles += ProcessNewCandles; _trader.SubscribeCandles(_candleSeries, from, to); }
public ChartWindow(CandleSeries candleSeries) { InitializeComponent(); if (candleSeries.IsNull()) throw new ArgumentNullException("candleSeries"); _candleSeries = candleSeries; _trader = MainWindow.Instance.Trader; Chart.ChartTheme = "ExpressionDark"; var area = new ChartArea(); Chart.Areas.Add(area); _candleElem = new ChartCandleElement { Antialiasing = false, UpFillColor = Colors.White, UpBorderColor = Colors.Black, DownFillColor = Colors.Black, DownBorderColor = Colors.Black, }; area.Elements.Add(_candleElem); _trader.NewCandles += ProcessNewCandles; _trader.SubscribeCandles(_candleSeries, DateTime.Today - TimeSpan.FromTicks(((TimeSpan)candleSeries.Arg).Ticks * 100), DateTimeOffset.MaxValue); }
public SmaStrategy(CandleSeries series, SimpleMovingAverage longSma, SimpleMovingAverage shortSma) { _series = series; LongSma = longSma; ShortSma = shortSma; }
private void OnChartPanelSubscribeCandleElement(ChartCandleElement element, CandleSeries candleSeries) { _drawTimer.Cancel(); _elements.Add(new RefPair<IChartElement, int>(element, 0)); _drawTimer.Activate(); }
/// <summary> /// Subscribe to receive new candles. /// </summary> /// <param name="series">Candles series.</param> /// <param name="from">The initial date from which you need to get data.</param> /// <param name="to">The final date by which you need to get data.</param> public void SubscribeCandles(CandleSeries series, DateTimeOffset from, DateTimeOffset to) { if (series == null) throw new ArgumentNullException("series"); if (series.CandleType != typeof(TimeFrameCandle)) throw new ArgumentException(LocalizedStrings.NotSupportCandle.Put("OANDA", series.CandleType), "series"); if (!(series.Arg is TimeSpan)) throw new ArgumentException(LocalizedStrings.WrongCandleArg.Put(series.Arg), "series"); var transactionId = TransactionIdGenerator.GetNextId(); _series.Add(transactionId, series); SendInMessage(new MarketDataMessage { TransactionId = transactionId, DataType = MarketDataTypes.CandleTimeFrame, //SecurityId = GetSecurityId(series.Security), Arg = series.Arg, IsSubscribe = true, From = from, To = to, }.FillSecurityInfo(this, series.Security)); }
public void UnsubscribeCandles(CandleSeries series) { var key = new SubscriptionKey(series.Security.Id, (TimeSpan) series.Arg); var subscription = _candleSubscriptions.TryGetValue(key); if(subscription == null) return; subscription.RemoveSubscriber(series); if(subscription.NumSubscribers > 0) return; subscription.CandleBuilder.Candle -= CandleBuilderOnCandle; _candleSubscriptions.Remove(key); var msg = new MarketDataMessage().FillSecurityInfo(this, series.Security); msg.TransactionId = TransactionIdGenerator.GetNextId(); msg.OriginalTransactionId = subscription.SubscribeTransactionId; msg.SecurityId = GetSecurityId(series.Security); msg.DataType = MarketDataTypes.CandleTimeFrame; msg.IsSubscribe = false; msg.From = subscription.From; msg.Arg = subscription.TimeFrame; SendInMessage(msg); UnSubscribeMarketData(series.Security, MarketDataTypes.CandleTimeFrame); }
/// <summary> /// Создать <see cref="CandleManagerIndicatorSource"/>. /// </summary> /// <param name="series">Серия свечек.</param> public CandleSeriesIndicatorSource(CandleSeries series) { if (series == null) throw new ArgumentNullException("series"); _series = series; _series.ProcessCandle += OnProcessCandle; }
private void OnChartPanelSubscribeIndicatorElement(ChartIndicatorElement element, CandleSeries candleSeries, IIndicator indicator) { _drawTimer.Cancel(); _elements.Add(new RefPair<IChartElement, int>(element, 0)); _indicators.Add(element, indicator); _drawTimer.Activate(); }
public SmaStrategy(ICandleManager candleManager, CandleSeries series, SimpleMovingAverage longSma, SimpleMovingAverage shortSma) { _candleManager = candleManager; _series = series; LongSma = longSma; ShortSma = shortSma; }
private void CandleSettingsEditorOnClosed(object sender, RoutedEventArgs routedEventArgs) { if (_tempCandleSeries == CandleSettingsEditor.Settings || _candleSeries == null) return; _tempCandleSeries = CandleSettingsEditor.Settings.Clone(); SecurityPicker_OnSecuritySelected(SecurityPicker.SelectedSecurity); }
/// <summary> /// Создать <see cref="CandleManagerIndicatorSource"/>. /// </summary> /// <param name="series">Серия свечек.</param> /// <param name="getPart">Конвертер свечки, через которую можно получить ее параметр (цену закрытия <see cref="Candle.ClosePrice"/>, цену открытия <see cref="Candle.OpenPrice"/> и т.д.).</param> public CandleSeriesIndicatorSource(CandleSeries series, Func<Candle, decimal> getPart) : base(getPart) { if (series == null) throw new ArgumentNullException("series"); _series = series; _series.ProcessCandle += OnProcessCandle; }
private void ProcessNewCandles(CandleSeries series, IEnumerable<Candle> candles) { if (series != _candleSeries) return; foreach (var timeFrameCandle in candles) { Chart.Draw(_candleElem, timeFrameCandle); } }
public SmaStrategy(CandleSeries series, SimpleMovingAverage longSma, SimpleMovingAverage shortSma) { _series = series; LongSma = longSma; ShortSma = shortSma; _longSmaPeriod = this.Param("LongSmaPeriod", longSma.Length); _shortSmaPeriod = this.Param("ShortSmaPeriod", shortSma.Length); }
IEnumerable<Range<DateTimeOffset>> IExternalCandleSource.GetSupportedRanges(CandleSeries series) { if (series.CandleType != typeof(TimeFrameCandle) || !(series.Arg is TimeSpan)) yield break; var tf = (TimeSpan)series.Arg; if (OandaMessageAdapter.TimeFrames.Contains(tf)) yield return new Range<DateTimeOffset>(DateTimeOffset.MinValue, CurrentTime); }
static void Main(string[] args) { _candleManager = new CandleManager(); if (!GetSetings()) return; var storageRegistry = new StorageRegistry(); ((LocalMarketDataDrive)storageRegistry.DefaultDrive).Path = _historyPath; var cbs = new TradeStorageCandleBuilderSource { StorageRegistry = storageRegistry }; _candleManager.Sources.OfType<TimeFrameCandleBuilder>().Single().Sources.Add(cbs); _candleManager.Processing += GetCandles; foreach (var Sec in listOfName) { foreach (var timeFrame in listOfTimeFrame) { _series = new CandleSeries(typeof(TimeFrameCandle), Sec, timeFrame); LisfStreamWriters.Add(_series.ToString(), new StreamWriter(GetFileName(_series), false)); _candleManager.Start(_series, _startTime, _endTime); } } Console.ReadKey(); // Закроем все потоки которые мы записывали foreach (var strim in LisfStreamWriters) { strim.Value.Close(); } }
public SubscribeCandleElementCommand(ChartCandleElement element, CandleSeries candleSeries) { if (element == null) throw new ArgumentNullException(nameof(element)); if (candleSeries == null) throw new ArgumentNullException(nameof(candleSeries)); Element = element; CandleSeries = candleSeries; }
public ChartAddElementCommand(ChartArea area, IChartElement element, CandleSeries series = null) { if (area == null) throw new ArgumentNullException(nameof(area)); if (element == null) throw new ArgumentNullException(nameof(element)); Area = area; Element = element; Series = series; }
private void ProcessNewCandles(CandleSeries series, IEnumerable<Candle> candles) { if (series != _candleSeries) return; this.GuiAsync(() => { foreach (var timeFrameCandle in candles) { Chart.ProcessCandle(_candleElem, timeFrameCandle); } }); }
protected override void OnStarted() { _series = new CandleSeries(typeof(TimeFrameCandle), Security, TimeFrame); _shortSma.Length = ShortSmaPeriod; _longSma.Length = LongSmaPeriod; if (_area == null) { _area = new ChartArea(); _area.Elements.Add(new ChartCandleElement()); _area.Elements.Add(new ChartIndicatorElement { Color = Colors.Green, StrokeThickness = 1 }); _area.Elements.Add(new ChartIndicatorElement { Color = Colors.Red, StrokeThickness = 1 }); _area.Elements.Add(new ChartTradeElement()); new ChartAddAreaCommand(_area).Process(this); } this .WhenNewMyTrades() .Do(trades => { foreach (var myTrade in trades) { new ChartDrawCommand(myTrade.Trade.Time, new Dictionary<IChartElement, object> { { _area.Elements[3], myTrade } }).Process(this); } }) .Apply(this); _series .WhenCandles() .Do(Process) .Apply(this); this.GetCandleManager().Start(_series); Security .WhenMarketDepthChanged(SafeGetConnector()) .Do(md => new UpdateMarketDepthCommand(md).Process(this)) .Apply(this); SafeGetConnector().RegisterMarketDepth(Security); base.OnStarted(); }
public SubscribeIndicatorElementCommand(ChartIndicatorElement element, CandleSeries candleSeries, IIndicator indicator) { if (element == null) throw new ArgumentNullException(nameof(element)); if (candleSeries == null) throw new ArgumentNullException(nameof(candleSeries)); if (indicator == null) throw new ArgumentNullException(nameof(indicator)); Element = element; CandleSeries = candleSeries; Indicator = indicator; }
public SmaStrategy(IChart chart, ChartCandleElement candlesElem, ChartTradeElement tradesElem, SimpleMovingAverage shortMa, ChartIndicatorElement shortElem, SimpleMovingAverage longMa, ChartIndicatorElement longElem, CandleSeries series) { _chart = chart; _candlesElem = candlesElem; _tradesElem = tradesElem; _shortElem = shortElem; _longElem = longElem; _series = series; ShortSma = shortMa; LongSma = longMa; }
private void Chart_OnSubscribeIndicatorElement(ChartIndicatorElement element, CandleSeries series, IIndicator indicator, ChartPanel chart) { var values = _allCandles .Select(candle => { if (candle.State != CandleStates.Finished) candle.State = CandleStates.Finished; return new RefPair<DateTimeOffset, IDictionary<IChartElement, object>>(candle.OpenTime, new Dictionary<IChartElement, object> { { element, indicator.Process(candle) } }); }) .ToArray(); chart.Draw(values); }
public EMAEventModelStrategy(CandleSeries series, ExponentialMovingAverage filterMA, ExponentialMovingAverage longMA, ExponentialMovingAverage shortMA, Unit takeProfitUnit, Unit stopLossUnit) { this.FilterMA = filterMA; this.LongMA = longMA; this.ShortMA = shortMA; this.CandleSeries = series; this.TakeProfitUnit = takeProfitUnit; this.StopLossUnit = stopLossUnit; this.StopTradingUnit = this.StopLossUnit * 3; this.UseQuoting = true; this.BestPriceOffset = 5; }
public void UnsubscribeCandles(CandleSeries series) { var tuple = _subscriptionDates.TryGetValue(series.Security.Id); if(tuple == null) return; var msg = new MarketDataMessage().FillSecurityInfo(this, series.Security); msg.TransactionId = TransactionIdGenerator.GetNextId(); msg.OriginalTransactionId = tuple.Item2; msg.SecurityId = GetSecurityId(series.Security); msg.DataType = MarketDataTypes.CandleTimeFrame; msg.IsSubscribe = false; msg.From = tuple.Item1; msg.Arg = series.Arg; SendInMessage(msg); UnSubscribeMarketData(series.Security, MarketDataTypes.CandleTimeFrame); }
public void SubscribeCandles(CandleSeries series) { var transId = TransactionIdGenerator.GetNextId(); _subscriptionDates[series.Security.Id] = Tuple.Create(series.From, transId); var msg = new MarketDataMessage().FillSecurityInfo(this, series.Security); msg.TransactionId = transId; msg.SecurityId = GetSecurityId(series.Security); msg.DataType = MarketDataTypes.CandleTimeFrame; msg.IsSubscribe = true; msg.From = series.From; msg.Arg = (TimeSpan)series.Arg; _lastCandles.Remove(Tuple.Create(msg.SecurityId, msg.Arg)); SendInMessage(msg); SubscribeMarketData(series.Security, MarketDataTypes.CandleTimeFrame); }
/// <summary> /// Создать <see cref="CandleSettingsEditor"/>. /// </summary> public CandleSettingsEditor() { InitializeComponent(); CandleType.ItemsSource = _candleTypes; _visibility.Add(typeof(TimeFrameCandle), TimeFramePanel); _visibility.Add(typeof(TickCandle), IntValuePanel); _visibility.Add(typeof(VolumeCandle), DecimalValuePanel); _visibility.Add(typeof(RangeCandle), UnitValuePanel); _visibility.Add(typeof(RenkoCandle), UnitValuePanel); _visibility.Add(typeof(PnFCandle), PnfValuePanel); Settings = new CandleSeries { CandleType = typeof(TimeFrameCandle), Arg = TimeSpan.FromMinutes(1), }; UnitValue.Value = new Unit(1); PnfBoxSize.Value = new Unit(1); }
public void SubscribeCandles(CandleSeries series) { if (!IsConnected) { _subscribersBuffer.Add(series); return; } var key = new SubscriptionKey(series.Security.Id, (TimeSpan) series.Arg); var transId = TransactionIdGenerator.GetNextId(); var subscription = _candleSubscriptions.TryGetValue(key); if (subscription != null) { Candles?.Invoke(series, subscription.CandleBuilder.AllCandles); subscription.AddSubscriber(series); return; } subscription = new CandleSubscription(series.Security, series.From, (TimeSpan) series.Arg, transId); subscription.AddSubscriber(series); _candleSubscriptions.Add(key, subscription); subscription.CandleBuilder.Candle += CandleBuilderOnCandle; var msg = new MarketDataMessage().FillSecurityInfo(this, series.Security); msg.TransactionId = transId; msg.SecurityId = GetSecurityId(series.Security); msg.DataType = MarketDataTypes.CandleTimeFrame; msg.IsSubscribe = true; msg.From = series.From; msg.Arg = series.Arg; SendInMessage(msg); SubscribeMarketData(series.Security, MarketDataTypes.CandleTimeFrame); }
/// <summary> /// To get the number of candles. /// </summary> /// <param name="series">Candles series.</param> /// <returns>Number of candles.</returns> public int GetCandleCount(CandleSeries series) { var info = GetInfo(series); return info == null ? 0 : info.CandleCount; }
/// <summary> /// To create candles from the tick trades collection. /// </summary> /// <param name="trades">Tick trades.</param> /// <param name="series">Candles series.</param> /// <param name="onlyFormed">Process only formed candles.</param> /// <returns>Candles.</returns> public static IEnumerable <Candle> ToCandles(this IEnumerable <Trade> trades, CandleSeries series, bool onlyFormed = true) { return(trades .ToMessages <Trade, ExecutionMessage>() .ToCandles(series, onlyFormed) .ToCandles <Candle>(series.Security, series.CandleType)); }
/// <summary> /// To create candles from the order books collection. /// </summary> /// <param name="depths">Market depths.</param> /// <param name="series">Candles series.</param> /// <param name="type">Type of candle depth based data.</param> /// <param name="onlyFormed">Process only formed candles.</param> /// <returns>Candles.</returns> public static IEnumerable <Candle> ToCandles(this IEnumerable <MarketDepth> depths, CandleSeries series, DepthCandleSourceTypes type = DepthCandleSourceTypes.Middle, bool onlyFormed = true) { return(depths .ToMessages <MarketDepth, QuoteChangeMessage>() .ToCandles(series, type, onlyFormed) .ToCandles <Candle>(series.Security, series.CandleType)); }
/// <summary> /// To start candles getting. /// </summary> /// <param name="manager">The candles manager.</param> /// <param name="series">Candles series.</param> public static void Start(this ICandleManager manager, CandleSeries series) { manager.ThrowIfNull().Start(series, series.From, series.To); }
/// <summary> /// To get all candles. /// </summary> /// <typeparam name="TCandle">The candles type.</typeparam> /// <param name="candleManager">The candles manager.</param> /// <param name="series">Candles series.</param> /// <returns>Candles.</returns> public static IEnumerable <TCandle> GetCandles <TCandle>(this ICandleManager candleManager, CandleSeries series) where TCandle : Candle { return(candleManager.ThrowIfNull().Container.GetCandles(series).OfType <TCandle>()); }
/// <summary> /// To get candles by the total number. /// </summary> /// <typeparam name="TCandle">The candles type.</typeparam> /// <param name="candleManager">The candles manager.</param> /// <param name="series">Candles series.</param> /// <param name="candleCount">The number of candles that should be returned.</param> /// <returns>Found candles.</returns> public static IEnumerable <TCandle> GetCandles <TCandle>(this ICandleManager candleManager, CandleSeries series, int candleCount) { return(candleManager.ThrowIfNull().Container.GetCandles(series, candleCount).OfType <TCandle>()); }
/// <summary> /// To get a temporary candle on the specific date. /// </summary> /// <param name="candleManager">The candles manager.</param> /// <param name="series">Candles series.</param> /// <param name="time">The candle date.</param> /// <returns>The found candle (<see langword="null" />, if the candle by the specified criteria does not exist).</returns> public static TimeFrameCandle GetTimeFrameCandle(this ICandleManager candleManager, CandleSeries series, DateTimeOffset time) { return(candleManager.GetCandles <TimeFrameCandle>(series).FirstOrDefault(c => c.OpenTime == time)); }
IEnumerable <Range <DateTimeOffset> > ICandleSource <Candle> .GetSupportedRanges(CandleSeries series) { if (series == null) { throw new ArgumentNullException(nameof(series)); } if (series.Security is IndexSecurity) { yield return(new Range <DateTimeOffset>(_from, _to)); } }
void ICandleSource <Candle> .Stop(CandleSeries series) { _connector.UnSubscribeCandles(series); _candleSeries.Remove(series); }
void ICandleSource <Candle> .Start(CandleSeries series, DateTimeOffset?from, DateTimeOffset?to) { _candleSeries.Add(series); _connector.SubscribeCandles(series, from, to); }
IEnumerable <Range <DateTimeOffset> > ICandleSource <Candle> .GetSupportedRanges(CandleSeries series) { yield return(new Range <DateTimeOffset>(DateTimeOffset.MinValue, DateTimeOffset.MaxValue)); }
/// <summary> /// To create candles from the tick trades collection. /// </summary> /// <param name="trades">Tick trades.</param> /// <param name="series">Candles series.</param> /// <returns>Candles.</returns> public static IEnumerableEx <CandleMessage> ToCandles(this IEnumerableEx <ExecutionMessage> trades, CandleSeries series) { return(trades .ToEntities <ExecutionMessage, Trade>(series.Security) .ToCandles(series) .ToMessages <Candle, CandleMessage>()); }
private void OnStopped(CandleSeries series) { Stopped?.Invoke(series); }
void ICandleSource <Candle> .Stop(CandleSeries series) { _series.Remove(series); _source.UnSubscribeCandles(series); }
private SeriesInfo GetInfo(CandleSeries series) { if (series == null) throw new ArgumentNullException(nameof(series)); return _info.TryGetValue(series); }
/// <summary> /// To create candles from the order books collection. /// </summary> /// <param name="depths">Market depths.</param> /// <param name="series">Candles series.</param> /// <returns>Candles.</returns> public static IEnumerableEx <CandleMessage> ToCandles(this IEnumerableEx <QuoteChangeMessage> depths, CandleSeries series) { return(depths .ToEntities <QuoteChangeMessage, MarketDepth>(series.Security) .ToCandles(series) .ToMessages <Candle, CandleMessage>()); }
IEnumerable <Range <DateTimeOffset> > ICandleSource <Candle> .GetSupportedRanges(CandleSeries series) { return(_source.GetSupportedRanges(series)); }
/// <summary> /// To get a candle by the index. /// </summary> /// <typeparam name="TCandle">The candles type.</typeparam> /// <param name="candleManager">The candles manager.</param> /// <param name="series">Candles series.</param> /// <param name="candleIndex">The candle's position number from the end.</param> /// <returns>The found candle. If the candle does not exist, then <see langword="null" /> will be returned.</returns> public static TCandle GetCandle <TCandle>(this ICandleManager candleManager, CandleSeries series, int candleIndex) where TCandle : Candle { return((TCandle)candleManager.ThrowIfNull().Container.GetCandle(series, candleIndex)); }
/// <summary> /// To create candles from the tick trades collection. /// </summary> /// <param name="trades">Tick trades.</param> /// <param name="series">Candles series.</param> /// <returns>Candles.</returns> public static IEnumerableEx <Candle> ToCandles(this IEnumerableEx <Trade> trades, CandleSeries series) { return(new CandleEnumerable <Trade>(series, trades)); }
/// <summary> /// To get candles by date range. /// </summary> /// <typeparam name="TCandle">The candles type.</typeparam> /// <param name="candleManager">The candles manager.</param> /// <param name="series">Candles series.</param> /// <param name="timeRange">The date range which should include candles. The <see cref="Candle.OpenTime"/> value is taken into consideration.</param> /// <returns>Found candles.</returns> public static IEnumerable <TCandle> GetCandles <TCandle>(this ICandleManager candleManager, CandleSeries series, Range <DateTimeOffset> timeRange) where TCandle : Candle { return(candleManager.ThrowIfNull().Container.GetCandles(series, timeRange).OfType <TCandle>()); }
public CandleEnumerable(CandleSeries series, IEnumerableEx <TValue> values) : base(() => new CandleEnumerator(series, values)) { _values = values; }
///// <summary> ///// To stop candles getting. ///// </summary> ///// <param name="series">Candles series.</param> //public static void Stop(this CandleSeries series) //{ // var manager = series.ThrowIfNull().CandleManager; // // серию ранее не запускали, значит и останавливать не нужно // if (manager == null) // return; // manager.Stop(series); //} //private static ICandleManagerContainer GetContainer(this CandleSeries series) //{ // return series.ThrowIfNull().CandleManager.Container; //} /// <summary> /// To get the number of candles. /// </summary> /// <param name="candleManager">The candles manager.</param> /// <param name="series">Candles series.</param> /// <returns>Number of candles.</returns> public static int GetCandleCount(this ICandleManager candleManager, CandleSeries series) { return(candleManager.ThrowIfNull().Container.GetCandleCount(series)); }
public void PushNewValue(CandleSeries series, TValue value) { NewSourceValues(series, new[] { value }); }
/// <summary> /// To create candles from the order books collection. /// </summary> /// <param name="depths">Market depths.</param> /// <param name="series">Candles series.</param> /// <param name="type">Type of candle depth based data.</param> /// <param name="onlyFormed">Process only formed candles.</param> /// <returns>Candles.</returns> public static IEnumerable <CandleMessage> ToCandles(this IEnumerable <QuoteChangeMessage> depths, CandleSeries series, DepthCandleSourceTypes type = DepthCandleSourceTypes.Middle, bool onlyFormed = true) { return(new CandleMessageEnumerable(series.ToMarketDataMessage(true), onlyFormed, depths, type)); }
public override void Stop(CandleSeries series) { RaiseStopped(series); }
/// <summary> /// To create candles from the tick trades collection. /// </summary> /// <param name="trades">Tick trades.</param> /// <param name="series">Candles series.</param> /// <param name="onlyFormed">Process only formed candles.</param> /// <returns>Candles.</returns> public static IEnumerable <CandleMessage> ToCandles(this IEnumerable <ExecutionMessage> trades, CandleSeries series, bool onlyFormed = true) { return(new CandleMessageEnumerable(series.ToMarketDataMessage(true), onlyFormed, trades)); }
public override void Start(CandleSeries series, DateTimeOffset from, DateTimeOffset to) { }
void ICandleSource <Candle> .Start(CandleSeries series, DateTimeOffset from, DateTimeOffset to) { _source.SubscribeCandles(series, from, to); }
public override IEnumerable <Range <DateTimeOffset> > GetSupportedRanges(CandleSeries series) { if (series == null) { throw new ArgumentNullException(nameof(series)); } if (series.Security != _security) { yield break; } yield return(new Range <DateTimeOffset>(DateTimeOffset.MinValue, DateTimeOffset.MaxValue)); }
/// <summary> /// To notify the container about the start of the candles getting for the series. /// </summary> /// <param name="series">Candles series.</param> /// <param name="from">The initial date from which the candles will be get.</param> /// <param name="to">The final date by which the candles will be get.</param> public void Start(CandleSeries series, DateTimeOffset from, DateTimeOffset to) { if (series == null) throw new ArgumentNullException(nameof(series)); var info = _info.SafeAdd(series, key => new SeriesInfo(this)); info.Reset(from); }
/// <summary> /// To get the current candle. /// </summary> /// <typeparam name="TCandle">The candles type.</typeparam> /// <param name="candleManager">The candles manager.</param> /// <param name="series">Candles series.</param> /// <returns>The found candle. If the candle does not exist, the <see langword="null" /> will be returned.</returns> public static TCandle GetCurrentCandle <TCandle>(this ICandleManager candleManager, CandleSeries series) where TCandle : Candle { return(candleManager.GetCandle <TCandle>(series, 0)); }
private void OnConnectorCandleSeriesStopped(CandleSeries series) { _candleSeries.Remove(series); Stopped?.Invoke(series); }
/// <summary> /// To create candles from the order books collection. /// </summary> /// <param name="depths">Market depths.</param> /// <param name="series">Candles series.</param> /// <returns>Candles.</returns> public static IEnumerableEx <Candle> ToCandles(this IEnumerableEx <MarketDepth> depths, CandleSeries series) { return(new CandleEnumerable <MarketDepth>(series, depths)); }