Каков наилучший способ параллельного вызова вызовов API в .net Core, C #? - PullRequest
Новая
       28

Каков наилучший способ параллельного вызова вызовов API в .net Core, C #?

2 голосов
/ 12 октября 2019

Я хотел бы вызывать мой API параллельно x раз, чтобы обработка могла быть выполнена быстро. У меня есть три метода ниже, которые я должен вызывать API параллельно. Я пытаюсь понять, каков наилучший способ выполнить это действие.

Базовый код 

var client = new System.Net.Http.HttpClient();
client.DefaultRequestHeaders.Add("Accept", "application/json");

client.BaseAddress = new Uri("https://jsonplaceholder.typicode.com");
var list = new List<int>();

var listResults = new List<string>();
for (int i = 1; i < 5; i++)
{
    list.Add(i);
}

1-й метод с использованием Parallel.ForEach 

Parallel.ForEach(list,new ParallelOptions() { MaxDegreeOfParallelism = 3 }, index =>
{
    var response = client.GetAsync("posts/" + index).Result;

    var contents =  response.Content.ReadAsStringAsync().Result;
    listResults.Add(contents);
    Console.WriteLine(contents);
});

Console.WriteLine("After all parallel tasks are done with Parallel for each");

2-й метод сЗадачи. Я не уверен, если это идет параллельно. Дайте мне знать, если он делает 

var loadPosts = new List<Task<string>>();
foreach(var post in list)
{
    var response = await client.GetAsync("posts/" + post);

    var contents = response.Content.ReadAsStringAsync();
    loadPosts.Add(contents);
    Console.WriteLine(contents.Result);
}

await Task.WhenAll(loadPosts);

Console.WriteLine("After all parallel tasks are done with Task When All");

3-й метод с использованием блока действий - это то, что я считаю, я должен всегда делать, но я хочу услышать от сообщества 

var responses = new List<string>();

var block = new ActionBlock<int>(
    async x => {
        var response = await client.GetAsync("posts/" + x);
        var contents = await response.Content.ReadAsStringAsync();
        Console.WriteLine(contents);
        responses.Add(contents);                
    },
    new ExecutionDataflowBlockOptions
    {
        MaxDegreeOfParallelism = 6, // Parallelize on all cores
    });

for (int i = 1; i < 5; i++)
{
    block.Post(i);
}

block.Complete();
await block.Completion;

Console.WriteLine("After all parallel tasks are done with Action block");

Ответы [ 2 ]

5 голосов
/ 12 октября 2019

Подход № 2 близок. Вот эмпирическое правило: связанные операции ввода-вывода => использовать Tasks / WhenAll (асинхронность), вычислить связанные операции => использовать параллелизм. Http-запросы - это сетевой ввод-вывод. 

            foreach (var post in list)
            {
                async Task<string> func()
                {
                    var response = await client.GetAsync("posts/" + post);
                    return await response.Content.ReadAsStringAsync();
                }

                tasks.Add(func());
            }

            await Task.WhenAll(tasks);

            var postResponses = new List<string>();

            foreach (var t in tasks) {
                var postResponse = await t; //t.Result would be okay too.
                postResponses.Add(postResponse);
                Console.WriteLine(postResponse);
            }
1 голос
/ 17 октября 2019

Я бы использовал следующее, он не контролирует параллелизм (он будет отправлять все HTTP-запросы параллельно, в отличие от вашего 3-го метода), но это намного проще - он имеет только один await. 

var client = new HttpClient();
var list = new[] { 1, 2, 3, 4, 5 };
var postTasks = list.Select(p => client.GetStringAsync("posts/" + p));
var posts = await Task.WhenAll(postTasks);
foreach (var postContent in posts)
{
    Console.WriteLine(postContent);
}
...