Beispiel #1
0
        public async Task <ConcurrentBag <CryptsyMarketInfo> > GetOpenMarkets(bool basicInfoOnly = false, CancellationToken token = default(CancellationToken))
        {
            return(await RetryHelper.DoAsync(async() =>
            {
                CryptsyResponse answer = await CryptsyPublicQuery(new Dictionary <string, string> {
                    { "method", "marketdatav2" }
                }, false, token);

                return answer.Success ? CryptsyMarketInfo.ReadMultipleFromJObject(answer.Data as JObject, basicInfoOnly) : null;
            }, TimeSpan.FromMilliseconds(Constant.DefaultRetryInterval)));
        }
Beispiel #2
0
        public async Task <CryptsyMarketInfo> GetMarketInfo(long marketId, CancellationToken token = default(CancellationToken))
        {
            return(await RetryHelper.DoAsync(async() =>
            {
                var args = new Dictionary <string, string>
                {
                    { "marketid", Convert.ToString(marketId) },
                    { "method", "singlemarketdata" }
                };

                CryptsyResponse answer = await CryptsyPublicQuery(args, false, token);

                return answer.Success ? CryptsyMarketInfo.ReadMultipleFromJObject(answer.Data as JObject).SingleOrDefault() : null;
            }, TimeSpan.FromMilliseconds(Constant.DefaultRetryInterval)));
        }
Beispiel #3
0
        //Set basicInfoOnly=true to skip recent trades & top 20 buy and sell orders
        public ConcurrentBag <CryptsyMarketInfo> GetOpenMarketsPeriodically(CryptsyMarket[] markets, bool basicInfoOnly = false)
        {
            var resultList = new ConcurrentBag <CryptsyMarketInfo>();

            var options = new ParallelOptions {
                MaxDegreeOfParallelism = Environment.ProcessorCount * 50
            };
            int marketCounts = markets.Length;

            var sw = new Stopwatch();

            sw.Start();

            Parallel.For(1, marketCounts,
                         options,
                         () => new Tuple <CryptsyResponse>(new CryptsyResponse()),
                         (i, pls, state) =>
            {
                try
                {
                    CryptsyResponse answer = CryptsyPublicQuery(new Dictionary <string, string> {
                        { "method", "singlemarketdata" }, { "marketid", Convert.ToString(markets[i - 1].MarketId) }
                    }, i % 2 == 0).Result;
                    state = new Tuple <CryptsyResponse>(answer);
                }
                catch
                {
                    state = new Tuple <CryptsyResponse>(null);
                }
                return(state);
            },
                         state =>
            {
                if (state.Item1 != null && state.Item1.Success && state.Item1.Data is JObject)
                {
                    var data = CryptsyMarketInfo.ReadMultipleFromJObject((JObject)state.Item1.Data, basicInfoOnly);
                    data.ToList().ForEach(resultList.Add);
                }
            });
            sw.Stop();

            return(resultList);
        }