Async กำลังรอการเลือก linq

ฉันต้องการแก้ไขโปรแกรมที่มีอยู่และมันมีรหัสต่อไปนี้:

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

แต่สิ่งนี้ดูแปลกสำหรับฉันมากก่อนอื่นให้ใช้asyncและawaitเลือก ตามคำตอบของสตีเฟ่นเคลียร์ฉันควรจะทิ้งมันไว้

จากนั้นวินาทีSelectที่เลือกผลลัพธ์ นี่ไม่ได้หมายความว่างานนั้นไม่ได้เป็นแบบอะซิงก์เลยและดำเนินการแบบซิงโครนัส (ไม่ต้องใช้ความพยายามมากนัก) หรืองานนั้นจะทำงานแบบอะซิงโครนัส

ฉันควรเขียนโค้ดด้านบนเหมือนดังต่อไปนี้ตามคำตอบอื่นโดย Stephen Cleary :

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

ในขณะที่ฉันกำลังทำงานในโครงการนี้ฉันต้องการเปลี่ยนตัวอย่างโค้ดแรก แต่ฉันไม่กระตือรือร้นที่จะเปลี่ยนโค้ด async (ทำงานได้อย่างมั่นใจ) บางทีฉันแค่กังวลอะไรและตัวอย่างโค้ดทั้ง 3 ทำสิ่งเดียวกันหรือไม่

ProcessEventsAsync มีลักษณะเช่นนี้:

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

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

แต่สิ่งนี้ดูแปลกสำหรับฉันก่อนอื่นให้ใช้ async และรอคอยในตัวเลือก ตามคำตอบของสตีเฟ่นเคลียร์ฉันควรจะทิ้งมันไว้

การโทรถึงSelectถูกต้อง สองบรรทัดนี้เหมือนกันเป็นหลัก:

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

(มีความแตกต่างเล็กน้อยเกี่ยวกับวิธีโยนข้อยกเว้นแบบซิงโครนัProcessEventAsyncส แต่ในบริบทของรหัสนี้มันไม่สำคัญเลย)

จากนั้นเลือกที่สองซึ่งเลือกผลลัพธ์ นี่ไม่ได้หมายความว่างานนั้นไม่ได้เป็นแบบอะซิงก์เลยและดำเนินการแบบซิงโครนัส (ไม่มีความพยายามอะไรเลย) หรือจะทำงานแบบอะซิงโครนัสและเมื่อมีการดำเนินการแบบสอบถามที่เหลือ

หมายความว่าแบบสอบถามกำลังบล็อก ดังนั้นมันไม่ได้เป็นแบบอะซิงโครนัสจริงๆ

ทำลายมันลง:

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

จะเริ่มการทำงานแบบอะซิงโครนัสสำหรับแต่ละเหตุการณ์ก่อน จากนั้นบรรทัดนี้:

                   .Select(t => t.Result)

จะรอให้การดำเนินการเหล่านั้นเสร็จสิ้นทีละครั้ง (ก่อนจะรอการดำเนินการของเหตุการณ์แรกจากนั้นดำเนินการถัดไปจากนั้นดำเนินต่อไป ฯลฯ )

นี้เป็นส่วนหนึ่งที่ผมไม่สนใจเพราะบล็อกมันและยังจะตัดข้อยกเว้นใด ๆ AggregateExceptionใน

และมันเหมือนกันหมดอย่างนี้หรือไม่?

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

ใช่ทั้งสองตัวอย่างนี้เทียบเท่ากัน พวกเขาทั้งสองเริ่มการทำงานแบบอะซิงโครนัสทั้งหมด ( events.Select(...)) จากนั้นรอแบบอะซิงโครนัสเพื่อให้การดำเนินการทั้งหมดเสร็จสมบูรณ์ในลำดับใด ๆ ( await Task.WhenAll(...)) จากนั้นดำเนินการกับส่วนที่เหลือของงาน ( Where...)

ตัวอย่างทั้งสองนี้แตกต่างจากรหัสต้นฉบับ AggregateExceptionรหัสเดิมคือการปิดกั้นและจะตัดข้อยกเว้นใน

รหัสที่มีอยู่ใช้งานได้ แต่กำลังบล็อกเธรด

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

สร้างงานใหม่สำหรับทุกเหตุการณ์ แต่

.Select(t => t.Result)

บล็อกเธรดที่รอให้แต่ละภารกิจใหม่จบ

ในทางกลับกันโค้ดของคุณจะให้ผลลัพธ์เหมือนกัน แต่จะเก็บแบบอะซิงโครนัส

เพียงแค่ความคิดเห็นเดียวในรหัสแรกของคุณ สายนี้

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

จะสร้างภารกิจเดียวดังนั้นตัวแปรควรตั้งชื่อเป็นเอกเทศ

ในที่สุดรหัสสุดท้ายของคุณให้เหมือนกัน แต่รวบรัดมากขึ้น

สำหรับการอ้างอิง: Task.Wait / Task.WhenAll

ด้วยวิธีการปัจจุบันที่มีอยู่ใน Linq มันดูน่าเกลียดมาก:

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

หวังว่าการติดตาม. NET ในเวอร์ชันต่อ ๆ ไปจะมีเครื่องมือที่หรูหรากว่าเพื่อจัดการกับคอลเลกชันของงานและงานของคอลเลกชัน

ฉันใช้รหัสนี้:

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

แบบนี้:

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

ฉันชอบวิธีนี้เป็นวิธีเสริม:

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

เพื่อให้สามารถใช้งานได้โดยการโยงวิธี:

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