Parallel.ForEach'ta yuvalama bekleniyor

Bir metro uygulamasında, bir dizi WCF çağrısı yürütmem gerekiyor. Yapılması gereken önemli sayıda arama var, bu yüzden bunları paralel bir döngüde yapmam gerekiyor. Sorun, WCF çağrıları tamamlanmadan önce paralel döngü çıkmasıdır.

Beklendiği gibi çalışması için bunu nasıl yeniden düzenlersiniz?

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

Arkasındaki tüm fikir Parallel.ForEach(), bir dizi iş parçacığına sahip olmanız ve her iş parçacığının koleksiyonun bir bölümünü işlemesidir. Fark ettiğiniz gibi, bu, zaman uyumsuz çağrı süresi boyunca iş parçacığını serbest bırakmak istediğiniz async- ile çalışmaz await.

Bunu, ForEach()iplikleri engelleyerek “düzeltebilirsiniz” , ancak bu async- ' nun bütün noktasını yener await.

Yapabileceğiniz şey , asenkronleri iyi destekleyen TPL Dataflow'u kullanmaktır .Parallel.ForEach()Task

Özellikle, kodunuz TransformBlockher kimliği lambda Customerkullanarak bir dönüştüren bir kullanılarak yazılabilir async. Bu blok paralel çalışacak şekilde yapılandırılabilir. Bu bloğu ActionBlock, her Customerbirini konsola yazan bir bloğa bağlarsınız. Engelleme ağını kurduktan sonra, Post()her kimliğiTransformBlock .

Kodda:

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

Muhtemelen paralelliğini TransformBlockbazı küçük sabitlerle sınırlamak isteseniz de . Ayrıca, örneğin koleksiyon çok büyükse, öğesinin kapasitesini sınırlayabilir TransformBlockve öğeleri eşzamansız olarak ekleyebilirsiniz SendAsync().

Kodunuzla karşılaştırıldığında (işe yaradıysa) ek bir avantaj olarak, yazı tek bir öğe biter bitmez başlayacak ve tüm işlemler bitinceye kadar beklemeyecektir.

svick cevabı (her zamanki gibi) mükemmel.

Ancak, aktarılacak büyük miktarda veriye sahip olduğunuzda Dataflow'un daha yararlı olduğunu düşünüyorum. Veya asyncuyumlu bir kuyruğa ihtiyacınız olduğunda .

Sizin durumunuzda, daha basit bir çözüm sadece async-style paralelliğini kullanmaktır :

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'u önerilen svick olarak kullanmak aşırıya kaçabilir ve Stephen'ın cevabı, operasyonun eşzamanlılığını kontrol etmek için araçlar sağlamaz. Ancak, bu oldukça basit bir şekilde elde edilebilir:

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()Çağrıları bir dizi yerine bir listesini kullanarak ve tamamlanan görevleri yerine optimize edilebilir, ama çok çoğu senaryolarda bir fark yapacak şüpheliyim. OP sorusu başına örnek kullanım:

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

EDIT üyesi SO kullanıcı ve TPL wiz Eli Arbel beni Stephen Toub'un ilgili bir makalesine yönlendirdi . Her zamanki gibi, uygulaması hem zarif hem de etkilidir:

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

        })); 
}

Sorunun asıl gönderildiği 4 yıl önce mevcut olmayan yeni AsyncEnumerator NuGet Paketi ile çabadan tasarruf edebilirsiniz . Paralellik derecesini kontrol etmenizi sağlar:

using System.Collections.Async;
...

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

Feragatname: Açık kaynak kodlu ve MIT altında lisanslanan AsyncEnumerator kütüphanesinin yazarıyım ve bu mesajı sadece topluluğa yardım etmek için gönderiyorum.

Anahtar kelime kullanımı yerine Parallel.Foreacha içine Task.Run()ve içine sarınawait[yourasyncmethod].Result

(UI iş parçacığını engellememek için Task.Run işlemini yapmanız gerekir)

Bunun gibi bir şey:

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

Bu oldukça verimli olmalı ve tüm TPL Dataflow'un çalışmasını sağlamaktan daha kolay olmalıdır:

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

Partiye biraz geç kaldım ama senkronize bağlamda ama aşağıda belirtildiği gibi paralel olmayan kodunuzu çalıştırmak için GetAwaiter.GetResult () kullanmayı düşünebilirsiniz;

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

Bunun için SemaphoreSlim'i kullanan ve aynı zamanda maksimum paralellik derecesini ayarlamaya izin veren bir uzatma yöntemi

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

Örnek Kullanımı:

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

Bir grup yardımcı yöntem girdikten sonra, bu basit sözdizimiyle paralel sorgular çalıştırabilirsiniz:

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

Burada olan: Kaynak koleksiyonunu 10 parçaya ( .Split(DegreeOfParallelism)) böldükten sonra, öğelerini teker teker işleyen 10 görev ( .SelectManyAsync(...)) yürütüyoruz ve bunları tek bir liste halinde birleştiriyoruz.

Bahsetmeye değer daha basit bir yaklaşım var:

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

Ancak bir önlem alınması gerekir : çok büyük bir kaynak koleksiyonunuz varsa, Taskhemen her öğe için bir zamanlama yapar ve bu da önemli performans isabetlerine neden olabilir.

Yukarıdaki örneklerde kullanılan genişletme yöntemleri aşağıdaki gibidir:

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