/// <summary>
        ///
        /// </summary>
        /// <param name="cache"></param>
        /// <param name="symbol"></param>
        /// <param name="limit"></param>
        /// <param name="callback"></param>
        /// <param name="token"></param>
        /// <returns></returns>
        public static Task SubscribeAndStreamAsync(this IOrderBookCache cache, string symbol, int limit, Action <OrderBookCacheEventArgs> callback, CancellationToken token)
        {
            Throw.IfNull(cache, nameof(cache));

            cache.Subscribe(symbol, limit, callback);

            return(StreamAsync(cache, token));
        }
        public OrderBookService(IOrderBookCache orderBookCache,
                                IFakeOrderBookPublisher fakeOrderBookPublisher,
                                FakeExchangeConnectorSettings fakeExchangeConnectorSettings)
        {
            _orderBookCache = orderBookCache;

            _fakeOrderBookPublisher = fakeOrderBookPublisher;

            _fakeExchangeConnectorSettings = fakeExchangeConnectorSettings;
        }
 public OrderBookService(IOrderBookCache orderBookCache,
                         IFakeOrderBookPublisher fakeOrderBookPublisher,
                         FakeExchangeConnectorSettings fakeExchangeConnectorSettings,
                         CorrelationContextAccessor correlationContextAccessor,
                         ILog log)
 {
     _orderBookCache                = orderBookCache;
     _fakeOrderBookPublisher        = fakeOrderBookPublisher;
     _fakeExchangeConnectorSettings = fakeExchangeConnectorSettings;
     _correlationContextAccessor    = correlationContextAccessor;
     _log = log;
 }
        public CacheDataHandler(IInstrumentCache instrumentCache,
                                IOrderBookCache orderBookCache,
                                IPositionCache positionCache,
                                IOrderCache orderCache,
                                ILogger <CacheDataHandler> logger)


        {
            _instrumentCache = instrumentCache;
            _orderBookCache  = orderBookCache;
            _positionCache   = positionCache;
            _orderCache      = orderCache;
            _logger          = logger;
        }
 /// <summary>
 ///
 /// </summary>
 /// <param name="cache"></param>
 /// <param name="symbol"></param>
 /// <param name="callback"></param>
 /// <param name="token"></param>
 /// <returns></returns>
 public static Task SubscribeAndStreamAsync(this IOrderBookCache cache, string symbol, Action <OrderBookCacheEventArgs> callback, CancellationToken token)
 => SubscribeAndStreamAsync(cache, symbol, default, callback, token);
 /// <summary>
 ///
 /// </summary>
 /// <param name="cache"></param>
 /// <param name="symbol"></param>
 /// <param name="limit"></param>
 /// <param name="token"></param>
 /// <returns></returns>
 public static Task SubscribeAndStreamAsync(this IOrderBookCache cache, string symbol, int limit, CancellationToken token)
 => SubscribeAndStreamAsync(cache, symbol, limit, null, token);
        /// <summary>
        ///
        /// </summary>
        /// <param name="cache"></param>
        /// <param name="token"></param>
        /// <returns></returns>
        public static Task StreamAsync(this IOrderBookCache cache, CancellationToken token)
        {
            Throw.IfNull(cache, nameof(cache));

            return(cache.Client.WebSocket.StreamAsync(token));
        }
 /// <summary>
 ///
 /// </summary>
 /// <param name="cache"></param>
 /// <param name="symbol"></param>
 /// <param name="callback"></param>
 /// <returns></returns>
 public static void Subscribe(this IOrderBookCache cache, string symbol, Action <OrderBookCacheEventArgs> callback)
 => cache.Subscribe(symbol, default, callback);
 /// <summary>
 ///
 /// </summary>
 /// <param name="cache"></param>
 /// <param name="symbol"></param>
 /// <param name="limit"></param>
 /// <returns></returns>
 public static void Subscribe(this IOrderBookCache cache, string symbol, int limit)
 => cache.Subscribe(symbol, limit, null);
 /// <summary>
 ///
 /// </summary>
 /// <param name="cache"></param>
 /// <param name="symbol"></param>
 /// <returns></returns>
 public static void Subscribe(this IOrderBookCache cache, string symbol)
 => cache.Subscribe(symbol, default, null);
 /// <summary>
 ///
 /// </summary>
 /// <param name="cache"></param>
 /// <param name="symbol"></param>
 /// <param name="token"></param>
 /// <returns></returns>
 public static Task SubscribeAsync(this IOrderBookCache cache, string symbol, CancellationToken token)
 => cache.SubscribeAsync(symbol, default, null, token);
 public OrderbooksController(IOrderBookCache orderBookCache)
 {
     _orderBookCache = orderBookCache;
 }
 /// <summary>
 ///
 /// </summary>
 /// <param name="cache"></param>
 /// <param name="symbol"></param>
 /// <param name="token"></param>
 /// <returns></returns>
 public static Task StreamAsync(this IOrderBookCache cache, string symbol, CancellationToken token)
 => StreamAsync(cache, symbol, default, null, token);
 /// <summary>
 ///
 /// </summary>
 /// <param name="cache"></param>
 /// <param name="symbol"></param>
 /// <param name="callback"></param>
 /// <returns></returns>
 public static void Subscribe <TClient>(this IOrderBookCache <TClient> cache, string symbol, Action <OrderBookCacheEventArgs> callback, int limit = default)
     where TClient : IDepthClient
 => cache.Subscribe(symbol, limit, callback);
 /// <summary>
 ///
 /// </summary>
 /// <param name="cache"></param>
 /// <param name="symbol"></param>
 /// <param name="limit"></param>
 /// <returns></returns>
 public static void Subscribe <TClient>(this IOrderBookCache <TClient> cache, string symbol, int limit)
     where TClient : IDepthClient
 => cache.Subscribe(symbol, limit, null);
 public OrderbooksController(IOrderBookCache orderBookCache, IOrderBookService orderBookService, ILog log)
 {
     _orderBookCache   = orderBookCache;
     _orderBookService = orderBookService;
     _log = log;
 }
Beispiel #17
0
        internal static async Task DisableLiveTask()
        {
            LiveTokenSource?.Cancel();

            // Wait for live task to complete.
            if (LiveTask != null && !LiveTask.IsCompleted)
            {
                await LiveTask;
            }

            LiveTokenSource?.Dispose();

            if (TradeCache != null)
            {
                lock (ConsoleSync)
                {
                    Console.WriteLine();
                    Console.WriteLine("  ...live trades feed disabled.");
                }
            }
            TradeCache = null;

            if (OrderBookCache != null)
            {
                lock (ConsoleSync)
                {
                    Console.WriteLine();
                    Console.WriteLine("  ...live order book feed disabled.");
                }
            }
            OrderBookCache = null;

            if (CandlestickCache != null)
            {
                lock (ConsoleSync)
                {
                    Console.WriteLine();
                    Console.WriteLine("  ...live candlestick feed disabled.");
                }
            }
            CandlestickCache = null;

            if (AggregateTradeCache != null)
            {
                lock (ConsoleSync)
                {
                    Console.WriteLine();
                    Console.WriteLine("  ...live aggregate trades feed disabled.");
                }
            }
            AggregateTradeCache = null;

            if (UserDataClient != null)
            {
                lock (ConsoleSync)
                {
                    Console.WriteLine();
                    Console.WriteLine("  ...live account feed disabled.");
                }
            }
            UserDataClient = null;

            LiveTokenSource = null;
            LiveTask        = null;
        }