Async method to return true or false in a Task

Question

I know that an async method can only return void or Task. I have read similar methods for Exception handling inside async methods. And I'm new to async programming so I am looking for a straightforward solution.

My async method runs an Sql query. If the query was ok, it should notify the caller with a Boolean true and otherwise a false. My method is currently a void so I have no way of knowing.

private async void RefreshContacts()
{
    Task refresh = Task.Run(() =>
    {
        try
        {
            // run the query
        }
        catch { }
    }
    );
    await refresh;           
}

I simply would like to change async to Task so that in my catch statement the method will return a false and otherwise a true.

Answer 1

It sounds like you just need to return a Task<bool> then:

private async Task<bool> RefreshContactsAsync()
{
    try
    {
        ...
    }
    catch // TODO: Catch more specific exceptions
    {
        return false;
    }
    ...
    return true;
}

Personally I would not catch the exception, instead letting the caller check the task for a faulted state, but that's a different matter.

Answer 2

Change the method signature to Task<bool>. Then if your method is declared as async you can simple return a bool value. But as jon skeet said there are other, possibly better ways, to handle your szenario

 private async Task<bool> RefreshContacts()
    {
        Task refresh = Task.Run(() =>
        {
            try
            {
                // run the query
                      return true;
        }
        catch { return false;}      
}

PS: Another common issue you will possibly have is if you have a method without async. Then you can return Task.FromResult(true) like this:

 private Task<bool> RefreshContacts()
 {
     ....
    return Task.FromResult(true)
 }

Answer 3

Sorry, but I think y'all misleading people here. See the Microsoft article, here.

Very simple example which shows how we can return a (scalar) value of bool, int or string type from a Task.

I am posting the C# code here, for posterity:

using System;
using System.Linq;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {
      Console.WriteLine(ShowTodaysInfo().Result);
   }

   private static async Task<string> ShowTodaysInfo()
   {
      string ret = $"Today is {DateTime.Today:D}\n" +
                   "Today's hours of leisure: " +
                   $"{await GetLeisureHours()}";
      return ret;
   }

   static async Task<int> GetLeisureHours()  
   {  
       // Task.FromResult is a placeholder for actual work that returns a string.  
       var today = await Task.FromResult<string>(DateTime.Now.DayOfWeek.ToString());  

       // The method then can process the result in some way.  
       int leisureHours;  
       if (today.First() == 'S')  
           leisureHours = 16;  
       else  
           leisureHours = 5;  

       return leisureHours;  
   }  
}
// The example displays output like the following:
//       Today is Wednesday, May 24, 2017
//       Today's hours of leisure: 5
// </Snippet >

Answer 4

It seems that you are trying to expose an asynchronous wrapper for a synchronous method. This is not recommended, and you can read the reasons here: Should I expose asynchronous wrappers for synchronous methods?

If you still insist on doing it, here is how it can be done:

private Task<bool> RefreshContactsAsync()
{
    return Task.Run(() =>
    {
        try
        {
            // Run the query
            return true;
        }
        catch
        {
            return false;
        }
    });
}

Notice the absence of the async and await keywords. We just use the Task.Run overload that takes a Func<TResult> parameter, and returns a Task<TResult>. The TResult in this case is of type bool.

What you should do instead? Simply make your RefreshContacts method synchronous:

private bool RefreshContacts()
{
    try
    {
        // Run the query
        return true;
    }
    catch
    {
        return false;
    }
}

...and wrap it in Task.Run at the calling site:

bool success = await Task.Run(() => RefreshContacts());

This way nobody is going to get the false impression that they are calling a genuinely asynchronous method (a method that doesn't run on a thread). The intent is clear: a synchronous method is offloaded to the ThreadPool, most probably for the reason of keeping the UI responsive.

Answer 5

google brought me here for a different question so I will answer what I was looking for in hopes that it helps someone else.

In the first example, the async keyword is missing creating a compiler error

        protected override Task<bool> ShouldMakeADecision()
        {
            return true;
        }

This will fail because you need to write the async keyword as shown below. You can see I put it after protected and before override.

        protected async override Task<bool> ShouldMakeADecision()
        {
            return true;
        }