Quando usar corretamente o Task.Run e quando apenas async-waitit

Gostaria de perguntar sua opinião sobre a arquitetura correta quando usar Task.Run. Estou com a interface do usuário atrasada em nosso aplicativo WPF .NET 4.5 (com estrutura Caliburn Micro).

Basicamente, estou fazendo (trechos de código muito simplificados):

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

Pelos artigos / vídeos que li / vi, sei que await asyncnão é necessariamente executado em um thread em segundo plano e para iniciar o trabalho em segundo plano, você precisa envolvê-lo em espera Task.Run(async () => ... ). O uso async awaitnão bloqueia a interface do usuário, mas continua sendo executado no encadeamento da interface do usuário, tornando-o lento.

Onde é o melhor lugar para colocar o Task.Run?

Devo apenas

1. Encerre a chamada externa porque isso é menos trabalhoso para o .NET

2. , ou devo agrupar apenas métodos vinculados à CPU em execução internamente, Task.Runpois isso o reutiliza para outros lugares? Não tenho certeza aqui se iniciar um trabalho em threads de fundo no fundo é uma boa idéia.

Anúncio (1), a primeira solução seria assim:

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.

Anúncio (2), a segunda solução seria assim:

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
}

Observe as diretrizes para executar o trabalho em um thread da interface do usuário , coletado no meu blog:

• Não bloqueie o thread da interface do usuário por mais de 50 ms por vez.
• Você pode agendar ~ 100 continuações no thread da interface do usuário por segundo; 1000 é demais.

Existem duas técnicas que você deve usar:

1) Use ConfigureAwait(false)quando puder.

Por exemplo, em await MyAsync().ConfigureAwait(false);vez de await MyAsync();.

ConfigureAwait(false)informa awaitque você não precisa continuar no contexto atual (nesse caso, "no contexto atual" significa "no encadeamento da interface do usuário"). No entanto, para o restante desse asyncmétodo (após o ConfigureAwait), você não pode fazer nada que pressuponha que você esteja no contexto atual (por exemplo, atualize os elementos da interface do usuário).

Para obter mais informações, consulte o artigo Práticas recomendadas do MSDN em programação assíncrona .

2) Use Task.Runpara chamar métodos ligados à CPU.

Você deve usar Task.Run, mas não dentro de qualquer código que deseja que seja reutilizável (ou seja, código de biblioteca). Então você usa Task.Runpara chamar o método, não como parte da implementação do método.

Portanto, o trabalho puramente vinculado à CPU ficaria assim:

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

Você chamaria usando Task.Run:

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

Os métodos que são uma mistura de limite de CPU e de E / S devem ter uma Asyncassinatura com documentação apontando sua natureza de limite de CPU:

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

Você também chamaria de usar Task.Run(já que é parcialmente vinculado à CPU):

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

Um problema com o ContentLoader é que internamente ele opera sequencialmente. Um padrão melhor é paralelizar o trabalho e depois sincronizar no final, para obtermos

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

Obviamente, isso não funciona se alguma das tarefas exigir dados de outras tarefas anteriores, mas deve oferecer melhor rendimento geral para a maioria dos cenários.