Comment puis-je utiliser Async avec ForEach?

Est-il possible d'utiliser Async lors de l'utilisation de ForEach? Voici le code que j'essaye:

using (DataContext db = new DataLayer.DataContext())
{
    db.Groups.ToList().ForEach(i => async {
        await GetAdminsFromGroup(i.Gid);
    });
}

J'obtiens l'erreur:

Le nom 'Async' n'existe pas dans le contexte actuel

La méthode dans laquelle l'instruction using est incluse est définie sur async.

List<T>.ForEachne joue pas particulièrement bien avec async(LINQ-to-objects non plus, pour les mêmes raisons).

Dans ce cas, je recommande de projeter chaque élément dans une opération asynchrone, et vous pouvez ensuite (de manière asynchrone) attendre qu'ils se terminent tous.

using (DataContext db = new DataLayer.DataContext())
{
    var tasks = db.Groups.ToList().Select(i => GetAdminsFromGroupAsync(i.Gid));
    var results = await Task.WhenAll(tasks);
}

Les avantages de cette approche par rapport au fait de donner à un asyncdélégué ForEachsont les suivants:

1. La gestion des erreurs est plus appropriée. Les exceptions à async voidne peuvent pas être prises avec catch; cette approche propagera les exceptions à la await Task.WhenAllligne, permettant une gestion naturelle des exceptions.
2. Vous savez que les tâches sont terminées à la fin de cette méthode, puisqu'elle fait un await Task.WhenAll. Si vous utilisez async void, vous ne pouvez pas facilement dire quand les opérations sont terminées.
3. Cette approche a une syntaxe naturelle pour récupérer les résultats. GetAdminsFromGroupAsyncressemble à une opération qui produit un résultat (les administrateurs), et un tel code est plus naturel si de telles opérations peuvent renvoyer leurs résultats plutôt que de définir une valeur comme effet secondaire.

Cette petite méthode d'extension devrait vous donner une itération asynchrone sans exception:

public static async Task ForEachAsync<T>(this List<T> list, Func<T, Task> func)
{
    foreach (var value in list)
    {
        await func(value);
    }
}

Puisque nous changeons le type de retour du lambda de voidà Task, les exceptions se propageront correctement. Cela vous permettra d'écrire quelque chose comme ça dans la pratique:

await db.Groups.ToList().ForEachAsync(async i => {
    await GetAdminsFromGroup(i.Gid);
});

La réponse simple est d'utiliser le foreachmot - clé au lieu de la ForEach()méthode de List().

using (DataContext db = new DataLayer.DataContext())
{
    foreach(var i in db.Groups)
    {
        await GetAdminsFromGroup(i.Gid);
    }
}

Voici une version de travail réelle des variantes async foreach ci-dessus avec traitement séquentiel:

public static async Task ForEachAsync<T>(this List<T> enumerable, Action<T> action)
{
    foreach (var item in enumerable)
        await Task.Run(() => { action(item); }).ConfigureAwait(false);
}

Voici la mise en œuvre:

public async void SequentialAsync()
{
    var list = new List<Action>();

    Action action1 = () => {
        //do stuff 1
    };

    Action action2 = () => {
        //do stuff 2
    };

    list.Add(action1);
    list.Add(action2);

    await list.ForEachAsync();
}

Quelle est la principale différence? .ConfigureAwait(false);qui conserve le contexte du thread principal pendant le traitement séquentiel asynchrone de chaque tâche.

En commençant par C# 8.0, vous pouvez créer et consommer des flux de manière asynchrone.

    private async void button1_Click(object sender, EventArgs e)
    {
        IAsyncEnumerable<int> enumerable = GenerateSequence();

        await foreach (var i in enumerable)
        {
            Debug.WriteLine(i);
        }
    }

    public static async IAsyncEnumerable<int> GenerateSequence()
    {
        for (int i = 0; i < 20; i++)
        {
            await Task.Delay(100);
            yield return i;
        }
    }

Plus

Ajouter cette méthode d'extension

public static class ForEachAsyncExtension
{
    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).ConfigureAwait(false);
            }));
    }
}

Et puis utilisez comme ceci:

Task.Run(async () =>
{
    var s3 = new AmazonS3Client(Config.Instance.Aws.Credentials, Config.Instance.Aws.RegionEndpoint);
    var buckets = await s3.ListBucketsAsync();

    foreach (var s3Bucket in buckets.Buckets)
    {
        if (s3Bucket.BucketName.StartsWith("mybucket-"))
        {
            log.Information("Bucket => {BucketName}", s3Bucket.BucketName);

            ListObjectsResponse objects;
            try
            {
                objects = await s3.ListObjectsAsync(s3Bucket.BucketName);
            }
            catch
            {
                log.Error("Error getting objects. Bucket => {BucketName}", s3Bucket.BucketName);
                continue;
            }

            // ForEachAsync (4 is how many tasks you want to run in parallel)
            await objects.S3Objects.ForEachAsync(4, async s3Object =>
            {
                try
                {
                    log.Information("Bucket => {BucketName} => {Key}", s3Bucket.BucketName, s3Object.Key);
                    await s3.DeleteObjectAsync(s3Bucket.BucketName, s3Object.Key);
                }
                catch
                {
                    log.Error("Error deleting bucket {BucketName} object {Key}", s3Bucket.BucketName, s3Object.Key);
                }
            });

            try
            {
                await s3.DeleteBucketAsync(s3Bucket.BucketName);
            }
            catch
            {
                log.Error("Error deleting bucket {BucketName}", s3Bucket.BucketName);
            }
        }
    }
}).Wait();

Le problème était que le asyncmot - clé doit apparaître avant le lambda, pas avant le corps:

db.Groups.ToList().ForEach(async (i) => {
    await GetAdminsFromGroup(i.Gid);
});