Async attendent dans linq select

J'ai besoin de modifier un programme existant et il contient le code suivant:

var inputs = events.Select(async ev => await ProcessEventAsync(ev))
                   .Select(t => t.Result)
                   .Where(i => i != null)
                   .ToList();

Mais cela me semble très étrange, tout d'abord l'utilisation de asyncet awaitdans le select. D'après cette réponse de Stephen Cleary, je devrais pouvoir les supprimer.

Puis le second Selectqui sélectionne le résultat. Cela ne signifie-t-il pas que la tâche n'est pas du tout asynchrone et est exécutée de manière synchrone (tant d'efforts pour rien), ou la tâche sera-t-elle exécutée de manière asynchrone et lorsqu'elle est terminée, le reste de la requête est exécuté?

Dois-je écrire le code ci-dessus comme suit selon une autre réponse de Stephen Cleary :

var tasks = await Task.WhenAll(events.Select(ev => ProcessEventAsync(ev)));
var inputs = tasks.Where(result => result != null).ToList();

et est-ce complètement pareil?

var inputs = (await Task.WhenAll(events.Select(ev => ProcessEventAsync(ev))))
                                       .Where(result => result != null).ToList();

Pendant que je travaille sur ce projet, j'aimerais changer le premier exemple de code, mais je ne suis pas trop désireux de changer (apparemment en train de travailler) le code async. Peut-être que je ne m'inquiète pour rien et que les 3 exemples de code font exactement la même chose?

ProcessEventsAsync ressemble à ceci:

async Task<InputResult> ProcessEventAsync(InputEvent ev) {...}

var inputs = events.Select(async ev => await ProcessEventAsync(ev))
                   .Select(t => t.Result)
                   .Where(i => i != null)
                   .ToList();

Mais cela me semble très étrange, tout d'abord l'utilisation de l'async et attendre dans le select. D'après cette réponse de Stephen Cleary, je devrais pouvoir les supprimer.

L'appel à Selectest valide. Ces deux lignes sont essentiellement identiques:

events.Select(async ev => await ProcessEventAsync(ev))
events.Select(ev => ProcessEventAsync(ev))

(Il y a une différence mineure concernant la façon dont une exception synchrone serait lancée ProcessEventAsync, mais dans le contexte de ce code, cela n'a pas d'importance.)

Puis le second Select qui sélectionne le résultat. Cela ne signifie-t-il pas que la tâche n'est pas du tout asynchrone et qu'elle est exécutée de manière synchrone (tant d'efforts pour rien), ou la tâche sera-t-elle exécutée de manière asynchrone et lorsqu'elle est terminée, le reste de la requête est exécuté?

Cela signifie que la requête est bloquante. Ce n'est donc pas vraiment asynchrone.

Décomposer:

var inputs = events.Select(async ev => await ProcessEventAsync(ev))

démarrera d'abord une opération asynchrone pour chaque événement. Puis cette ligne:

                   .Select(t => t.Result)

attendra que ces opérations se terminent une à la fois (il attend d'abord l'opération du premier événement, puis la suivante, puis la suivante, etc.).

C'est la partie qui ne m'intéresse pas, car elle bloque et englobe également toutes les exceptions AggregateException.

et est-ce complètement pareil?

var tasks = await Task.WhenAll(events.Select(ev => ProcessEventAsync(ev)));
var inputs = tasks.Where(result => result != null).ToList();

var inputs = (await Task.WhenAll(events.Select(ev => ProcessEventAsync(ev))))
                                       .Where(result => result != null).ToList();

Oui, ces deux exemples sont équivalents. Ils démarrent tous les deux toutes les opérations asynchrones ( events.Select(...)), puis attendent de manière asynchrone que toutes les opérations se terminent dans n'importe quel ordre ( await Task.WhenAll(...)), puis poursuivent le reste du travail ( Where...).

Ces deux exemples sont différents du code d'origine. Le code d'origine est bloquant et encapsulera les exceptions AggregateException.

Le code existant fonctionne, mais bloque le thread.

.Select(async ev => await ProcessEventAsync(ev))

crée une nouvelle tâche pour chaque événement, mais

.Select(t => t.Result)

bloque le thread qui attend la fin de chaque nouvelle tâche.

En revanche, votre code produit le même résultat mais reste asynchrone.

Juste un commentaire sur votre premier code. Cette ligne

var tasks = await Task.WhenAll(events...

produira une seule tâche donc la variable doit être nommée au singulier.

Enfin votre dernier code fait la même chose mais est plus succinct

Pour référence: Task.Wait / Task.WhenAll

Avec les méthodes actuelles disponibles dans Linq, cela semble assez moche:

var tasks = items.Select(
    async item => new
    {
        Item = item,
        IsValid = await IsValid(item)
    });
var tuples = await Task.WhenAll(tasks);
var validItems = tuples
    .Where(p => p.IsValid)
    .Select(p => p.Item)
    .ToList();

Espérons que les versions suivantes de .NET proposeront des outils plus élégants pour gérer des collections de tâches et des tâches de collections.

J'ai utilisé ce code:

public static async Task<IEnumerable<TResult>> SelectAsync<TSource,TResult>(this IEnumerable<TSource> source, Func<TSource, Task<TResult>> method)
{
      return await Task.WhenAll(source.Select(async s => await method(s)));
}

comme ça:

var result = await sourceEnumerable.SelectAsync(async s=>await someFunction(s,other params));

Je préfère cela comme méthode d'extension:

public static async Task<IEnumerable<T>> WhenAll<T>(this IEnumerable<Task<T>> tasks)
{
    return await Task.WhenAll(tasks);
}

Pour qu'il soit utilisable avec le chaînage de méthodes:

var inputs = await events
  .Select(async ev => await ProcessEventAsync(ev))
  .WhenAll()