Гніздування чекають у Parallel.ForEach

У програмі метро мені потрібно виконати ряд дзвінків WCF. Здійснюється значна кількість дзвінків, тому мені потрібно робити їх у паралельному циклі. Проблема полягає в тому, що паралельний цикл виходить до завершення дзвінків WCF.

Як би ви відреагували, щоб це працювало так, як очікувалося?

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

Вся ідея Parallel.ForEach()полягає в тому, що у вас є набір потоків, і кожен потік обробляє частину колекції. Як ви помітили, це не працює з async- await, де ви хочете звільнити потік протягом тривалості виклику асинхронізації.

Ви можете це "виправити", блокуючи ForEach()нитки, але це перемагає всю точку async- await.

Що ви можете зробити, це використовувати TPL Dataflow замість Parallel.ForEach(), який підтримує асинхронний Tasks добре.

Зокрема, ваш код може бути записаний за допомогою символу a, TransformBlockякий перетворює кожен ідентифікатор у Customerвикористовуваний asyncлямбда. Цей блок можна налаштувати паралельно виконувати. Ви б зв'язали цей блок із тим, ActionBlockщо пише кожен Customerна консоль. Після налаштування блокової мережі Post()кожен ідентифікатор можна перейти до TransformBlock.

У коді:

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

Хоча ви, мабуть, хочете обмежити паралелізм TransformBlockна деякій невеликій постійній. Крім того, ви можете обмежити ємність TransformBlockта додати до неї елементи асинхронно, використовуючи SendAsync(), наприклад, якщо колекція занадто велика.

В якості додаткової переваги в порівнянні з вашим кодом (якщо він працював) є те, що запис розпочнеться, як тільки один елемент буде закінчено, а не чекати, поки вся обробка завершена.

Відповідь svick (як завжди) відмінна.

Однак я вважаю Потік даних кориснішим, коли ви фактично маєте велику кількість даних для передачі. Або коли вам потрібна async-сумісна черга.

У вашому випадку більш простим рішенням є просто використовувати asyncпаралелізм -style:

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

Використання DataFlow як запропонованого svick може бути надмірним, а відповідь Стівена не передбачає засобів для контролю одночасності операції. Однак цього можна досягти досить просто:

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

Ці ToArray()виклики можуть бути оптимізовані за допомогою масиву замість списку і замінити завершення завдання, але я сумніваюся , що це буде робити велику частину різниці в більшості сценаріїв. Вибір використання за запитом ОП:

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

Користувач EDIT Fellow SO та майстер TPL Eli Arbel вказав мені на відповідну статтю Стівена Туба . Як завжди, його реалізація є одночасно елегантною та ефективною:

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

        })); 
}

Ви можете зекономити зусилля за допомогою нового пакету NuGet AsyncEnumerator , який не існував 4 роки тому, коли питання було опубліковано спочатку. Це дозволяє контролювати ступінь паралелізму:

using System.Collections.Async;
...

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

Відмова: Я є автором бібліотеки AsyncEnumerator, яка є відкритим кодом і має ліцензію в рамках MIT, і я публікую це повідомлення лише для того, щоб допомогти громаді.

Згорніть текст Parallel.Foreachу Task.Run()та замість awaitключового слова[yourasyncmethod].Result

(вам потрібно зробити завдання Task.Run, щоб не блокувати потік інтерфейсу)

Щось на зразок цього:

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

Це має бути досить ефективно та простіше, ніж налагодити роботу всього потоку даних 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;
}

Я трохи запізнююся на вечірку, але ви, можливо, захочете скористатися GetAwaiter.GetResult () для запуску коду асинхронізації в контексті синхронізації, але паралельно, як показано нижче;

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

Метод розширення для цього використовує 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);

Ввівши купу допоміжних методів, ви зможете виконувати паралельні запити з цим простим синтаксисом:

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

Що відбувається тут: ми розділимо колекцію джерел на 10 фрагментів ( .Split(DegreeOfParallelism)), потім запустимо 10 завдань, обробляючи їх по черзі ( .SelectManyAsync(...)), і об'єднаємо їх назад в один список.

Варто згадати і простіший підхід:

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

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

Методи розширення, які використовуються у наведених вище прикладах, виглядають так:

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