Mengapa tidak menunggu di Task.WhenAll melempar AggregateException?

Dalam kode ini:

private async void button1_Click(object sender, EventArgs e) {
    try {
        await Task.WhenAll(DoLongThingAsyncEx1(), DoLongThingAsyncEx2());
    }
    catch (Exception ex) {
        // Expect AggregateException, but got InvalidTimeZoneException
    }
}

Task DoLongThingAsyncEx1() {
    return Task.Run(() => { throw new InvalidTimeZoneException(); });
}

Task DoLongThingAsyncEx2() {
    return Task.Run(() => { throw new InvalidOperation();});
}

Saya berharap WhenAlluntuk membuat dan melempar AggregateException, karena setidaknya salah satu tugas yang ditunggu adalah pengecualian. Sebaliknya, saya mendapatkan kembali satu pengecualian yang dilemparkan oleh salah satu tugas.

Tidak WhenAllselalu membuat AggregateException?

Saya tidak begitu ingat di mana, tetapi saya membaca di suatu tempat bahwa dengan kata kunci async / await baru , kata kunci tersebut membuka AggregateExceptionke dalam pengecualian yang sebenarnya.

Jadi, dalam blok tangkap, Anda mendapatkan pengecualian sebenarnya dan bukan gabungan. Ini membantu kami menulis kode yang lebih alami dan intuitif.

Ini juga diperlukan untuk memudahkan konversi kode yang ada menjadi menggunakan async / await di mana banyak kode mengharapkan pengecualian tertentu dan bukan pengecualian gabungan.

- Edit -

Mengerti:

An Async Primer oleh Bill Wagner

Bill Wagner berkata: (dalam When Exception Happen )

... Saat Anda menggunakan await, kode yang dihasilkan oleh compiler akan membuka AggregateException dan menampilkan pengecualian yang mendasarinya. Dengan memanfaatkan await, Anda menghindari pekerjaan tambahan untuk menangani jenis AggregateException yang digunakan oleh Task.Result, Task.Wait, dan metode Tunggu lainnya yang ditentukan di kelas Task. Itu alasan lain untuk menggunakan await daripada metode Tugas yang mendasarinya ....

Saya tahu ini adalah pertanyaan yang sudah dijawab tetapi jawaban yang dipilih tidak benar - benar menyelesaikan masalah OP, jadi saya pikir saya akan memposting ini.

Solusi ini memberi Anda pengecualian agregat (yaitu semua pengecualian yang dilemparkan oleh berbagai tugas) dan tidak memblokir (alur kerja masih asinkron).

async Task Main()
{
    var task = Task.WhenAll(A(), B());

    try
    {
        var results = await task;
        Console.WriteLine(results);
    }
    catch (Exception)
    {
        if (task.Exception != null)
        {
            throw task.Exception;
        }
    }
}

public async Task<int> A()
{
    await Task.Delay(100);
    throw new Exception("A");
}

public async Task<int> B()
{
    await Task.Delay(100);
    throw new Exception("B");
}

Kuncinya adalah menyimpan referensi ke tugas agregat sebelum Anda menunggunya, lalu Anda dapat mengakses properti Exception yang menyimpan AggregateException Anda (meskipun hanya satu tugas yang memberikan pengecualian).

Semoga masih bermanfaat. Saya tahu saya mengalami masalah ini hari ini.

Anda dapat melintasi semua tugas untuk melihat apakah ada lebih dari satu yang membuat pengecualian:

private async Task Example()
{
    var tasks = new [] { DoLongThingAsyncEx1(), DoLongThingAsyncEx2() };

    try 
    {
        await Task.WhenAll(tasks);
    }
    catch (Exception ex) 
    {
        var exceptions = tasks.Where(t => t.Exception != null)
                              .Select(t => t.Exception);
    }
}

private Task DoLongThingAsyncEx1()
{
    return Task.Run(() => { throw new InvalidTimeZoneException(); });
}

private Task DoLongThingAsyncEx2()
{
    return Task.Run(() => { throw new InvalidOperationException(); });
}

Hanya berpikir saya akan memperluas jawaban @ Richiban untuk mengatakan bahwa Anda juga dapat menangani AggregateException di blok tangkap dengan mereferensikannya dari tugas. Misalnya:

async Task Main()
{
    var task = Task.WhenAll(A(), B());

    try
    {
        var results = await task;
        Console.WriteLine(results);
    }
    catch (Exception ex)
    {
        // This doesn't fire until both tasks
        // are complete. I.e. so after 10 seconds
        // as per the second delay

        // The ex in this instance is the first
        // exception thrown, i.e. "A".
        var firstExceptionThrown = ex;

        // This aggregate contains both "A" and "B".
        var aggregateException = task.Exception;
    }
}

