🚀Async/Await Deep Dive - Asynchronous Programming

Solution 1

Through DISPATCHER. Since this example is from WPF, we can use dispatcher to allow UI to change it.

private async void RunApp_Click(object sender, RoutedEventArgs e)  
{  
    var t1 = Task.Run(() =>  
    {  
        Dispatcher.Invoke(() =>  
        {  
            OutPutText.Text = "This text will be set from different thread.....!!!!!";  
        });  
    });   
}

Solution 2

By using TaskScheduler class, it has one "FromCurrentSynchronizationContext" method. This method creates a TaskScheduler associated with the current SynchronizationContext that lets the completed task know which thread initiated that one.

private async void RunApp_Click(object sender, RoutedEventArgs e)    
{    
    var t1 = Task.Run(() =>    
    {   
        //do some business logic    
        Task.Delay(2000);      
    }).ContinueWith(t =>    
    {      
        OutPutText.Text = "This text will be set from different thread.....!!!!!";   
    }, TaskScheduler.FromCurrentSynchronizationContext());    
}

Solution 3

How we can do this with Async/Await?

private async void RunApp_Click(object sender, RoutedEventArgs e)  
{  
    //Best and easy way to do  
    await RunAsync();
    OutPutText.Text = "This text will be set from different thread.....!!!!!";
}  
  
private async Task RunAsync()  
{  
    //do some business logic  
    await Task.Delay(2000);
}

As we can see, it's easy to write code that's maintainable. This hides all complexity behind the hood. Lets see how it will execute behind the screen.

When the UI thread sees await RunAsync(), it will execute RunAsync in State Machine and free the UI thread so that the UI will not freeze. As soon as RunAsync completes, the State machine will let the UI thread (caller thread) to complete the process.

Let's see the comply code of when we used Async/Await.

First see the state machine compile code of RunApp_Click:

[CompilerGenerated]  
private sealed class <RunApp_Click>d__1 : IAsyncStateMachine  
{  
    public int <>1__state;  
    public AsyncVoidMethodBuilder <>t__builder;  
    public object sender;  
    public RoutedEventArgs e;  
    public MainWindow <>4__this;  
    private TaskAwaiter <>u__1;  
  
    private void MoveNext()  
    {  
        int num = this.<>1__state;  
        try  
        {  
            TaskAwaiter awaiter;  
            if (num == 0)  
            {  
                awaiter = this.<>u__1;  
                this.<>u__1 = new TaskAwaiter();  
                this.<>1__state = num = -1;  
                goto TR_0004;  
            }  
            else  
            {  
                awaiter = this.<>4__this.RunAsync().GetAwaiter();   //Invoking RunAsync and waiting for to complete
                if (awaiter.IsCompleted)  
                {  
                    goto TR_0004;  
                }  
                else  
                {  
                    this.<>1__state = num = 0;  
                    this.<>u__1 = awaiter;  
                    MainWindow.<RunApp_Click>d__1 stateMachine = this;  
                    this.<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter, MainWindow.<RunApp_Click>d__1>(ref awaiter, ref stateMachine);  
                }  
            }  
            return;  
        TR_0004:  
            awaiter.GetResult();  
            this.<>4__this.OutPutText.Text = "This text will be set from different thread.....!!!!!";    //After RunAsync will complete this line will of code will be executed
            this.<>1__state = -2;  
            this.<>t__builder.SetResult();  
        }  
        catch (Exception exception)  
        {  
            this.<>1__state = -2;  
            this.<>t__builder.SetException(exception);  
        }  
    }
}

Let's see the state machine compile code of RunAsync method.

[CompilerGenerated]  
private sealed class <RunAsync>d__2 : IAsyncStateMachine  
{  
    public int <>1__state;  
    public AsyncTaskMethodBuilder <>t__builder;  
    public MainWindow <>4__this;  
    private TaskAwaiter <>u__1;  
  
    private void MoveNext()  
    {  
        int num = this.<>1__state;  
        try  
        {  
            TaskAwaiter awaiter;  
            if (num == 0)  
            {  
                awaiter = this.<>u__1;  
                this.<>u__1 = new TaskAwaiter();  
                this.<>1__state = num = -1;  
                goto TR_0004;  
            }  
            else  
            {  
                awaiter = Task.Delay(0x7d0).GetAwaiter();  
                if (awaiter.IsCompleted)  
                {  
                    goto TR_0004;  
                }  
                else  
                {  
                    this.<>1__state = num = 0;  
                    this.<>u__1 = awaiter;  
                    MainWindow.<RunAsync>d__2 stateMachine = this;  
                    this.<>t__builder.AwaitUnsafeOnCompleted<TaskAwaiter, MainWindow.<RunAsync>d__2>(ref awaiter, ref stateMachine);  
                }  
            }  
            return;  
        TR_0004:  
            awaiter.GetResult();  
            this.<>1__state = -2;  
            this.<>t__builder.SetResult();  
        }  
        catch (Exception exception)  
        {  
            this.<>1__state = -2;  
            this.<>t__builder.SetException(exception);  
        }  
    }
}

Let us see the RunAsync Compile code.

[AsyncStateMachine(typeof(<RunAsync>d__2)), DebuggerStepThrough]  
private Task RunAsync()  
{  
    <RunAsync>d__2 stateMachine = new <RunAsync>d__2 {  
        <>4__this = this,  
        <>t__builder = AsyncTaskMethodBuilder.Create(),  
        <>1__state = -1  
    };  
    stateMachine.<>t__builder.Start<<RunAsync>d__2>(ref stateMachine);  
    return stateMachine.<>t__builder.Task;   //In original code there was no return statement but compiler added this line to return back to caller thread.
}

The compiler has created two state machine and both have try catch block but no return statement in the catch block so the error will propagate to surface. If we execute an asynchronous task inside the try catch block, we will get the exception: no need of continue with and then checking is faulted.

When we use the Task.Run exception, it will not be caught on try catch, because that will be shallowed by the task itself. We called those exceptions SHALLOWED EXCEPTIONS.

Let's conclude this topic with the advantages and disadvantages of using Async/Await...

Advantages

• Increases efficiency when used properly
• UI will be interactive
• Easy to handle exceptions
• Maximum utilization of CPU and Memory of system

Disadvantages

• Every Async method add 100 bytes overhead to app
• Deadlock will be around the corner
• Increases complexity (without a proper understanding of things happening behind the scene)

Note

ASP.NET core does not have a Synchronization context, which means await defaults to the thread pool context. So, in the ASP.NET Core world, asynchronous may run on any thread, and they may all run in parallel.