Виклик декількох служб асинхронізації паралельно

У мене є кілька служб async REST, які не залежать один від одного. Тобто під час "очікування" відповіді від Service1 я можу зателефонувати до Service2, Service3 тощо.

Наприклад, зверніться до коду нижче:

var service1Response = await HttpService1Async();
var service2Response = await HttpService2Async();

// Use service1Response and service2Response

Тепер service2Responseце не залежить від їх, service1Responseі їх можна отримати самостійно. Отже, немає потреби чекати відповіді першої служби, щоб зателефонувати на другу службу.

Я не думаю, що я можу Parallel.ForEachтут використовувати, оскільки це не пов'язана з процесором операція.

Для того, щоб викликати ці дві операції паралельно, чи можу я зателефонувати на використання Task.WhenAll? Одне питання, яке я бачу, використовуючи Task.WhenAllте, що воно не дає результатів. Щоб отримати результат, я можу зателефонувати task.Resultпісля дзвінка Task.WhenAll, оскільки всі завдання вже виконані, і все, що мені потрібно для отримання відповіді?

Приклад коду:

var task1 = HttpService1Async();
var task2 = HttpService2Async();

await Task.WhenAll(task1, task2)

var result1 = task1.Result;
var result2 = task2.Result;

// Use result1 and result2

Чи кращий цей код, ніж перший за рівнем продуктивності? Будь-який інший підхід я можу використовувати?

Одне питання я бачу за допомогою Task.WhenAll в тому, що він не повертає результатів

Але це дійсно повертає результати. Усі вони будуть знаходитись у масиві загального типу, тому не завжди корисно використовувати результати в тому, що вам потрібно знайти елемент у масиві, який відповідає тому, для Taskчого потрібно результат, та потенційно передати його його фактичний тип, тож це може бути не найпростішим / найчитабельнішим підходом у цьому контексті, але коли ви просто хочете мати всі результати від кожного завдання, а загальним типом є тип, до якого ви хочете ставитися до них, тоді це чудово .

Щоб отримати результат, я можу викликати task.Result після виклику Task.WhenAll, оскільки всі завдання вже виконані, і все, що мені потрібно для отримання відповіді?

Так, ви могли це зробити. Ви також можете awaitїх ( awaitрозгорнув би виняток у будь-якому несправному завданні, тоді як Resultвикинув би сукупний виняток, але в іншому випадку це було б саме).

Чи кращий цей код, ніж перший за рівнем продуктивності?

Він виконує дві операції одночасно, а не одну, а потім іншу. Будь це краще чи гірше, залежить від того, що є основними операціями. Якщо основними операціями є "зчитування файлу з диска", то виконання їх паралельно, ймовірно, повільніше, оскільки є лише одна головка диска, і вона може бути в одному місці в будь-який момент часу; перестрибування між двома файлами буде повільніше, ніж читання одного файлу, а потім іншого. З іншого боку, якщо операції "виконують певний мережевий запит" (як це відбувається тут), вони, швидше за все, будуть швидшими (принаймні, до певної кількості одночасних запитів), тому що ви можете чекати відповіді з іншого мережевого комп'ютера так само швидко, коли відбувається ще якийсь очікуваний мережевий запит. Якщо ви хочете знати, чи це "

Будь-який інший підхід я можу використовувати?

Якщо вам не важливо, що ви знаєте всі винятки, викинуті з усіх операцій, які ви робите паралельно, а не лише першу, ви можете просто awaitвиконати завдання WhenAll. Єдине, що WhenAllдає тобі - це те, що ти маєш AggregateExceptionвиняток із кожного невдалого завдання, а не кидати, коли ти потрапляєш у перше несправне завдання. Це так просто, як:

var task1 = HttpService1Async();
var task2 = HttpService2Async();

var result1 = await task1;
var result2 = await task2;

Ось метод розширення, який використовує SemaphoreSlim і дозволяє встановити максимальний ступінь паралелізму

    /// <summary>
    /// Concurrently Executes async actions for each item of <see cref="IEnumerable<typeparamref name="T"/>
    /// </summary>
    /// <typeparam name="T">Type of IEnumerable</typeparam>
    /// <param name="enumerable">instance of <see cref="IEnumerable<typeparamref name="T"/>"/></param>
    /// <param name="action">an async <see cref="Action" /> to execute</param>
    /// <param name="maxDegreeOfParallelism">Optional, An integer that represents the maximum degree of parallelism,
    /// Must be grater than 0</param>
    /// <returns>A Task representing an async operation</returns>
    /// <exception cref="ArgumentOutOfRangeException">If the maxActionsToRunInParallel is less than 1</exception>
    public static async Task ForEachAsyncConcurrent<T>(
        this IEnumerable<T> enumerable,
        Func<T, Task> action,
        int? maxDegreeOfParallelism = null)
    {
        if (maxDegreeOfParallelism.HasValue)
        {
            using (var semaphoreSlim = new SemaphoreSlim(
                maxDegreeOfParallelism.Value, maxDegreeOfParallelism.Value))
            {
                var tasksWithThrottler = new List<Task>();

                foreach (var item in enumerable)
                {
                    // Increment the number of currently running tasks and wait if they are more than limit.
                    await semaphoreSlim.WaitAsync();

                    tasksWithThrottler.Add(Task.Run(async () =>
                    {
                        await action(item).ContinueWith(res =>
                        {
                            // action is completed, so decrement the number of currently running tasks
                            semaphoreSlim.Release();
                        });
                    }));
                }

                // Wait for all tasks to complete.
                await Task.WhenAll(tasksWithThrottler.ToArray());
            }
        }
        else
        {
            await Task.WhenAll(enumerable.Select(item => action(item)));
        }
    }

Використання зразка:

await enumerable.ForEachAsyncConcurrent(
    async item =>
    {
        await SomeAsyncMethod(item);
    },
    5);

Можна або використовувати

Parallel.Invoke(() =>
{
    HttpService1Async();
},
() =>
{   
    HttpService2Async();
});

або

Task task1 = Task.Run(() => HttpService1Async());
Task task2 = Task.Run(() => HttpService2Async());

//If you wish, you can wait for a particular task to return here like this:
task1.Wait();