Understanding Control Flow With Async And Await In C#

class Program  
{  
    static void Main(string[] args)  
    {  
        Method1();  
        Method2();  
        Console.ReadKey();  
    }  
  
    public static async Task Method1()  
    {  
        await Task.Run(() =>  
        {  
            for (int i = 0; i < 100; i++)  
            {  
                Console.WriteLine(" Method 1");
                // Do something
                Task.Delay(100).Wait();
            }  
        });  
    }  
  
  
    public static void Method2()  
    {  
        for (int i = 0; i < 25; i++)  
        {  
            Console.WriteLine(" Method 2");
            // Do something
           Task.Delay(100).Wait();
        }  
    }  
}

We will create a new method called callMethod, and in this method, we will call all our Methods Method1, Method2, and Method3, respectively.

Code sample C# 7

class Program  
{  
    static void Main(string[] args)  
    {  
        callMethod();  
        Console.ReadKey();  
    }  
  
    public static async void callMethod()  
    {  
        Task<int> task = Method1();  
        Method2();  
        int count = await task;  
        Method3(count);  
    }  
  
    public static async Task<int> Method1()  
    {  
        int count = 0;  
        await Task.Run(() =>  
        {  
            for (int i = 0; i < 100; i++)  
            {  
                Console.WriteLine(" Method 1");  
                count += 1;  
            }  
        });  
        return count;  
    }  
  
    public static void Method2()  
    {  
        for (int i = 0; i < 25; i++)  
        {  
            Console.WriteLine(" Method 2");  
        }  
    }  
  
    public static void Method3(int count)  
    {  
        Console.WriteLine("Total count is " + count);  
    }  
}

Code sample C# 9

class Program  
 {  
   static async Task Main(string[] args)  
   {  
     await callMethod();  
     Console.ReadKey();  
   }  
  
   public static async Task callMethod()  
   {  
     Method2();  
     var count = await Method1();  
     Method3(count);  
   }  
  
   public static async Task<int> Method1()  
   {  
     int count = 0;  
     await Task.Run(() =>  
     {  
       for (int i = 0; i < 100; i++)  
       {  
         Console.WriteLine(" Method 1");  
         count += 1;  
       }  
     });  
     return count;  
   }  
  
   public static void Method2()  
   {  
     for (int i = 0; i < 25; i++)  
     {  
       Console.WriteLine(" Method 2");  
     }  
   }  
  
   public static void Method3(int count)  
   {  
     Console.WriteLine("Total count is " + count);  
   }  
}

In the code above, Method3 requires one parameter, which is the return type of Method1. Here, the await keyword is vital in waiting for Method1 task completion.

Output

Real-time example

Some support APIs from the .NET Framework 4.5, and the Windows runtime contains methods that support async programming.

We can use all of these in the real-time project with the help of async and await keywords for the faster execution of the task.

Some APIs that contain async methods are HttpClient, SyndicationClient, StorageFile, StreamWriter, StreamReader, XmlReader, MediaCapture, BitmapEncoder, BitmapDecoder, etc.

In this example, we will read all the characters from a large text file asynchronously and get the total length of all the characters.

Sample code

class Program  
{  ke
    static void Main()  
    {  
        Task task = new Task(CallMethod);  
        task.Start();  
        task.Wait();  
        Console.ReadLine();  
    }  
  
    static async void CallMethod()  
    {  
        string filePath = "E:\\sampleFile.txt";  
        Task<int> task = ReadFile(filePath);  
  
        Console.WriteLine(" Other Work 1");  
        Console.WriteLine(" Other Work 2");  
        Console.WriteLine(" Other Work 3");  
  
        int length = await task;  
        Console.WriteLine(" Total length: " + length);  
  
        Console.WriteLine(" After work 1");  
        Console.WriteLine(" After work 2");  
    }  
  
    static async Task<int> ReadFile(string file)  
    {  
        int length = 0;  
  
        Console.WriteLine(" File reading is stating");  
        using (StreamReader reader = new StreamReader(file))  
        {  
            // Reads all characters from the current position to the end of the stream asynchronously    
            // and returns them as one string.    
            string s = await reader.ReadToEndAsync();  
  
            length = s.Length;  
        }  
        Console.WriteLine(" File reading is completed");  
        return length;  
    }  
}

In the code given above, we are calling a ReadFile method to read the contents of a text file and get the length of the total characters present in the text file.

In our sampleText.txt, the file contains too many characters, so It will take a long time to read all the characters.

Here, we are using async programming to read all the contents from the file, so it will not wait to get a return value from this method and execute the other lines of code. , However, it still has to wait for the line of code given below because we are using await keywords, and we will use the return value for the line of code below.

int length = await task;
Console.WriteLine(" Total length: " + length);

Subsequently, other lines of code will be executed sequentially.

Console.WriteLine(" After work 1");
Console.WriteLine(" After work 2");

Output

Here, we must understand important points: if we are not using await keyword, then the method works synchronously. So the compiler will show the warning to us, but it will not show any error.

We can use async and await keywords in C# to implement async programming in this easy way,

If you're new to Async programming, here is a detailed tutorial on Asynchronous programming in C#.