Should I worry about “This async method lacks ‘await’ operators and will run synchronously” warning

by

The async keyword is merely an implementation detail of a method; it isn’t part of the method signature. If a particular method implementation or override has nothing to await, then just omit the async keyword and return a completed task using Task.FromResult<TResult>:

public Task<string> Foo()               //    public async Task<string> Foo()
{                                       //    {
    Baz();                              //        Baz();
    return Task.FromResult("Hello");    //        return "Hello";
}                                       //    }

If your method return type is Task instead of Task<TResult>, then return Task.CompletedTask:

public Task Bar()                       //    public async Task Bar()
{                                       //    {
    Baz();                              //        Baz();
    return Task.CompletedTask;          //
}                                       //    }

Note: Task.CompletedTask was added in .NET Framework 4.6. If you’re targeting .NET Framework 4.5.2 or earlier, then you can instead return a completed task of any type and value. Task.FromResult(0) seems to be a popular choice:

public Task Bar()                       //    public async Task Bar()
{                                       //    {
    Baz();                              //        Baz();
    return Task.FromResult(0);          //
}                                       //    }

Dealing with Exceptions

An exception thrown by a non-async method propagates immediately up the call stack, but an exception thrown by an async method is stored in the returned Task object and propagates only when the Task is awaited. This makes a big difference if someone calls your method and then does something else before awaiting the Task:

Task<string> task = Foo();   // If Foo is async and throws an exception,
DoSomethingElse();           // then this line will be executed,
string result = await task;  // and the exception will be rethrown here.

If you need to preserve this behavior for a non-async method, then wrap the entire method within a try…catch statement. Pass any unhandled exception to Task.FromException, and return the result:

public Task<string> Foo()                       //  public async Task<string> Foo()
{                                               //  {
    try                                         //
    {                                           //
        Baz(); // might throw                   //      Baz();
        return Task.FromResult("Hello");        //      return "Hello";
    }                                           //
    catch (Exception ex)                        //
    {                                           //
        return Task.FromException<string>(ex);  //
    }                                           //
}                                               //  }

public Task Bar()                               //  public async Task Bar()
{                                               //  {
    try                                         //
    {                                           //
        Baz(); // might throw                   //      Baz();
        return Task.CompletedTask;              //
    }                                           //
    catch (Exception ex)                        //
    {                                           //
        return Task.FromException(ex);          //
    }                                           //
}                                               //  }

The generic argument to Task.FromException must match the return type of the method.

Reducing Boilerplate Code

You can use the following helper class to automatically call Task.FromResult and Task.FromException for you:

public static class TaskHelper
{
    public static Task FromResultOf(Action action)
    {
        try
        {
            action();
            return Task.CompletedTask;
        }
        catch (Exception ex)
        {
            return Task.FromException(ex);
        }
    }

    public static Task<T> FromResultOf<T>(Func<T> func)
    {
        try
        {
            return Task.FromResult(func());
        }
        catch (Exception ex)
        {
            return Task.FromException<T>(ex);
        }
    }
}

Sample usage:

public Task<string> Foo()               //    public async Task<string> Foo()
{                                       //    {
    return TaskHelper.FromResultOf(     //
        () =>                           //
        {                               //
            Baz();                      //        Baz();
            return "Hello";             //        return "Hello";
        });                             //
}                                       //    }

public Task Bar()                       //    public async Task Bar()
{                                       //    {
    return TaskHelper.FromResultOf(     //
        () =>                           //
        {                               //
            Baz();                      //        Baz();
        });                             //
}                                       //    }

More Related Contents:

  1. Why use async and return await, when you can return Task directly?
  2. How and when to use ‘async’ and ‘await’
  3. HttpClient.GetAsync(…) never returns when using await/async
  4. Should I avoid ‘async void’ event handlers?
  5. Running multiple async tasks and waiting for them all to complete
  6. How do yield and await implement flow of control in .NET?
  7. Fire and forget async method in asp.net mvc
  8. How can I call an async method in Main?
  9. Task sequencing and re-entracy
  10. Enforce an async method to be called once
  11. What is the use for Task.FromResult in C#
  12. Why use Async/await all the way down
  13. Waiting for async/await inside a task
  14. How can I prevent synchronous continuations on a Task?
  15. Benefits of using async and await keywords
  16. Different forms of the WCF service contract interface
  17. How does async works in C#?
  18. Executing tasks in parallel
  19. Proper way to start and fire-and-forget asynchronous calls?
  20. Use Task.Run() in synchronous method to avoid deadlock waiting on async method?
  21. A pattern for self-cancelling and restarting task
  22. Async always WaitingForActivation
  23. What is the correct way to cancel an async operation that doesn’t accept a CancellationToken?
  24. A pattern to pause/resume an async task?
  25. is using an an `async` lambda with `Task.Run()` redundant?
  26. Async thread body loop, It just works, but how?
  27. Converting async/await to Task.ContinueWith
  28. Horrible performance using SqlCommand Async methods with large data
  29. Await and SynchronizationContext in a managed component hosted by an unmanaged app
  30. Timeout pattern on task-based asynchronous method in C#

Leave a Comment