Async warten in linq select

Ich muss ein vorhandenes Programm ändern und es enthält folgenden Code:

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

Aber das scheint mir sehr seltsam, vor allem die Verwendung von asyncund awaitin der Auswahl. Nach dieser Antwort von Stephen Cleary sollte ich diese fallen lassen können.

Dann die zweite, Selectdie das Ergebnis auswählt. Bedeutet dies nicht, dass die Aufgabe überhaupt nicht asynchron ist und synchron ausgeführt wird (so viel Aufwand für nichts), oder wird die Aufgabe asynchron ausgeführt und wenn sie erledigt ist, wird der Rest der Abfrage ausgeführt?

Soll ich den obigen Code wie folgt schreiben, gemäß einer anderen Antwort von Stephen Cleary :

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

und ist es ganz so?

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

Während ich an diesem Projekt arbeite, möchte ich das erste Codebeispiel ändern, aber ich bin nicht besonders daran interessiert, asynchronen Code zu ändern (anscheinend zu funktionieren). Vielleicht mache ich mir nur um nichts Sorgen und alle 3 Codebeispiele machen genau das Gleiche?

ProcessEventsAsync sieht folgendermaßen aus:

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

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

Aber das scheint mir sehr seltsam, vor allem die Verwendung von Async und warten in der Auswahl. Nach dieser Antwort von Stephen Cleary sollte ich diese fallen lassen können.

Der Anruf an Selectist gültig. Diese beiden Zeilen sind im Wesentlichen identisch:

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

(Es gibt einen kleinen Unterschied, wie eine synchrone Ausnahme ausgelöst wird ProcessEventAsync, aber im Kontext dieses Codes spielt dies überhaupt keine Rolle.)

Dann die zweite Auswahl, die das Ergebnis auswählt. Bedeutet dies nicht, dass die Aufgabe überhaupt nicht asynchron ist und synchron ausgeführt wird (so viel Aufwand für nichts), oder wird die Aufgabe asynchron ausgeführt und wenn sie erledigt ist, wird der Rest der Abfrage ausgeführt?

Dies bedeutet, dass die Abfrage blockiert wird. Es ist also nicht wirklich asynchron.

Brechen sie ab:

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

startet zuerst eine asynchrone Operation für jedes Ereignis. Dann diese Zeile:

                   .Select(t => t.Result)

wartet darauf, dass diese Vorgänge nacheinander abgeschlossen werden (zuerst wird auf den Vorgang des ersten Ereignisses gewartet, dann auf den nächsten, dann auf den nächsten usw.).

Dies ist der Teil, den ich nicht mag, weil er blockiert und auch Ausnahmen einschließt AggregateException.

und ist es ganz so?

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

Ja, diese beiden Beispiele sind gleichwertig. Beide starten alle asynchronen Operationen ( events.Select(...)), warten dann asynchron, bis alle Operationen in beliebiger Reihenfolge abgeschlossen sind ( await Task.WhenAll(...)), und fahren dann mit dem Rest der Arbeit fort ( Where...).

Beide Beispiele unterscheiden sich vom ursprünglichen Code. Der ursprüngliche Code blockiert und schließt Ausnahmen ein AggregateException.

Vorhandener Code funktioniert, blockiert jedoch den Thread.

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

erstellt für jedes Ereignis eine neue Aufgabe, aber

.Select(t => t.Result)

Blockiert den Thread, der auf das Ende jeder neuen Aufgabe wartet.

Andererseits erzeugt Ihr Code das gleiche Ergebnis, bleibt jedoch asynchron.

Nur ein Kommentar zu Ihrem ersten Code. Diese Linie

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

erzeugt eine einzelne Aufgabe, daher sollte die Variable im Singular benannt werden.

Schließlich macht Ihr letzter Code dasselbe, ist aber prägnanter

Als Referenz: Task.Wait / Task.WhenAll

Mit den aktuellen in Linq verfügbaren Methoden sieht es ziemlich hässlich aus:

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

Hoffentlich werden die folgenden Versionen von .NET elegantere Tools für die Bearbeitung von Aufgabensammlungen und Aufgaben von Sammlungen bieten.

Ich habe diesen Code verwendet:

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

so was:

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

Ich bevorzuge dies als Erweiterungsmethode:

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

Damit es mit Methodenverkettung verwendet werden kann:

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