Lukas K Lukas K - 28 days ago 14
C# Question

When correctly use Task.Run and when just async-await

I would like to ask you on your opinion about the correct architecture when to use

Task.Run
. I am experiencing laggy UI in our WPF .net 4.5 app. (with Caliburn Micro framework).

What I am basically doing is (very simplified code snippets)

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

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


From the articles/videos I read/saw I know that
await
async
is not necessarily running on a backgroud thread and to start work in background you need to wrap it with await
Task.Run(async () => ... )
. Using
async
await
does not block UI, but still is running on the UI thread, so it is making it laggy.

My question is where is the best place to put Task.Run.

Should I just
(1) wrap the outer call because this is less threading work for .net
or should I
(2) wrap only CPU bound methods internally running with
Task.Run
as this makes it reusable for other places? I am not sure here if starting work on background threads deep in core is a good idea.

(1) fist solution would see like this

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 IO or CPU bound would now run in background


(2) second solution would see like this

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

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


I hope this makes sense. Thx for your opinions in advance.

Answer

Note the guidelines for performing work on a UI thread, collected on my blog:

  • Don't block the UI thread for more than 50ms at a time.
  • You can schedule ~100 continuations on the UI thread per second; 1000 is too much.

There are two techniques you should use:

1) Use ConfigureAwait(false) when you can.

E.g., await MyAsync().ConfigureAwait(false); instead of await MyAsync();.

ConfigureAwait(false) tells the await that you do not need to resume on the current context (in this case, "on the current context" means "on the UI thread"). However, for the rest of that async method (after the ConfigureAwait), you cannot do anything that assumes you're in the current context (e.g., update UI elements).

For more information, see my MSDN article Best Practices in Asynchronous Programming.

2) Use Task.Run to call CPU-bound methods.

You should use Task.Run, but not within any code you want to be reusable (i.e., library code). So you use Task.Run to call the method, not as part of the implementation of the method.

So purely CPU-bound work would look like this:

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

Which you would call using Task.Run:

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

Methods that are a mixture of CPU-bound and I/O-bound should have an Async signature with documentation pointing out their CPU-bound nature:

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

Which you would also call using Task.Run (since it is partially CPU-bound):

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