public async Task<int> A()
{
    await Task.Delay(100);
    throw new Exception("A");
}

public async Task<int> B()
{
    // Extra delay to make it clear that the await
    // waits for all tasks to complete, including
    // waiting for this exception.
    await Task.Delay(10000);
    throw new Exception("B");
}

Anda sedang memikirkan Task.WaitAll- itu melempar AggregateException.

WhenAll hanya menampilkan pengecualian pertama dari daftar pengecualian yang ditemuinya.

Banyak jawaban bagus di sini, tetapi saya masih ingin memposting kata-kata kasar saya karena saya baru saja menemukan masalah yang sama dan melakukan penelitian. Atau lompat ke versi TLDR di bawah.

Masalah

Menunggu taskdikembalikan oleh Task.WhenAllhanya melempar pengecualian pertama dari yang AggregateExceptiondisimpan di task.Exception, bahkan ketika beberapa tugas telah gagal.

Dokumen saat ini untukTask.WhenAll mengatakan:

Jika salah satu tugas yang disediakan selesai dalam keadaan rusak, tugas yang dikembalikan juga akan selesai dalam keadaan rusak, di mana pengecualiannya akan berisi kumpulan dari kumpulan pengecualian yang tidak terbungkus dari setiap tugas yang disediakan.

Yang benar, tetapi tidak mengatakan apa-apa tentang perilaku "membuka" yang disebutkan di atas saat tugas yang dikembalikan menunggu.

Saya kira, dokumen tidak menyebutkannya karena perilaku itu tidak spesifikTask.WhenAll .

Ini hanyalah Task.Exceptiontipe AggregateExceptiondan untuk awaitkelanjutan itu selalu dibuka sebagai pengecualian batin pertama, dengan desain. Ini bagus untuk kebanyakan kasus, karena biasanya Task.Exceptionhanya terdiri dari satu pengecualian internal. Tetapi pertimbangkan kode ini:

Task WhenAllWrong()
{
    var tcs = new TaskCompletionSource<DBNull>();
    tcs.TrySetException(new Exception[]
    {
        new InvalidOperationException(),
        new DivideByZeroException()
    });
    return tcs.Task;
}

var task = WhenAllWrong();    
try
{
    await task;
}
catch (Exception exception)
{
    // task.Exception is an AggregateException with 2 inner exception 
    Assert.IsTrue(task.Exception.InnerExceptions.Count == 2);
    Assert.IsInstanceOfType(task.Exception.InnerExceptions[0], typeof(InvalidOperationException));
    Assert.IsInstanceOfType(task.Exception.InnerExceptions[1], typeof(DivideByZeroException));

    // However, the exception that we caught here is 
    // the first exception from the above InnerExceptions list:
    Assert.IsInstanceOfType(exception, typeof(InvalidOperationException));
    Assert.AreSame(exception, task.Exception.InnerExceptions[0]);
}

Di sini, sebuah instance dari AggregateExceptionakan dibuka ke pengecualian dalam pertamanya InvalidOperationExceptiondengan cara yang persis sama seperti yang mungkin kita lakukan dengannya Task.WhenAll. Kami bisa saja gagal mengamatiDivideByZeroException jika kami tidak melalui task.Exception.InnerExceptionslangsung.

Stephen Toub dari Microsoft menjelaskan alasan di balik perilaku ini dalam masalah GitHub terkait :

Hal yang ingin saya sampaikan adalah bahwa hal itu dibahas secara mendalam, bertahun-tahun yang lalu, ketika ini pertama kali ditambahkan. Kami awalnya melakukan apa yang Anda sarankan, dengan Tugas yang dikembalikan dari WhenAll berisi satu AggregateException yang berisi semua pengecualian, yaitu tugas.Exception akan mengembalikan pembungkus AggregateException yang berisi AggregateException lain yang kemudian berisi pengecualian sebenarnya; lalu jika ditunggu, AggregateException dalam akan disebarkan. Umpan balik kuat yang kami terima yang menyebabkan kami mengubah desain adalah bahwa a) sebagian besar kasus semacam itu memiliki pengecualian yang cukup homogen, sehingga menyebarkan semua secara agregat tidaklah penting, b) menyebarkan agregat kemudian mematahkan ekspektasi seputar tangkapan untuk jenis pengecualian tertentu, dan c) untuk kasus di mana seseorang memang menginginkan kumpulan, mereka dapat melakukannya secara eksplisit dengan dua baris seperti yang saya tulis. Kami juga berdiskusi ekstensif tentang perilaku menunggu yang seharusnya terkait dengan tugas yang berisi banyak pengecualian, dan di sinilah kami mendarat.

