Linq Select'te zaman uyumsuz bekliyor

Varolan bir programı değiştirmek gerekir ve aşağıdaki kodu içerir:

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

Ama bu benim için çok garip görünüyor, her şeyden önce seçimde asyncve awaitseçimde. Göre bu cevap Stephen Cleary I tarafından bu düşmesi gerekir.

Sonra ikincisi Select sonucu seçen . Bu, görevin hiç zaman uyumsuz olmadığı ve eşzamanlı olarak gerçekleştirildiği (hiçbir şey için çok fazla çaba) olmadığı veya görev zaman uyumsuz olarak gerçekleştirileceği ve sorgunun geri kalanının yürütüldüğü anlamına gelmiyor mu?

Stephen Cleary tarafından başka bir cevaba göre yukarıdaki kodu aşağıdaki gibi yazmalıyım :

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

ve tamamen böyle mi?

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

Ben bu proje üzerinde çalışırken ben ilk kod örneğini değiştirmek istiyorum ama (görünüşte çalışan) zaman uyumsuz kod değiştirme konusunda çok istekli değilim. Belki sadece hiçbir şey için endişeleniyorum ve tüm 3 kod örnekleri aynı şeyi yapıyor?

ProcessEventsAsync şöyle görünür:

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

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

Ama bu benim için çok garip görünüyor, her şeyden önce seçimde async ve bekliyor. Stephen Cleary'nin bu cevabına göre bunları bırakabilmeliyim.

İçin çağrı Selectgeçerli. Bu iki çizgi aslında aynıdır:

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

(Eşzamanlı bir istisnanın nasıl atılacağı konusunda küçük bir fark vardır ProcessEventAsync, ancak bu kod bağlamında hiç önemli değildir.)

Sonra sonucu seçen ikinci Seçim. Bu, görevin hiç zaman uyumsuz olmadığı ve eşzamanlı olarak gerçekleştirildiği (hiçbir şey için çok fazla çaba) olmadığı veya görev zaman uyumsuz olarak gerçekleştirileceği ve sorgunun geri kalanının yürütüldüğü anlamına gelmiyor mu?

Bu, sorgunun engellendiği anlamına gelir. Yani gerçekten asenkron değil.

Yıkmak:

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

önce her olay için eşzamansız bir işlem başlatır. Sonra bu satır:

                   .Select(t => t.Result)

bu işlemlerin birer birer tamamlanmasını bekleyecektir (önce ilk olayın çalışmasını, sonra bir sonraki, sonra bir sonraki, vb.) bekler.

Bu benim umurumda değilim, çünkü herhangi bir istisnayı engeller ve sarar AggregateException.

ve tamamen böyle mi?

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

Evet, bu iki örnek eşdeğerdir. Her ikisi de tüm eşzamansız işlemleri ( events.Select(...)) başlatır , sonra eşzamansız olarak tüm işlemlerin herhangi bir sırayla ( await Task.WhenAll(...)) tamamlanmasını bekler , ardından işin geri kalanına ( Where...) devam eder.

Bu örneklerin her ikisi de orijinal koddan farklıdır. Orijinal kod engelleniyor ve istisnalar içeri girecek AggregateException.

Mevcut kod çalışıyor, ancak iş parçacığını engelliyor.

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

her etkinlik için yeni bir Görev oluşturur, ancak

.Select(t => t.Result)

her yeni görevin bitmesini bekleyen iş parçacığını engeller.

Diğer yandan kodunuz aynı sonucu verir, ancak eşzamansız tutar.

İlk kodunuz hakkında sadece bir yorum. Bu hat

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

tek bir Görev üretecek, böylece değişken tekil olarak adlandırılmalıdır.

Sonunda son kodunuz aynı ama daha özlü

Referans için: Görev Bekle / Görev.

Linq'te mevcut yöntemler ile oldukça çirkin görünüyor:

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

Umarım .NET'in aşağıdaki sürümleri, görev koleksiyonlarını ve koleksiyon görevlerini işlemek için daha zarif bir araç geliştirecektir.

Bu kodu kullandım:

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

bunun gibi:

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

Bunu bir uzantı yöntemi olarak tercih ederim:

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

Böylece yöntem zincirleme ile kullanılabilir:

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