Can I use async and Task.Run to make a complex method asyncronous?

Question

I have a complex method, this method make webRequest, access database and other jobs.

public string MyComplexMethod(params){
    //Access db
    //Make WebRequests
    //...
}

I made this method asynchronous this way:

public async Task<string> MyComplexMethod(params)
{
    //Access db
    //Make WebRequests
    //...
}

public async Task MyComplexMethodAsync(params)
{
    await Task.Run(() => MyComplexMethod()).ConfigureAwait(false);
}

And I call my complex method this way:

public void OtherMethod()
{
    //other stuff
    MyComplexMethodAsync(params);
    //other stuff
}

Can I use async and mainly Task.Run with such complex method? Or there another way to make this method asynchronous?

Answer 1

To be wrapped by Task.Run method don't need to be asynchronous

public string MyComplexMethod() {}

public Task MyComplexMethodAsync() 
{
    return Task.Run(() => MyComplexMethod());
}

But using sample above don't make your method to be asynchronous in the way async-await works.
You mentioned that your complex method uses webservices and database queries - this makes your method to be perfect candidate for making it asynchronous.
async-await was designed mostly for working with external resources effectively without using extra threads for operations which only waiting for response and do nothing.

Only you need, it creates own asynchronous method for every operation which "touches" external resources, most of the "clients" already provide asynchronous methods for working with databases or web services.

// Access Db
public async Task<object> GetValueFromDatabaseAsync()
{
    using (var connection = new SqlConnection(connectionString))
    using (var command = new SqlCommand(query, connection))
    {
        await connection.OpenAsync();
        return await command.ExecuteScalarAsync();
    }
}

// Make web request
public async Task<HttpResponseMessage> SendRequestToWebServiceAsync(SomeData data)
{
    using (var client = new HttpClient())
    {
        client.BaseAddress = new Uri(webserviceUrl);
        return await client.PostAsJsonAsync("api/values", data);
    }
} 

Then you end up with your asynchronous complex method

public async Task<string> MyComplexMethodAsync() 
{
    var value = await GetValueFromDatabaseAsync();
    var data = new SomeData(value);
    var response = await SendRequestToWebServiceAsync(data);

    return response.StatusCode.ToString();
}

Interesting part of asynchronous approach, that after you starting using async-await methods in your application they starts spreading over whole application like a zombies :)

For using MyComplexMethodAsync yuo need change OtherMethod to be asynchronous too

public async Task OtherMethodAsync()
{
    //other stuff
    await MyComplexMethodAsync(params);
    //other stuff
}

Answer 2

I think you're on the right path with async / await.

async tells the compiler that you are going to wrap everything in that method ContinueWith AFTER you reach the await keyword.

public void Something()
{
     var task = new Task(() => DoWork());
     task.ContinueWith(() => MoreWorkAfter());
     task.Start();
}

//Is the same as

public async void Something()
{
     var task = new Task(() => DoWork());
     task.Start();
     await Task;
     MoreWorkAfter();
}

//Is also the same as 

public async void Something()
{
     var task = Task.Run(() => DoWork());
     await Task;
     MoreWorkAfter();
}

//Still the same as 

public async void Something()
{
     await Task.Run(() => DoWork());
     MoreWorkAfter();
}

To make the method itself awaitable it has to return a Task object also because Task has the GetAwaiter() the await is looking for. Just remember that if you don't START the task it will await forever. So here's the same method written in an awaitable way for others.

public Task SomethingAsync()
{
     return Task.Run(() => DoWork());
}

//Same as...

public async Task SomethingAsync()
{
     await Task.Run(() => DoWork());
}

//And now in other methods you can....

public async void AnotherMethod()
{
     await SomethingAsync();
     //Do more work after it's complete.
}

Something to take away is that the Task is running on a new thread once it's started and to answer your question, yes it offloads the work. So for your original method keep it the same. The async method can Task.Run it like you've done.

public string MyComplexMethod(params)
{
        //Access db
        //Make WebRequests
        //...
}

public async Task MyComplexMethodAsync(params)
{
    await Task.Run(() => MyComplexMethod()).ConfigureAwait(false);
}

Something to note however; is that although you may call:

await MyComplexMethodAsync(params);

You have ConfigureAwait(false);

Which means any code after the task, in that method, will not be on the current context.

public async Task MyComplexMethodAsync(params)
{
    //Main thread work here
    await Task.Run(() => MyComplexMethod()).ConfigureAwait(false);//Background work here
    //This will also be background work since CongfigureAwait(false);
}

public async Task MyComplexMethodAsync(params)
{
    //Main thread work here
    await Task.Run(() => MyComplexMethod()); //Background work here
    //Main thread work here again since CongfigureAwait defaults to true;
}

And I say Main thread work but that assumes the Main thread called MyComplexMethodAsync.

The easiest way to grasp it is just imagine everything AFTER the await keyword is basically a new Action that gets called when the task is complete; just like using ContinueWith.

AND if there is code AFTER the await keyword in your method, it will BE SCHEDULED to run on the Main thread (considering the Main thread called the method to start with). Meaning it's a little like using Dispatcher.BeginInvoke if you've ever use it. The remaining portion get's queued to run on the Main thread in better terms. (Again, unless you put ConfigureAwait(false) and then it doesn't)