Satu hal penting lainnya yang perlu diperhatikan, perilaku membuka bungkus ini dangkal. Yaitu, itu hanya akan membuka pengecualian pertama dari AggregateException.InnerExceptionsdan membiarkannya di sana, bahkan jika itu kebetulan merupakan contoh dari yang lain AggregateException. Ini mungkin menambah lapisan kebingungan lainnya. Misalnya, mari kita ubah WhenAllWrongseperti ini:

async Task WhenAllWrong()
{
    await Task.FromException(new AggregateException(
        new InvalidOperationException(),
        new DivideByZeroException()));
}

var task = WhenAllWrong();

try
{
    await task;
}
catch (Exception exception)
{
    // now, task.Exception is an AggregateException with 1 inner exception, 
    // which is itself an instance of AggregateException
    Assert.IsTrue(task.Exception.InnerExceptions.Count == 1);
    Assert.IsInstanceOfType(task.Exception.InnerExceptions[0], typeof(AggregateException));

    // And now the exception that we caught here is that inner AggregateException, 
    // which is also the same object we have thrown from WhenAllWrong:
    var aggregate = exception as AggregateException;
    Assert.IsNotNull(aggregate);
    Assert.AreSame(exception, task.Exception.InnerExceptions[0]);
    Assert.IsInstanceOfType(aggregate.InnerExceptions[0], typeof(InvalidOperationException));
    Assert.IsInstanceOfType(aggregate.InnerExceptions[1], typeof(DivideByZeroException));
}

Solusi (TLDR)

Jadi, kembali ke await Task.WhenAll(...), yang saya pribadi inginkan adalah bisa:

• Dapatkan satu pengecualian jika hanya satu yang terlempar;
• Dapatkan AggregateExceptionjika lebih dari satu pengecualian telah dilemparkan secara kolektif oleh satu atau lebih tugas;
• Hindari menyimpan Tasksatu - satunya untuk memeriksa nya Task.Exception;
• Menyebarkan status pembatalan benar ( Task.IsCanceled), sebagai sesuatu seperti ini tidak akan melakukannya: Task t = Task.WhenAll(...); try { await t; } catch { throw t.Exception; }.

Saya telah mengumpulkan ekstensi berikut untuk itu:

public static class TaskExt 
{
    /// <summary>
    /// A workaround for getting all of AggregateException.InnerExceptions with try/await/catch
    /// </summary>
    public static Task WithAggregatedExceptions(this Task @this)
    {
        // using AggregateException.Flatten as a bonus
        return @this.ContinueWith(
            continuationFunction: anteTask =>
                anteTask.IsFaulted &&
                anteTask.Exception is AggregateException ex &&
                (ex.InnerExceptions.Count > 1 || ex.InnerException is AggregateException) ?
                Task.FromException(ex.Flatten()) : anteTask,
            cancellationToken: CancellationToken.None,
            TaskContinuationOptions.ExecuteSynchronously,
            scheduler: TaskScheduler.Default).Unwrap();
    }    
}

Sekarang, berikut ini bekerja seperti yang saya inginkan:

try
{
    await Task.WhenAll(
        Task.FromException(new InvalidOperationException()),
        Task.FromException(new DivideByZeroException()))
        .WithAggregatedExceptions();
}
catch (OperationCanceledException) 
{
    Trace.WriteLine("Canceled");
}
catch (AggregateException exception)
{
    Trace.WriteLine("2 or more exceptions");
    // Now the exception that we caught here is an AggregateException, 
    // with two inner exceptions:
    var aggregate = exception as AggregateException;
    Assert.IsNotNull(aggregate);
    Assert.IsInstanceOfType(aggregate.InnerExceptions[0], typeof(InvalidOperationException));
    Assert.IsInstanceOfType(aggregate.InnerExceptions[1], typeof(DivideByZeroException));
}
catch (Exception exception)
{
    Trace.WriteLine($"Just a single exception: ${exception.Message}");
}

Ini berhasil untuk saya

private async Task WhenAllWithExceptions(params Task[] tasks)
{
    var result = await Task.WhenAll(tasks);
    if (result.IsFaulted)
    {
                throw result.Exception;
    }
}

Dalam kode Anda, pengecualian pertama dikembalikan menurut desain seperti yang dijelaskan di http://blogs.msdn.com/b/pfxteam/archive/2011/09/28/task-exception-handling-in-net-4-5. aspx

Sedangkan untuk pertanyaan Anda, Anda akan mendapatkan AggreateException jika Anda menulis kode seperti ini:

try {
    var result = Task.WhenAll(DoLongThingAsyncEx1(), DoLongThingAsyncEx2()).Result; 
}
catch (Exception ex) {
    // Expect AggregateException here
}