Асинхронное программирование

using System;
using System.Collections.Generic;
using System.Globalization;
using System.Net.Http;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Json;
using System.Threading.Tasks;
 
namespace AsincExample
{
    class Program
    {
        static void Main(string[] args)
        {
            foreach (var h in Api.GetHashrate().GetAwaiter().GetResult())
                Console.WriteLine(h.Count.ToString());
        }
    }
    class Api
    {
        static string apiAdressMethod = "https://api.nicehash.com/api?method=orders.get";
        static int algorithmsQuantity = 31;
        public static async Task<List<Dictionary<float, float>>> GetHashrate()
        {
            List<Dictionary<float, float>> Hashrate = new List<Dictionary<float, float>>();
            for (byte algo = 0; algo < algorithmsQuantity; algo++)
                Hashrate.Add(await GetHashrate(algo));
            return Hashrate;
        }
        static async Task<Dictionary<float, float>> GetHashrate(int algo)
        {
            Dictionary<float, float> Hashrate = new Dictionary<float, float>();
            for (byte location = 0; location <= 1; location++)
                foreach (Order o in (await GetHashrate(location, algo)).Result.Order)
                {
                    float price = float.Parse(o.Price, CultureInfo.InvariantCulture);
                    float speed = float.Parse(o.AcceptedSpeed, CultureInfo.InvariantCulture);
                    if (o.Type == "0")
                    {
                        if (Hashrate.ContainsKey(price))
                            Hashrate[price] += speed;
                        else
                            Hashrate.Add(price, speed);
                    }
                }
            return Hashrate;
        }
        static async Task<Answer> GetHashrate(int location, int algo)
        {
            using (var http = new HttpClient())
            using (var stream = await http.GetStreamAsync(apiAdressMethod + $"&location={location}&algo={algo}"))
            {
                var serializer = new DataContractJsonSerializer(typeof(Answer));
                return (Answer)serializer.ReadObject(stream);
            }
        }
 
        [DataContract]
        class Answer
        {
            [DataMember(Name = "result")]
            public Result Result { get; set; }
            [DataMember(Name = "method")]
            public string Method { get; set; }
        }
        [DataContract]
        class Result
        {
            [DataMember(Name = "orders")]
            public Order[] Order { get; set; }
            [DataMember(Name = "timestamp")]
            public string Timestamp { get; set; }
        }
        [DataContract]
        class Order
        {
            [DataMember(Name = "limit_speed")]
            public string LimitSpeed { get; set; }
            [DataMember(Name = "alive")]
            public string Alive { get; set; }
            [DataMember(Name = "price")]
            public string Price { get; set; }
            [DataMember(Name = "id")]
            public string Id { get; set; }
            [DataMember(Name = "type")]
            public string Type { get; set; }
            [DataMember(Name = "workers")]
            public string Workers { get; set; }
            [DataMember(Name = "algo")]
            public string Algo { get; set; }
            [DataMember(Name = "accepted_speed")]
            public string AcceptedSpeed { get; set; }
        }
    }
}

            ConcurrentBag<Dictionary<float, float>> Hashrate = new ConcurrentBag<Dictionary<float, float>>();
            Parallel.For(0, algorithmsQuantity, (algo) =>
            {
                Hashrate.Add(GetHashrate(algo));
            });
 
            return Hashrate.ToList();

var Hashrate = new ConcurrentBag<(int algo, Dictionary<float, float> orders)>();
Parallel.For(0, algorithmsQuantity, (algo) =>
{
    Hashrate.Add((algo, GetHashrate(algo)));
});
return Hashrate.OrderBy(tuple => tuple.algo).Select(tuple => tuple.orders).ToList();

return ParallelEnumerable.Range(0, algorithmsQuantity).AsOrdered()
   .Select(x => GetHashrate(x)).ToList();