L'annidamento ti aspetta in Parallel.ForEach

In un'app della metropolitana, devo eseguire una serie di chiamate WCF. Vi è un numero significativo di chiamate da effettuare, quindi devo eseguirle in un ciclo parallelo. Il problema è che il ciclo parallelo termina prima che le chiamate WCF siano tutte complete.

Come rifatteresti questo per funzionare come previsto?

var ids = new List<string>() { "1", "2", "3", "4", "5", "6", "7", "8", "9", "10" };
var customers = new  System.Collections.Concurrent.BlockingCollection<Customer>();

Parallel.ForEach(ids, async i =>
{
    ICustomerRepo repo = new CustomerRepo();
    var cust = await repo.GetCustomer(i);
    customers.Add(cust);
});

foreach ( var customer in customers )
{
    Console.WriteLine(customer.ID);
}

Console.ReadKey();

L'idea alla base Parallel.ForEach()è che hai un set di thread e ogni thread elabora parte della raccolta. Come hai notato, questo non funziona con async- await, dove vuoi rilasciare il thread per la durata della chiamata asincrona.

Potresti "sistemarlo" bloccando i ForEach()thread, ma questo sconfigge l'intero punto di async- await.

Quello che potresti fare è usare TPL Dataflow invece di Parallel.ForEach(), che supporta Taskbene i asincroni .

In particolare, il tuo codice potrebbe essere scritto usando un TransformBlockche trasforma ogni id in un Customerusando il asynclambda. Questo blocco può essere configurato per l'esecuzione in parallelo. Collegheresti quel blocco a un oggetto ActionBlockche scrive ciascuno Customersulla console. Dopo aver configurato la rete a blocchi, è possibile Post()ciascun ID per il TransformBlock.

Nel codice:

var ids = new List<string> { "1", "2", "3", "4", "5", "6", "7", "8", "9", "10" };

var getCustomerBlock = new TransformBlock<string, Customer>(
    async i =>
    {
        ICustomerRepo repo = new CustomerRepo();
        return await repo.GetCustomer(i);
    }, new ExecutionDataflowBlockOptions
    {
        MaxDegreeOfParallelism = DataflowBlockOptions.Unbounded
    });
var writeCustomerBlock = new ActionBlock<Customer>(c => Console.WriteLine(c.ID));
getCustomerBlock.LinkTo(
    writeCustomerBlock, new DataflowLinkOptions
    {
        PropagateCompletion = true
    });

foreach (var id in ids)
    getCustomerBlock.Post(id);

getCustomerBlock.Complete();
writeCustomerBlock.Completion.Wait();

Anche se probabilmente vuoi limitare il parallelismo della TransformBlocka qualche piccola costante. Inoltre, è possibile limitare la capacità di TransformBlocke aggiungere gli elementi ad esso in modo asincrono utilizzando SendAsync(), ad esempio, se la raccolta è troppo grande.

Come ulteriore vantaggio rispetto al tuo codice (se ha funzionato) è che la scrittura inizierà non appena un singolo articolo è finito e non attendere fino al termine di tutta l'elaborazione.

la risposta di svick è (come al solito) eccellente.

Tuttavia, trovo che il flusso di dati sia più utile quando in realtà hai grandi quantità di dati da trasferire. O quando hai bisogno di una asynccoda compatibile.

Nel tuo caso, una soluzione più semplice è usare solo il asyncparallelismo di tipo:

var ids = new List<string>() { "1", "2", "3", "4", "5", "6", "7", "8", "9", "10" };

var customerTasks = ids.Select(i =>
  {
    ICustomerRepo repo = new CustomerRepo();
    return repo.GetCustomer(i);
  });
var customers = await Task.WhenAll(customerTasks);

foreach (var customer in customers)
{
  Console.WriteLine(customer.ID);
}

Console.ReadKey();

