LINQ Sélectionnez analogique pour la méthode asynchrone

Vous pouvez utiliser les primitives de synchronisation

    class Program
    {
        static async Task Main(string[] args)
        {
            var waitHandle = new AutoResetEvent(true);
            var result = Enumerable
                .Range(0, 3)
                .Select(async (int param) => {
                    waitHandle.WaitOne();
                    await TestMethod(param);
                    waitHandle.Set();
                }).ToArray();
            Console.ReadKey();
        }
        private static async Task<int> TestMethod(int param)
        {
            Console.WriteLine($"{param} before");
            await Task.Delay(50);
            Console.WriteLine($"{param} after");
            return param;
        }
    }

Je rencontre régulièrement cette exigence et je ne connais aucune solution intégrée pour y répondre comme en C # 7.2. Je reviens généralement à l'utilisation de await sur chaque opération asynchrone dans un foreach , mais vous pouvez choisir votre méthode d'extension:

static async Task Main(string[] args)
{
    var result = (await Enumerable.Range(0, 3).SelectAsync(x => TestMethod(x))).ToArray();
    Console.ReadKey();
}

Vous appelleriez alors wait sur le SelectAsync:

public static class EnumerableExtensions
{
    public static async Task<IEnumerable<TResult>> SelectAsync<TSource, TResult>(
        this IEnumerable<TSource> source,
        Func<TSource, Task<TResult>> asyncSelector)
    {
        var results = new List<TResult>();
        foreach (var item in source)
            results.Add(await asyncSelector(item));
        return results;
    }
}

L'inconvénient de cette approche est que le SelectAsync est impatient, pas paresseux. C # 8 promet d'introduire des flux asynchrones , ce qui permettra de redevenir paresseux.

Vous devez être conscient de ce qu'est un objet Enumerable. Un objet Enumerable n'est pas l'énumération elle-même. Cela vous donne la possibilité d'obtenir un objet Enumerator. Si vous avez un objet Enumerator, vous pouvez demander les premiers éléments d'une séquence, et une fois que vous avez un élément énuméré, vous pouvez demander le suivant.

Donc, créer un objet qui vous permet d'énumérer sur une séquence, n'a rien à voir avec l'énumération elle-même.

Votre fonction Select renvoie uniquement un objet Enumerable, elle ne démarre pas l'énumération. L'énumération est lancée par ToArray.

Au niveau le plus bas, l'énumération se fait comme suit:

 var result = Enumerable.Range(0, 3)
     .Select(i => TestMethod(i))
     .ToListAsync();

ToArray appellera en interne GetEnumerator et MoveNext . Donc, pour rendre votre instruction LINQ asynchrone, vous aurez besoin d'un ToArrayAsync.

Le code est assez simple. Je vais vous montrer ToListAsync comme une méthode d'extension, ce qui est un peu plus facile à faire.

static class EnumerableAsyncExtensions
{
    public static async Task<List<TSource>> ToListAsync<TSource>(
       this IEnumerable<Task<TSource>> source)
    {
        List<TSource> result = new List<TSource>();
        var enumerator = source.GetEnumerator()
        while (enumerator.MoveNext())
        {
            // in baby steps. Feel free to do this in one step
            Task<TSource> current = enumerator.Current;
            TSource awaitedCurrent = await current;
            result.Add(awaitedCurrent);
        }
        return result;
    } 
}

Vous n'aurez à créer cela qu'une seule fois. Vous pouvez l'utiliser pour n'importe quel ToListAsync où vous devrez attendre pour chaque élément:

IEnumerable<TSource> myEnumerable = ...
IEnumerator<TSource> enumerator = myEnumerable.GetEnumerator();
while (enumerator.MoveNext())
{
     // there is still an element in the enumeration
     TSource currentElement = enumerator.Current;
     Process(currentElement);
}

Notez que le retour de Select est IEnumerable > : un objet qui permet d'énumérer une séquence d'objets Task . Dans un foreach, à chaque cycle, vous obtenez une Task