private async Task SaveMarketDataAsync(List <MarketSlice> marketData, Dictionary <string, IList <Candle> > prices)
        {
            var tasks = new List <Task>();

            List <string> assetPairIds      = prices.Keys.ToList();
            var           pricesValue       = new Dictionary <string, SortedSetEntry[]>();
            var           baseVolumesValue  = new Dictionary <string, SortedSetEntry[]>();
            var           quoteVolumesValue = new Dictionary <string, SortedSetEntry[]>();

            tasks.Add(_database.SortedSetAddAsync(RedisService.GetAssetPairsKey(),
                                                  marketData.Select(x => new SortedSetEntry(x.AssetPairId, 0)).ToArray()));

            foreach (var assetPairId in assetPairIds)
            {
                pricesValue.Add(assetPairId,
                                prices[assetPairId].Select(x =>
                                                           new SortedSetEntry(RedisExtensions.SerializeWithTimestamp((decimal)x.Open, x.DateTime),
                                                                              x.DateTime.ToUnixTime())).ToArray());

                baseVolumesValue.Add(assetPairId,
                                     prices[assetPairId].Select(x =>
                                                                new SortedSetEntry(RedisExtensions.SerializeWithTimestamp((decimal)x.TradingVolume, x.DateTime),
                                                                                   x.DateTime.ToUnixTime())).ToArray());

                quoteVolumesValue.Add(assetPairId,
                                      prices[assetPairId].Select(x =>
                                                                 new SortedSetEntry(RedisExtensions.SerializeWithTimestamp((decimal)x.TradingOppositeVolume, x.DateTime),
                                                                                    x.DateTime.ToUnixTime())).ToArray());
            }

            foreach (MarketSlice marketSlice in marketData)
            {
                tasks.Add(_database.HashSetAsync(RedisService.GetMarketDataKey(marketSlice.AssetPairId),
                                                 marketSlice.ToMarketSliceHash()));
            }

            await Task.WhenAll(tasks);

            tasks = new List <Task>();

            foreach (MarketSlice marketSlice in marketData)
            {
                tasks.Add(_priceWriter.InsertOrReplaceAsync(marketSlice.ToPrice()));
                tasks.Add(_tickerWriter.InsertOrReplaceAsync(marketSlice.ToTicker()));
            }

            await Task.WhenAll(tasks);

            tasks = new List <Task>();

            foreach (var assetPairId in assetPairIds)
            {
                tasks.Add(_database.SortedSetAddAsync(RedisService.GetMarketDataPriceKey(assetPairId), pricesValue[assetPairId]));
                tasks.Add(_database.SortedSetAddAsync(RedisService.GetMarketDataBaseVolumeKey(assetPairId), baseVolumesValue[assetPairId]));
                tasks.Add(_database.SortedSetAddAsync(RedisService.GetMarketDataQuoteVolumeKey(assetPairId), quoteVolumesValue[assetPairId]));
            }

            await Task.WhenAll(tasks);
        }
        private Task ClearDataAsync(List <string> assetPairIds)
        {
            var keys = new List <string>();

            foreach (var assetPairId in assetPairIds)
            {
                keys.Add(RedisService.GetMarketDataBaseVolumeKey(assetPairId));
                keys.Add(RedisService.GetMarketDataQuoteVolumeKey(assetPairId));
                keys.Add(RedisService.GetMarketDataPriceKey(assetPairId));
            }

            return(Task.WhenAll(
                       _database.KeyDeleteAsync(keys.Select(x => (RedisKey)x).ToArray()),
                       _tickerWriter.CleanAndKeepMaxPartitions(0),
                       _priceWriter.CleanAndKeepMaxPartitions(0)
                       ));
        }