L'uso di DataFlow come suggerito da svick può essere eccessivo e la risposta di Stephen non fornisce i mezzi per controllare la concorrenza dell'operazione. Tuttavia, ciò può essere ottenuto piuttosto semplicemente:

public static async Task RunWithMaxDegreeOfConcurrency<T>(
     int maxDegreeOfConcurrency, IEnumerable<T> collection, Func<T, Task> taskFactory)
{
    var activeTasks = new List<Task>(maxDegreeOfConcurrency);
    foreach (var task in collection.Select(taskFactory))
    {
        activeTasks.Add(task);
        if (activeTasks.Count == maxDegreeOfConcurrency)
        {
            await Task.WhenAny(activeTasks.ToArray());
            //observe exceptions here
            activeTasks.RemoveAll(t => t.IsCompleted); 
        }
    }
    await Task.WhenAll(activeTasks.ToArray()).ContinueWith(t => 
    {
        //observe exceptions in a manner consistent with the above   
    });
}

Le ToArray()chiamate possono essere ottimizzate utilizzando un array anziché un elenco e sostituendo le attività completate, ma dubito che farebbe molta differenza nella maggior parte degli scenari. Esempio di utilizzo secondo la domanda del PO:

RunWithMaxDegreeOfConcurrency(10, ids, async i =>
{
    ICustomerRepo repo = new CustomerRepo();
    var cust = await repo.GetCustomer(i);
    customers.Add(cust);
});

EDIT Fellow SO e la maga TPL Eli Arbel mi hanno indicato un articolo correlato di Stephen Toub . Come al solito, la sua implementazione è sia elegante che efficiente:

public static Task ForEachAsync<T>(
      this IEnumerable<T> source, int dop, Func<T, Task> body) 
{ 
    return Task.WhenAll( 
        from partition in Partitioner.Create(source).GetPartitions(dop) 
        select Task.Run(async delegate { 
            using (partition) 
                while (partition.MoveNext()) 
                    await body(partition.Current).ContinueWith(t => 
                          {
                              //observe exceptions
                          });

        })); 
}

Puoi risparmiare sforzo con il nuovo pacchetto NuGet di AsyncEnumerator , che non esisteva 4 anni fa quando la domanda era stata originariamente pubblicata. Ti permette di controllare il grado di parallelismo:

using System.Collections.Async;
...

await ids.ParallelForEachAsync(async i =>
{
    ICustomerRepo repo = new CustomerRepo();
    var cust = await repo.GetCustomer(i);
    customers.Add(cust);
},
maxDegreeOfParallelism: 10);

Disclaimer: sono l'autore della libreria AsyncEnumerator, che è open source e con licenza MIT, e sto pubblicando questo messaggio solo per aiutare la comunità.

Avvolgi Parallel.Foreachin a Task.Run()e invece della awaitparola chiave use[yourasyncmethod].Result

(è necessario eseguire l'attività Task.Run per non bloccare il thread dell'interfaccia utente)

Qualcosa come questo:

var yourForeachTask = Task.Run(() =>
        {
            Parallel.ForEach(ids, i =>
            {
                ICustomerRepo repo = new CustomerRepo();
                var cust = repo.GetCustomer(i).Result;
                customers.Add(cust);
            });
        });
await yourForeachTask;

Questo dovrebbe essere piuttosto efficiente e più semplice rispetto al funzionamento dell'intero flusso di dati TPL:

var customers = await ids.SelectAsync(async i =>
{
    ICustomerRepo repo = new CustomerRepo();
    return await repo.GetCustomer(i);
});

...

public static async Task<IList<TResult>> SelectAsync<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, Task<TResult>> selector, int maxDegreesOfParallelism = 4)
{
    var results = new List<TResult>();

    var activeTasks = new HashSet<Task<TResult>>();
    foreach (var item in source)
    {
        activeTasks.Add(selector(item));
        if (activeTasks.Count >= maxDegreesOfParallelism)
        {
            var completed = await Task.WhenAny(activeTasks);
            activeTasks.Remove(completed);
            results.Add(completed.Result);
        }
    }

    results.AddRange(await Task.WhenAll(activeTasks));
    return results;
}

