Calling Async Method from Sync Method in C#


In today's software development world, asynchronous programming has become important, particularly for systems that need to be responsive and scalable. It can be required, therefore, to integrate asynchronous functionality into already-existing synchronous codebases or frameworks. It's normal practice in C# to call asynchronous methods from synchronous ones. We will look at effective ways of achieving this in this article.

Asynchronous Programming in C#

In C#, asynchronous programming allows methods to run simultaneously without causing the caller thread to become blocked. For I/O-bound operations like file I/O, network connectivity, and database access, this is very helpful. The async modifier is usually used to identify asynchronous methods, which return a Task or Task that represents the current operation.

Using Task.Run()

Task.Run() to execute the async method on a ThreadPool thread and then synchronously wait for its completion.

public void MyNonAsyncMethod()
    int result = Task.Run(async () => await MyAsyncMethod()).Result;


using System;
using System.Threading.Tasks;

class Program
    public static void Main(string[] args)

   public static void SynchronousWork()
        Console.WriteLine("Synchronous work started...");
        Task.Run(async () =>
            await AsynchronousWorkAsync();
            Console.WriteLine("Asynchronous work completed.");
        Console.WriteLine("Synchronous work completed.");

   public static async Task AsynchronousWorkAsync()
        Console.WriteLine("Asynchronous work started...");
        await Task.Delay(2000); // Simulating asynchronous operation

SynchronousWork Method

Initiates synchronous work. Inside this method, an asynchronous operation is invoked using Task.Run(). Task.Run() queues the specified work to run on the ThreadPool. Inside the lambda expression, await is used to wait for the asynchronous method AsynchronousWorkAsync() to complete. .Wait() ensures that the asynchronous operation completes before moving to the next line. This approach effectively blocks the synchronous method until the asynchronous operation finishes.


Programming C# frequently calls for integrating asynchronous features into synchronous methods. via making use of structures like Task.Run(), await, and Task.Wait().With the help of Wait(), you may efficiently invoke asynchronous methods from synchronous ones in your applications while maintaining appropriate synchronisation and responsiveness. To make smart design choices, it is necessary to understand the implications and compromises connected to synchronous and asynchronous programming approaches.


Q 1. What is the purpose of calling asynchronous methods from synchronous methods?

Ans. The purpose is to integrate asynchronous functionality into synchronous codebases or frameworks. Asynchronous methods allow non-blocking execution, making the application more responsive and scalable, especially for I/O-bound operations.

Q 2. How can I call an asynchronous method from a synchronous method in C#?

Ans. You can call an asynchronous method from a synchronous method by using constructs like Task.Run() or Task.Wait(). Inside the synchronous method, you can invoke the asynchronous method using await to asynchronously wait for its completion.

Q 3. Is it safe to block a synchronous method to wait for an asynchronous operation to complete?

Ans. Blocking a synchronous method to wait for an asynchronous operation to complete is generally safe if done correctly. However, it's essential to avoid deadlocks by using appropriate synchronization constructs and handling exceptions properly.

Q 4. What are the potential pitfalls of calling asynchronous methods from synchronous methods?

Ans. Some common pitfalls include deadlocks, decreased performance due to blocking, and potential exceptions if not properly handled. It's crucial to understand these pitfalls and apply best practices to mitigate them.

Q 5. Are there alternative approaches to calling asynchronous methods from synchronous methods?

Ans. Yes, alternative approaches include restructuring code to be fully asynchronous, using asynchronous event handlers, or using synchronization primitives like TaskCompletionSource for more fine-grained control over asynchronous operations.

Similar Articles