Llamar a múltiples servicios asíncronos en paralelo

Tengo pocos servicios REST asíncronos que no dependen unos de otros. Es decir, mientras "espero" una respuesta del Servicio1, puedo llamar al Servicio2, al Servicio3, etc.

Por ejemplo, consulte el siguiente código:

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

// Use service1Response and service2Response

Ahora, service2Responseno depende service1Responsey se pueden obtener de forma independiente. Por lo tanto, no es necesario que espere la respuesta del primer servicio para llamar al segundo servicio.

No creo que pueda usar Parallel.ForEachaquí, ya que no es una operación vinculada a la CPU.

Para llamar a estas dos operaciones en paralelo, ¿puedo llamar al uso Task.WhenAll? Un problema que veo usando Task.WhenAlles que no devuelve resultados. Para obtener el resultado, ¿puedo llamar task.Resultdespués de llamar Task.WhenAll, ya que todas las tareas ya se han completado y todo lo que necesito para obtener una respuesta?

Código de muestra:

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

await Task.WhenAll(task1, task2)

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

// Use result1 and result2

¿Es este código mejor que el primero en términos de rendimiento? ¿Algún otro enfoque que pueda usar?

Un problema que veo usando Task.WhenAll es que no devuelve resultados

Pero sí devuelve los resultados. Todos estarán en una matriz de un tipo común, por lo que no siempre es útil usar los resultados ya que necesita encontrar el elemento en la matriz que corresponde al Taskresultado para el que desea el resultado, y potencialmente convertirlo en su tipo real, por lo que podría no ser el enfoque más fácil / más legible en este contexto, pero cuando solo desea obtener todos los resultados de cada tarea, y el tipo común es el tipo con el que desea tratarlos, entonces es genial .

Para obtener el resultado, ¿puedo llamar a task.Result después de llamar a Task.WhenAll, ya que todas las tareas ya se han completado y todo lo que necesito para obtener respuesta?

Sí, puedes hacer eso. También podría awaitusarlos ( awaitdesenvolvería la excepción en cualquier tarea fallida, mientras Resultque lanzaría una excepción agregada, pero de lo contrario sería lo mismo).

¿Es este código mejor que el primero en términos de rendimiento?

Realiza las dos operaciones al mismo tiempo, en lugar de una y luego la otra. Que eso sea mejor o peor depende de cuáles sean esas operaciones subyacentes. Si las operaciones subyacentes son "leer un archivo del disco", entonces hacerlas en paralelo probablemente sea más lento, ya que solo hay un cabezal de disco y solo puede estar en un lugar en un momento dado; saltar entre dos archivos será más lento que leer un archivo y luego otro. Por otro lado, si las operaciones son "realizar alguna solicitud de red" (como es el caso aquí), entonces es muy probable que sean más rápidas (al menos hasta un cierto número de solicitudes concurrentes), porque puede esperar una respuesta desde otra computadora de red igual de rápido cuando también hay otra solicitud de red pendiente en curso. Si quieres saber si es así

¿Algún otro enfoque que pueda usar?

Si no es importante para usted que conozca todas las excepciones lanzadas entre todas las operaciones que está haciendo en paralelo en lugar de solo la primera, simplemente puede realizar awaitlas tareas sin WhenAllninguna. Lo único que WhenAllte da es tener una AggregateExceptionexcepción con cada una de las tareas con fallas, en lugar de tirar cuando llegas a la primera tarea con fallas. Es tan simple como:

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

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

Aquí está el método de extensión que hace uso de SemaphoreSlim y permite establecer el grado máximo de paralelismo

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

Uso de muestra:

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

Puedes usar

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