Sono un po 'in ritardo per festeggiare, ma potresti prendere in considerazione l'utilizzo di GetAwaiter.GetResult () per eseguire il tuo codice asincrono nel contesto di sincronizzazione ma parallelamente come di seguito;

 Parallel.ForEach(ids, i =>
{
    ICustomerRepo repo = new CustomerRepo();
    // Run this in thread which Parallel library occupied.
    var cust = repo.GetCustomer(i).GetAwaiter().GetResult();
    customers.Add(cust);
});

Un metodo di estensione per questo che utilizza SemaphoreSlim e consente anche 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);

Dopo aver introdotto una serie di metodi di supporto, sarai in grado di eseguire query parallele con questa semplice sintassi:

const int DegreeOfParallelism = 10;
IEnumerable<double> result = await Enumerable.Range(0, 1000000)
    .Split(DegreeOfParallelism)
    .SelectManyAsync(async i => await CalculateAsync(i).ConfigureAwait(false))
    .ConfigureAwait(false);

Quello che succede qui è: suddividiamo la raccolta di sorgenti in 10 blocchi ( .Split(DegreeOfParallelism)), quindi eseguiamo 10 attività ognuna elaborando i suoi elementi uno per uno ( .SelectManyAsync(...)) e unendoli nuovamente in un unico elenco.

Vale la pena ricordare che esiste un approccio più semplice:

double[] result2 = await Enumerable.Range(0, 1000000)
    .Select(async i => await CalculateAsync(i).ConfigureAwait(false))
    .WhenAll()
    .ConfigureAwait(false);

Ma ha bisogno di una precauzione : se hai una raccolta di origine troppo grande, pianificherà Taskimmediatamente un oggetto per ogni elemento, il che potrebbe causare importanti risultati in termini di prestazioni.

I metodi di estensione utilizzati negli esempi precedenti sono i seguenti:

public static class CollectionExtensions
{
    /// <summary>
    /// Splits collection into number of collections of nearly equal size.
    /// </summary>
    public static IEnumerable<List<T>> Split<T>(this IEnumerable<T> src, int slicesCount)
    {
        if (slicesCount <= 0) throw new ArgumentOutOfRangeException(nameof(slicesCount));

        List<T> source = src.ToList();
        var sourceIndex = 0;
        for (var targetIndex = 0; targetIndex < slicesCount; targetIndex++)
        {
            var list = new List<T>();
            int itemsLeft = source.Count - targetIndex;
            while (slicesCount * list.Count < itemsLeft)
            {
                list.Add(source[sourceIndex++]);
            }

            yield return list;
        }
    }

    /// <summary>
    /// Takes collection of collections, projects those in parallel and merges results.
    /// </summary>
    public static async Task<IEnumerable<TResult>> SelectManyAsync<T, TResult>(
        this IEnumerable<IEnumerable<T>> source,
        Func<T, Task<TResult>> func)
    {
        List<TResult>[] slices = await source
            .Select(async slice => await slice.SelectListAsync(func).ConfigureAwait(false))
            .WhenAll()
            .ConfigureAwait(false);
        return slices.SelectMany(s => s);
    }

    /// <summary>Runs selector and awaits results.</summary>
    public static async Task<List<TResult>> SelectListAsync<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, Task<TResult>> selector)
    {
        List<TResult> result = new List<TResult>();
        foreach (TSource source1 in source)
        {
            TResult result1 = await selector(source1).ConfigureAwait(false);
            result.Add(result1);
        }
        return result;
    }

    /// <summary>Wraps tasks with Task.WhenAll.</summary>
    public static Task<TResult[]> WhenAll<TResult>(this IEnumerable<Task<TResult>> source)
    {
        return Task.WhenAll<TResult>(source);
    }
}