Ketika benar menggunakan Task.Run dan ketika hanya async-tunggu

Saya ingin menanyakan pendapat Anda tentang arsitektur yang benar kapan harus digunakan Task.Run . Saya mengalami UI lamban dalam aplikasi WPF .NET 4.5 kami (dengan kerangka kerja Caliburn Micro).

Pada dasarnya saya lakukan (cuplikan kode yang sangat sederhana):

public class PageViewModel : IHandle<SomeMessage>
{
   ...

   public async void Handle(SomeMessage message)
   {
      ShowLoadingAnimation();

      // Makes UI very laggy, but still not dead
      await this.contentLoader.LoadContentAsync();

      HideLoadingAnimation();
   }
}

public class ContentLoader
{
    public async Task LoadContentAsync()
    {
        await DoCpuBoundWorkAsync();
        await DoIoBoundWorkAsync();
        await DoCpuBoundWorkAsync();

        // I am not really sure what all I can consider as CPU bound as slowing down the UI
        await DoSomeOtherWorkAsync();
    }
}

Dari artikel / video yang saya baca / lihat, saya tahu itu await asyncbelum tentu berjalan di utas latar dan untuk mulai bekerja di latar belakang Anda harus membungkusnya dengan menunggu Task.Run(async () => ... ). Menggunakan async awaittidak memblokir UI, tetapi tetap berjalan di utas UI, sehingga membuatnya tertinggal.

Di mana tempat terbaik untuk meletakkan Task.Run?

Haruskah saya hanya

1. Bungkus panggilan luar karena ini kurang bekerja threading untuk .NET

2. , atau haruskah saya membungkus hanya metode terikat CPU yang berjalan secara internal Task.Runkarena ini membuatnya dapat digunakan kembali untuk tempat lain? Saya tidak yakin di sini jika mulai mengerjakan utas latar belakang jauh di inti adalah ide yang bagus.

Ad (1), solusi pertama akan seperti ini:

public async void Handle(SomeMessage message)
{
    ShowLoadingAnimation();
    await Task.Run(async () => await this.contentLoader.LoadContentAsync());
    HideLoadingAnimation();
}

// Other methods do not use Task.Run as everything regardless
// if I/O or CPU bound would now run in the background.

Ad (2), solusi kedua akan seperti ini:

public async Task DoCpuBoundWorkAsync()
{
    await Task.Run(() => {
        // Do lot of work here
    });
}

public async Task DoSomeOtherWorkAsync(
{
    // I am not sure how to handle this methods -
    // probably need to test one by one, if it is slowing down UI
}

Perhatikan pedoman untuk melakukan pekerjaan pada utas UI , dikumpulkan di blog saya:

• Jangan blokir utas UI lebih dari 50 ms sekaligus.
• Anda dapat menjadwalkan ~ 100 lanjutan pada utas UI per detik; 1000 terlalu banyak.

Ada dua teknik yang harus Anda gunakan:

1) Gunakan ConfigureAwait(false)saat Anda bisa.

Misalnya, await MyAsync().ConfigureAwait(false);bukannya await MyAsync();.

ConfigureAwait(false)memberitahu awaitbahwa Anda tidak perlu melanjutkan pada konteks saat ini (dalam hal ini, "pada konteks saat ini" berarti "pada utas UI"). Namun, untuk sisa asyncmetode itu (setelah ConfigureAwait), Anda tidak dapat melakukan apa pun yang mengasumsikan Anda berada dalam konteks saat ini (misalnya, memperbarui elemen UI).

Untuk informasi lebih lanjut, lihat artikel MSDN saya Praktik Terbaik di Pemrograman Asinkron .

2) Gunakan Task.Rununtuk memanggil metode yang terikat CPU.

Anda harus menggunakan Task.Run, tetapi tidak dalam kode apa pun yang Anda ingin dapat digunakan kembali (yaitu, kode perpustakaan). Jadi Anda gunakan Task.Rununtuk memanggil metode, bukan sebagai bagian dari implementasi metode.

Jadi pekerjaan yang terikat CPU murni akan terlihat seperti ini:

// Documentation: This method is CPU-bound.
void DoWork();

Yang akan Anda panggil menggunakan Task.Run:

await Task.Run(() => DoWork());

Metode yang merupakan campuran dari CPU-terikat dan I / O-terikat harus memiliki Asynctanda tangan dengan dokumentasi menunjukkan sifat terikat-CPU mereka:

// Documentation: This method is CPU-bound.
Task DoWorkAsync();

Yang juga akan Anda panggil menggunakan Task.Run(karena sebagian terikat CPU):

await Task.Run(() => DoWorkAsync());

Satu masalah dengan ContentLoader Anda adalah bahwa ia beroperasi secara berurutan. Pola yang lebih baik adalah memparalelkan pekerjaan dan kemudian melakukan sinkronisasi pada akhirnya, jadi kita dapatkan

public class PageViewModel : IHandle<SomeMessage>
{
   ...

   public async void Handle(SomeMessage message)
   {
      ShowLoadingAnimation();

      // makes UI very laggy, but still not dead
      await this.contentLoader.LoadContentAsync(); 

      HideLoadingAnimation();   
   }
}

public class ContentLoader 
{
    public async Task LoadContentAsync()
    {
        var tasks = new List<Task>();
        tasks.Add(DoCpuBoundWorkAsync());
        tasks.Add(DoIoBoundWorkAsync());
        tasks.Add(DoCpuBoundWorkAsync());
        tasks.Add(DoSomeOtherWorkAsync());

        await Task.WhenAll(tasks).ConfigureAwait(false);
    }
}

Jelas, ini tidak berfungsi jika ada tugas yang membutuhkan data dari tugas sebelumnya yang lain, tetapi seharusnya memberikan Anda hasil keseluruhan yang lebih baik untuk sebagian besar skenario.