Chiamata di più servizi asincroni in parallelo

Ho pochi servizi REST asincroni che non dipendono l'uno dall'altro. Cioè mentre "aspetto" una risposta da Service1, posso chiamare Service2, Service3 e così via.

Ad esempio, consultare il codice seguente:

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

// Use service1Response and service2Response

Ora, service2Responsenon dipende da service1Responsee possono essere recuperati in modo indipendente. Quindi, non è necessario che attenda la risposta del primo servizio per chiamare il secondo servizio.

Non credo di poter usare Parallel.ForEachqui poiché non è un'operazione legata alla CPU.

Per chiamare queste due operazioni in parallelo, posso chiamare use Task.WhenAll? Un problema che vedo usando Task.WhenAllè che non restituisce risultati. Per recuperare il risultato posso chiamare task.Resultdopo aver chiamato Task.WhenAll, dal momento che tutte le attività sono già state completate e tutto ciò di cui ho bisogno per ricevere risposta?

Codice d'esempio:

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

await Task.WhenAll(task1, task2)

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

// Use result1 and result2

Questo codice è migliore del primo in termini di prestazioni? Qualche altro approccio che posso usare?

Un problema che vedo usando Task.WhenAll è che non restituisce risultati

Ma fa restituire i risultati. Saranno tutti in una matrice di un tipo comune, quindi non è sempre utile usare i risultati in quanto è necessario trovare la voce nella matrice che corrisponde a quella per Taskcui si desidera il risultato e potenzialmente lanciarlo nella sua tipo reale, quindi potrebbe non essere l'approccio più semplice / più leggibile in questo contesto, ma quando vuoi solo avere tutti i risultati di ogni attività, e il tipo comune è il tipo con cui vuoi trattarli, quindi è fantastico .

Per recuperare il risultato posso chiamare task.Result dopo aver chiamato Task.WhenAll, poiché tutte le attività sono già state completate e tutto ciò di cui ho bisogno per recuperare la risposta?

Sì, potresti farlo. Potresti anche awaitloro ( awaitscartare l'eccezione in qualsiasi attività difettosa, mentre Resultlancerebbe un'eccezione aggregata, ma altrimenti sarebbe la stessa).

Questo codice è migliore del primo in termini di prestazioni?

Esegue le due operazioni contemporaneamente, anziché l'una e poi l'altra. Che sia meglio o peggio dipende da quali sono le operazioni sottostanti. Se le operazioni sottostanti sono "leggere un file dal disco", probabilmente è più lento eseguirle in parallelo, poiché esiste solo una testa del disco e può trovarsi in un solo posto in un dato momento; saltare tra due file sarà più lento della lettura di un file poi di un altro. D'altra parte, se le operazioni "eseguono alcune richieste di rete" (come nel caso qui), molto probabilmente saranno più veloci (almeno fino a un certo numero di richieste simultanee), perché puoi attendere una risposta da qualche altro computer di rete altrettanto velocemente quando c'è anche qualche altra richiesta di rete in sospeso. Se vuoi sapere se '

Qualche altro approccio che posso usare?

Se per te non è importante che tu conosca tutte le eccezioni lanciate tra tutte le operazioni che stai facendo in parallelo piuttosto che solo la prima, puoi semplicemente awaitsvolgere le attività senza WhenAllaffatto. L'unica cosa che WhenAllti dà è avere AggregateExceptionun'eccezione con ogni singola eccezione da ogni attività con errori, piuttosto che lanciare quando si colpisce la prima attività con errore. È semplice come:

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

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

Ecco il metodo di estensione che utilizza SemaphoreSlim e consente di impostare il massimo grado di parallelismo

    /// <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)));
        }
    }

Esempio di utilizzo:

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

Puoi usare entrambi

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

o

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();