Misunderstanding of async/await functions

You are not actually running your heavy-lifting code in a seperate thread - async does not automatically guarantee that.

Try something like (await Task.Run(() => DoHeavyWork()));

fk2's answer is correct, but you can avoid overhead and fragility by simply returning a Task<bool> directly:

public Task<bool> DoHeavyWork()
{
    return Task.Run(() =>
    {
        return HeavyWorkReturningBool();
    });
}

See this question for some more details.

However, as pointed out in the comments, this is not a clean solution. Offloading work to background threads to preserve UI responsiveness belongs to the UI code and not the API implementing the work. For a more modular solution you should implement it this way:

public async bool PopulateTV()
{
    using (var waitingForm = new WaitingForm())
    {
        waitingForm.Show();
        return await Task.Run(() => DoHeavyWork());
    }
}

DoHeavyWork remains a regular, synchronous Method:

public bool DoHeavyWork()
{
    var boolResult;
    //do the work
    return boolResult;
}

See the following blog posts for more information about this:

• Should I expose asynchronous wrappers for synchronous methods?
• Task.Run Etiquette and Proper Usage
• Task.Run Etiquette Examples: Don't Use Task.Run for the Wrong Thing
• Task.Run Etiquette Examples: Don't Use Task.Run in the Implementation

But it's not the big problem. When I call the parent method PopulateTV(), I want to return a bool value (if(!PopulateTV()) ... And I get an error :

It's if(!(await PopulateTV())). First wait for the result (bool) and later evaluate it.

In the other hand, your not that async method is equivalent to code it this way:

public Task<bool> DoHeavyWork()
{
  //do the work
  return Task.FromResult(true);
}

async/await keywords are meant to work as syntactic sugar in order to re-write your task-based asynchronous pattern code into a more readable one.

Actually, if your DoHeavyWork does something like this:

public async Task<bool> DoHeavyWork()
{
  await Task.Factory.StartNew(() => Thread.Sleep(10000));

  return true;
}

...is almost the same as writing it this way:

    public Task<bool> DoHeavyWork()
    {
        return Task.Factory.StartNew
        (
             () =>
             {
                  Thread.Sleep(10000);

                  return true;
             }
        )

    }

You need to understand that async/await is just a compiler feature to let you code elegant asynchronous code, but it doesn't mean that the async method must be asynchronous at all. It means that a Task instance can be awaited with await keyword.

That is, you can implement methods with asynchronous signatures (i.e. Task MyMethod() { }) but fake them returning a Task generated by a TaskCompletionSource<T>:

public Task<bool> DoHeavyWork()
{
  // No async operation here. This is just a fake!
  TaskCompletionSource<bool> completion = new TaskCompletionSource<bool>();
  completion.SetResult(true);

  return completion.Task;
}

...and this can be also simplified using Task.FromResult<T>(T result), as you can check in some of this answer's code snippets.

So, why I need to develop my APIs using task-based asynchronous pattern (TAP)?

Because the caller of your methods shouldn't need to know if the method is synchronous or asynchronous. Method's implementation will decide it, but at the same time the caller can work asynchronously if the whole method is actually asynchronous.

If you do the opposite (sync methods), your entire code flow will need to be changed if you decide to implement everything as asynchronous operations:

// I don't know if it's actually async or not, I don't care. The calling method
// decides it.
bool result = await DoWorkAsync();

// I know it's sync. So my code can become pure garbage if I need to make it
// synchronous since it can't be awaited and it doesn't return a Task instance!
bool result = DoWork();

But PopulateTV() return a bool (return boolResult;), even if the method declaration use Task<bool>.

Wrong. PopulateTV() returns a Task<bool>

//        (return Type is here)
//           ||||||||||
//           vvvvvvvvvv
public async Task<bool> populateTV()

Just think of return boolResult; as being the return statement of the Task, not the method. To get the actual bool result, you need to await that Task:

if (!(await PopulateTV()))

Why are you getting a warning when you declare your method like this?

public async Task<bool> DoHeavyWork()

Because you are using async without await. You don't need the async keyword here. All async does is enable await, so if you don't use await, don't use async. You can just return a Task:

public Task<bool> DoHeavyWork()
{
    return Task.Run<bool>(() => 
        //do the heavy work
        return boolResult;
    );
}