Async tunggu di linq pilih

Saya perlu memodifikasi program yang sudah ada dan berisi kode berikut:

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

Tetapi ini terasa sangat aneh bagi saya, pertama-tama penggunaan asyncdan awaitdalam pemilihan. Menurut jawaban Stephen Cleary ini, saya seharusnya bisa menghilangkannya.

Lalu yang kedua Selectyang memilih hasilnya. Bukankah ini berarti tugas sama sekali bukan asinkron dan dilakukan secara serempak (begitu banyak usaha sia-sia), atau akankah tugas dilakukan secara serempak dan ketika selesai, sisa permintaan dieksekusi?

Haruskah saya menulis kode di atas seperti mengikuti menurut jawaban lain oleh Stephen Cleary :

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

dan apakah ini sama seperti ini?

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

Sementara saya sedang mengerjakan proyek ini saya ingin mengubah contoh kode pertama tetapi saya tidak terlalu tertarik untuk mengubah kode async (tampaknya bekerja). Mungkin saya hanya mengkhawatirkan apa-apa dan ketiga sampel kode melakukan hal yang persis sama?

ProcessEventsAsync terlihat seperti ini:

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

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

Tapi ini terasa sangat aneh bagi saya, pertama-tama penggunaan async dan menunggu di pilih. Menurut jawaban Stephen Cleary ini, saya seharusnya bisa menghilangkannya.

Panggilan ke Selectvalid. Kedua garis ini pada dasarnya identik:

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

(Ada sedikit perbedaan tentang bagaimana pengecualian sinkron akan dilempar dari ProcessEventAsync, tetapi dalam konteks kode ini tidak masalah sama sekali.)

Kemudian Pilih kedua yang memilih hasilnya. Bukankah ini berarti tugasnya sama sekali tidak async dan dilakukan secara serempak (begitu banyak usaha sia-sia), atau akankah tugas itu dilakukan secara serempak dan ketika selesai, sisa permintaan dieksekusi?

Ini berarti bahwa kueri sedang memblokir. Jadi itu tidak benar-benar tidak sinkron.

Hancurkan:

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

pertama-tama akan memulai operasi asinkron untuk setiap peristiwa. Maka baris ini:

                   .Select(t => t.Result)

akan menunggu operasi tersebut selesai satu per satu (pertama menunggu operasi acara pertama, lalu berikutnya, lalu berikutnya, dll).

Ini adalah bagian yang saya tidak peduli, karena itu memblokir dan juga akan membungkus pengecualian AggregateException.

dan apakah ini sama seperti ini?

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

Ya, kedua contoh itu setara. Keduanya memulai semua operasi asinkron (events.Select(...) ), lalu menunggu secara tak sinkron untuk semua operasi selesai dalam urutan apa pun ( await Task.WhenAll(...)), kemudian melanjutkan dengan sisa pekerjaan ( Where...).

Kedua contoh ini berbeda dari kode aslinya. Kode asli diblokir dan akan membungkus pengecualian dalam AggregateException.

Kode yang ada berfungsi, tetapi memblokir utas.

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

membuat Tugas baru untuk setiap acara, tetapi

.Select(t => t.Result)

memblokir utas menunggu setiap tugas baru berakhir.

Di sisi lain kode Anda menghasilkan hasil yang sama tetapi tetap tidak sinkron.

Hanya satu komentar pada kode pertama Anda. Garis ini

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

akan menghasilkan Tugas tunggal sehingga variabel harus dinamai dalam singular.

Akhirnya kode terakhir Anda menghasilkan hal yang sama tetapi lebih ringkas

Untuk referensi: Task.Wait / Task.WhenAll

Dengan metode saat ini tersedia di Linq terlihat sangat jelek:

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

Semoga versi berikut. NET akan datang dengan tooling yang lebih elegan untuk menangani koleksi tugas dan tugas koleksi.

Saya menggunakan kode ini:

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

seperti ini:

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

Saya lebih suka ini sebagai metode ekstensi:

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

Sehingga dapat digunakan dengan metode chaining:

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