C# ContinueWith / Return

Question

I'm a bit new to async programming in C#, and struggling with a small but frustrating challenge.

I have a ASP.Net MVC WEB API that runs nicely. on the other side I have created this WEB API client method:

public async Task<DTOVArt> GetVArtFormArt(DTOArt art)
    {
        using (var client = GetHttpClient())
        {
            var response = await client.GetAsync("api/APIVArt/Get/" + art.ART_ID);
            if (!response.IsSuccessStatusCode) return null;
            var arts = await response.Content.ReadAsAsync<DTOVArt>();
            return arts;
        }
    }

which seems to be work very fine...

This method is called from a WPF view model, an that's where my problem comes..

private DTOVObs TransFormAaretsGang(DTOAaretsGang aaretsGang)
    {
        var dtovObs = new DTOVObs();

        using (var artservice = new ArtService())
        {
            artservice.GetVArtFormArt(new DTOArt() {ART_ID = aaretsGang.ART_ID}).ContinueWith(t =>
            {
                dtovObs.Familie_id = t.Result.Familie_id;
                dtovObs.Gruppe_id = t.Result.Gruppe_id;
                dtovObs.ART_ID = t.Result.ART_ID;
                if (aaretsGang.Dato != null) dtovObs.Aarstal = aaretsGang.Dato.Value.Year;
                return dtovObs;
            });
        }

        return dtovObs;
    }

The problem is that this last methods performs the return statement before it hits the ContinueWith statement block, that actually sets the values inside the class that should be returned.

Any attempt to do any kind of Wait() or using .Result instead of ContinueWith just blocks everything.

And if I do the return inside the ContinueWith block, the C# compiler says the method is missing a return statement, which is true.

Answer 1

When you use async / await, you don't have to use ContinueWith anymore. ContinueWith means: wait until the previous is finished and use the result to do the next.

async await does this for you.

Suppose you have an async function. All async functions return either Task (for void return) or Task<TResult> if the return is of type TResult

private async Task<int> SlowAdditionAsync(int a, int b)
{
    await Task.Delay(TimeSpan.FromSeconds(5); // causing the slow part
    return a + b;
}

usage:

private async Task PerformSlowAddition()
{
    int a = ...;
    int b = ...;
    int x =await SlowAditionAsync(a, b);
    // the statement after the await, the task is finished, the result is in x.
    // You can used the result as if you used Continuewith:
    DisplayAddition(x);
}

Or if you want to do something else during the calculation:

private async Task PerformSlowAddition()
{
    int a = ...;
    int b = ...;
    var taskSlowAddition = SlowAditionAsync(a, b);
    DoSomethingElse(); // while the calculator does its thing
    // now we need the result:
    int x = await taskSlowAddition;
    // no need to use ContinueWith, the next statement will be executed:
    DisplayAddition(x);
}

Remember:

• All functions that use a function that returns a Task or Task should be declared async
• all async functions return Task is they return void or Task if they return TResult.
• There is one exception to Task return: event handlers return void
• After calling an async function, you can do other things.
• When you need the result use await
• you can only await a Task or a Task
• The value of await Task is the TResult

There is only one async function that doesn't have to return a task and that is the eventhandler:

private async void OnButton1_Clicked(object sender, ...)
{
    var taskX = DosomethingAsync(...)
    DoSomethingElse();'
    // now we need the result of taskX:
    var x = await TaskX;
    ProcessReault(x)
}

Note that although the event handler doesn't return a task it is still async

If you have some statements that needs to run in the background while your user interface keeps responsive, use Task.Factory.StartNew() or the more modern one Task.Run():

private int SlowCalculation(int a, int b)
{
    // do something really difficult and slow
    System.Threading.Thread.Sleep(TimeSpan.FromSeconds(5));
    return a + b;
}

// make it async:
private async Task<int> SlowCalculationAsync(int a, int b)
{
    return await Task.Run( () => SlowCalculation(a, b));
}

usage:

private async Task CalculateAsync()
{
    int a = ...;
    int b = ...;
    int x = await SlowCalculationAsync(a, b);
    Display(x);
}

private async void OnButton1_clicked(object sender, ...)
{
     await CalculateAsync();
}

Answer 2

That's the nature of async. Because your call is async, it will be executed later and the code below just continue executing.

Try adding an await and just remove the ContinueWith if this is the root of the call, usually it's an event handler:

private async Task<DTOVObs> TransFormAaretsGang(DTOAaretsGang aaretsGang)
{
    var dtovObs = new DTOVObs();
    DTOVArt Result = await artservice.GetVArtFormArt(new DTOArt() {ART_ID = aaretsGang.ART_ID});
    dtovObs.Familie_id = Result.Familie_id;
    dtovObs.Gruppe_id = Result.Gruppe_id;
    dtovObs.ART_ID = Result.ART_ID;
    if (aaretsGang.Dato != null) 
       dtovObs.Aarstal = aaretsGang.Dato.Value.Year;
    return dtovObs;
}

If you still want to return an asynch Task so that any caller that calls this method can await the result, try:

private async Task<DTOVObs> TransFormAaretsGang(DTOAaretsGang aaretsGang)
    {
        using (var artservice = new ArtService())
        {
            return artservice.GetVArtFormArt(new DTOArt() {ART_ID = aaretsGang.ART_ID}).ContinueWith(t =>
            {
                dtovObs.Familie_id = t.Result.Familie_id;
                dtovObs.Gruppe_id = t.Result.Gruppe_id;
                dtovObs.ART_ID = t.Result.ART_ID;
                if (aaretsGang.Dato != null) dtovObs.Aarstal = aaretsGang.Dato.Value.Year;
                return dtovObs;
            });
        }
    }