Calling async method synchronously

You can run the method in a thread pool thread and use the task's awaiter to block the calling thread until the asynchronous operation has completed:

string code = Task.Run(() => GenerateCodeAsync()).GetAwaiter().GetResult(); 

Why is .Result not good enough?

You might be tempted to just access the Result property of the task to achieve the same result:

string code = GenerateCodeAsync().Result; 

This naive approach, however, has two drawbacks:

1. In some cases this leads to a deadlock: Your call to Result blocks the main thread, thereby preventing the remainder of the async code to execute. This can be avoided by adding .ConfigureAwait(false) at the right places, but doing this correctly is not trivial.

   We avoid this issue by calling Task.Run to execute the asynchronous method in a thread pool thread.

2. .Result (or .Wait() for tasks without a return value) will wrap any Exception that may be thrown in your asynchronous method in an AggregateException.

   We avoid this issue by calling .GetAwaiter().GetResult() instead.

You can get the TaskAwaiter with the GetAwaiter method, and wait synchronously for the completion of the task with the blocking GetResult method:

string code = GenerateCodeAsync().GetAwaiter().GetResult(); 

Important: The GetResult method has blocking behavior only for the Task/Task<T> awaitable types, not for the ValueTask/ValueTask<T> structs. You should never call this method directly on value tasks (these types have strict usage limitations). What you can do is to use first the AsTask and convert the value tasks to normal reference tasks. Here is an example of synchronously waiting the ValueTask returned by the Timer.DisposeAsync method:

timer.DisposeAsync().AsTask().GetAwaiter().GetResult(); 

Addressing criticism

1. According to the documentation, this method is intended for compiler use rather than use directly in code.

   Microsoft offers no alternative API that waits synchronously a task, and has the same error-propagating behavior with the await operator. So this is what we have to use. Quoting from the article Task Exception Handling in .NET 4.5 by Stephen Toub:

   However, you may [...] want the original exception propagated unwrapped rather than it being encased in an AggregateException. To achieve that, you can target the Task’s awaiter directly. When you write await task;, the compiler translates that into usage of the Task.GetAwaiter() method, which returns an instance that has a GetResult() method. When used on a faulted Task, GetResult() will propagate the original exception (this is how await task; gets its behavior). You can thus use task.GetAwaiter().GetResult() if you want to directly invoke this propagation logic.

   The .GetAwaiter().GetResult() is also recommended by Microsoft for console applications with asynchronous calls in Main. Before the introduction of static async Task Main entry points in C# 7.1 (August 2017), we were advised to use directly the .GetAwaiter().GetResult() ourselves.

2. We've run into deadlocks using this solution. Be warned.

   The deadlock happens in case a single-threaded synchronization context is installed on the current thread, and the async method includes at least one await that lacks the .ConfigureAwait(false) configuration. Under these specific conditions the deadlock is predictable and happens consistently, so you'll be forced to fix it ASAP using one of the available workarounds. It's not an intermittent error that you might miss. The UI will stop responding, and you'll have to kill the process from the Task Manager. The mere fact that the deadlock has such an obtrusive effect, minimizes its risk factor. In other words you won't ship deadlocking code, unless you don't test your application before shipping it.

You should be able to get this done using delegates, lambda expression

private void button2_Click(object sender, EventArgs e) { label1.Text = "waiting...."; Task<string> sCode = Task.Run(async () => { string msg =await GenerateCodeAsync(); return msg; }); label1.Text += sCode.Result; } private Task<string> GenerateCodeAsync() { return Task.Run<string>(() => GenerateCode()); } private string GenerateCode() { Thread.Sleep(2000); return "I m back" ; } 

Microsoft Identity has extension methods which call async methods synchronously. For example there is GenerateUserIdentityAsync() method and equal CreateIdentity()

If you look at UserManagerExtensions.CreateIdentity() it look like this:

 public static ClaimsIdentity CreateIdentity<TUser, TKey>(this UserManager<TUser, TKey> manager, TUser user, string authenticationType) where TKey : IEquatable<TKey> where TUser : class, IUser<TKey> { if (manager == null) { throw new ArgumentNullException("manager"); } return AsyncHelper.RunSync(() => manager.CreateIdentityAsync(user, authenticationType)); } 

Now lets see what AsyncHelper.RunSync does

 public static TResult RunSync<TResult>(Func<Task<TResult>> func) { var cultureUi = CultureInfo.CurrentUICulture; var culture = CultureInfo.CurrentCulture; return _myTaskFactory.StartNew(() => { Thread.CurrentThread.CurrentCulture = culture; Thread.CurrentThread.CurrentUICulture = cultureUi; return func(); }).Unwrap().GetAwaiter().GetResult(); } 

So, this is your wrapper for async method. And please don't read data from Result - it will potentially block your code in ASP.

There is another way - which is suspicious for me, but you can consider it too

 Result r = null; YourAsyncMethod() .ContinueWith(t => { r = t.Result; }) .Wait(); 

To prevent deadlocks I always try to use Task.Run() when I have to call an async method synchronously that @Heinzi mentions.

However the method has to be modified if the async method uses parameters. For example Task.Run(GenerateCodeAsync("test")).Result gives the error:

Argument 1: cannot convert from 'System.Threading.Tasks.Task<string>' to 'System.Action'

This could be called like this instead:

string code = Task.Run(() => GenerateCodeAsync("test")).Result; 

I need to call this method from a synchronously method.

It's possible with GenerateCodeAsync().Result or GenerateCodeAsync().Wait(), as the other answer suggests. This would block the current thread until GenerateCodeAsync has completed.

However, your question is tagged with asp.net, and you also left the comment:

I was hoping for a simpler solution, thinking that asp.net handled this much easier than writing so many lines of code

My point is, you should not be blocking on an asynchronous method in ASP.NET. This will reduce the scalability of your web app, and may create a deadlock (when an await continuation inside GenerateCodeAsync is posted to AspNetSynchronizationContext). Using Task.Run(...).Result to offload something to a pool thread and then block will hurt the scalability even more, as it incurs +1 more thread to process a given HTTP request.

ASP.NET has built-in support for asynchronous methods, either through asynchronous controllers (in ASP.NET MVC and Web API) or directly via AsyncManager and PageAsyncTask in classic ASP.NET. You should use it. For more details, check this answer.

Most of the answers on this thread are either complex or will result in deadlock.

Following method is simple and it will avoid deadlock because we are waiting for the task to finish and only then getting its result-

var task = Task.Run(() => GenerateCodeAsync()); task.Wait(); string code = task.Result; 

Furthermore, here is a reference to MSDN article that talks about exactly same thing- https://blogs.msdn.microsoft.com/jpsanders/2017/08/28/asp-net-do-not-use-task-result-in-main-context/

Well I was using this approach for years, which also handles and propagates exceptions from the underlying async task. Which works flawlessly.

 private string RunSync() { var task = Task.Run(async () => await GenerateCodeService.GenerateCodeAsync()); if (task.IsFaulted && task.Exception != null) { throw task.Exception; } return task.Result; } 

But since that Microsoft created this async helper: https://github.com/aspnet/AspNetIdentity/blob/main/src/Microsoft.AspNet.Identity.Core/AsyncHelper.cs

Here is also their source:

 public static void RunSync(Func<Task> func) { var cultureUi = CultureInfo.CurrentUICulture; var culture = CultureInfo.CurrentCulture; _myTaskFactory.StartNew(() => { Thread.CurrentThread.CurrentCulture = culture; Thread.CurrentThread.CurrentUICulture = cultureUi; return func(); }).Unwrap().GetAwaiter().GetResult(); } 

How about some extension methods that asynchronously await the completion of the asynchronous operation, then set a ManualResetEvent to indicate completion.

NOTE: You can use Task.Run(), however extension methods are a cleaner interface for expressing what you really want.

Tests showing how to use the extensions:

 [TestClass] public class TaskExtensionsTests { [TestMethod] public void AsynchronousOperationWithNoResult() { SampleAsynchronousOperationWithNoResult().AwaitResult(); } [TestMethod] public void AsynchronousOperationWithResult() { Assert.AreEqual(3, SampleAsynchronousOperationWithResult(3).AwaitResult()); } [TestMethod] [ExpectedException(typeof(Exception))] public void AsynchronousOperationWithNoResultThrows() { SampleAsynchronousOperationWithNoResultThrows().AwaitResult(); } [TestMethod] [ExpectedException(typeof(Exception))] public void AsynchronousOperationWithResultThrows() { SampleAsynchronousOperationWithResultThrows(3).AwaitResult(); } private static async Task SampleAsynchronousOperationWithNoResult() { await Task.Yield(); } private static async Task<T> SampleAsynchronousOperationWithResult<T>(T result) { await Task.Yield(); return result; } private static async Task SampleAsynchronousOperationWithNoResultThrows() { await Task.Yield(); throw new Exception(); } private static async Task<T> SampleAsynchronousOperationWithResultThrows<T>(T result) { await Task.Yield(); throw new Exception(); } [TestMethod] public void AsynchronousValueOperationWithNoResult() { SampleAsynchronousValueOperationWithNoResult().AwaitResult(); } [TestMethod] public void AsynchronousValueOperationWithResult() { Assert.AreEqual(3, SampleAsynchronousValueOperationWithResult(3).AwaitResult()); } [TestMethod] [ExpectedException(typeof(Exception))] public void AsynchronousValueOperationWithNoResultThrows() { SampleAsynchronousValueOperationWithNoResultThrows().AwaitResult(); } [TestMethod] [ExpectedException(typeof(Exception))] public void AsynchronousValueOperationWithResultThrows() { SampleAsynchronousValueOperationWithResultThrows(3).AwaitResult(); } private static async ValueTask SampleAsynchronousValueOperationWithNoResult() { await Task.Yield(); } private static async ValueTask<T> SampleAsynchronousValueOperationWithResult<T>(T result) { await Task.Yield(); return result; } private static async ValueTask SampleAsynchronousValueOperationWithNoResultThrows() { await Task.Yield(); throw new Exception(); } private static async ValueTask<T> SampleAsynchronousValueOperationWithResultThrows<T>(T result) { await Task.Yield(); throw new Exception(); } } 

The extensions

 /// <summary> /// Defines extension methods for <see cref="Task"/> and <see cref="ValueTask"/>. /// </summary> public static class TaskExtensions { /// <summary> /// Synchronously await the results of an asynchronous operation without deadlocking; ignoring cancellation. /// </summary> /// <param name="task"> /// The <see cref="Task"/> representing the pending operation. /// </param> public static void AwaitCompletion(this ValueTask task) { new SynchronousAwaiter(task, true).GetResult(); } /// <summary> /// Synchronously await the results of an asynchronous operation without deadlocking; ignoring cancellation. /// </summary> /// <param name="task"> /// The <see cref="Task"/> representing the pending operation. /// </param> public static void AwaitCompletion(this Task task) { new SynchronousAwaiter(task, true).GetResult(); } /// <summary> /// Synchronously await the results of an asynchronous operation without deadlocking. /// </summary> /// <param name="task"> /// The <see cref="Task"/> representing the pending operation. /// </param> /// <typeparam name="T"> /// The result type of the operation. /// </typeparam> /// <returns> /// The result of the operation. /// </returns> public static T AwaitResult<T>(this Task<T> task) { return new SynchronousAwaiter<T>(task).GetResult(); } /// <summary> /// Synchronously await the results of an asynchronous operation without deadlocking. /// </summary> /// <param name="task"> /// The <see cref="Task"/> representing the pending operation. /// </param> public static void AwaitResult(this Task task) { new SynchronousAwaiter(task).GetResult(); } /// <summary> /// Synchronously await the results of an asynchronous operation without deadlocking. /// </summary> /// <param name="task"> /// The <see cref="ValueTask"/> representing the pending operation. /// </param> /// <typeparam name="T"> /// The result type of the operation. /// </typeparam> /// <returns> /// The result of the operation. /// </returns> public static T AwaitResult<T>(this ValueTask<T> task) { return new SynchronousAwaiter<T>(task).GetResult(); } /// <summary> /// Synchronously await the results of an asynchronous operation without deadlocking. /// </summary> /// <param name="task"> /// The <see cref="ValueTask"/> representing the pending operation. /// </param> public static void AwaitResult(this ValueTask task) { new SynchronousAwaiter(task).GetResult(); } /// <summary> /// Ignore the <see cref="OperationCanceledException"/> if the operation is cancelled. /// </summary> /// <param name="task"> /// The <see cref="Task"/> representing the asynchronous operation whose cancellation is to be ignored. /// </param> /// <returns> /// The <see cref="Task"/> representing the asynchronous operation whose cancellation is ignored. /// </returns> public static async Task IgnoreCancellationResult(this Task task) { try { await task.ConfigureAwait(false); } catch (OperationCanceledException) { } } /// <summary> /// Ignore the <see cref="OperationCanceledException"/> if the operation is cancelled. /// </summary> /// <param name="task"> /// The <see cref="ValueTask"/> representing the asynchronous operation whose cancellation is to be ignored. /// </param> /// <returns> /// The <see cref="ValueTask"/> representing the asynchronous operation whose cancellation is ignored. /// </returns> public static async ValueTask IgnoreCancellationResult(this ValueTask task) { try { await task.ConfigureAwait(false); } catch (OperationCanceledException) { } } /// <summary> /// Ignore the results of an asynchronous operation allowing it to run and die silently in the background. /// </summary> /// <param name="task"> /// The <see cref="Task"/> representing the asynchronous operation whose results are to be ignored. /// </param> public static async void IgnoreResult(this Task task) { try { await task.ConfigureAwait(false); } catch { // ignore exceptions } } /// <summary> /// Ignore the results of an asynchronous operation allowing it to run and die silently in the background. /// </summary> /// <param name="task"> /// The <see cref="ValueTask"/> representing the asynchronous operation whose results are to be ignored. /// </param> public static async void IgnoreResult(this ValueTask task) { try { await task.ConfigureAwait(false); } catch { // ignore exceptions } } } /// <summary> /// Internal class for waiting for asynchronous operations that have a result. /// </summary> /// <typeparam name="TResult"> /// The result type. /// </typeparam> public class SynchronousAwaiter<TResult> { /// <summary> /// The manual reset event signaling completion. /// </summary> private readonly ManualResetEvent manualResetEvent; /// <summary> /// The exception thrown by the asynchronous operation. /// </summary> private Exception exception; /// <summary> /// The result of the asynchronous operation. /// </summary> private TResult result; /// <summary> /// Initializes a new instance of the <see cref="SynchronousAwaiter{TResult}"/> class. /// </summary> /// <param name="task"> /// The task representing an asynchronous operation. /// </param> public SynchronousAwaiter(Task<TResult> task) { this.manualResetEvent = new ManualResetEvent(false); this.WaitFor(task); } /// <summary> /// Initializes a new instance of the <see cref="SynchronousAwaiter{TResult}"/> class. /// </summary> /// <param name="task"> /// The task representing an asynchronous operation. /// </param> public SynchronousAwaiter(ValueTask<TResult> task) { this.manualResetEvent = new ManualResetEvent(false); this.WaitFor(task); } /// <summary> /// Gets a value indicating whether the operation is complete. /// </summary> public bool IsComplete => this.manualResetEvent.WaitOne(0); /// <summary> /// Synchronously get the result of an asynchronous operation. /// </summary> /// <returns> /// The result of the asynchronous operation. /// </returns> public TResult GetResult() { this.manualResetEvent.WaitOne(); return this.exception != null ? throw this.exception : this.result; } /// <summary> /// Tries to synchronously get the result of an asynchronous operation. /// </summary> /// <param name="operationResult"> /// The result of the operation. /// </param> /// <returns> /// The result of the asynchronous operation. /// </returns> public bool TryGetResult(out TResult operationResult) { if (this.IsComplete) { operationResult = this.exception != null ? throw this.exception : this.result; return true; } operationResult = default; return false; } /// <summary> /// Background "thread" which waits for the specified asynchronous operation to complete. /// </summary> /// <param name="task"> /// The task. /// </param> private async void WaitFor(Task<TResult> task) { try { this.result = await task.ConfigureAwait(false); } catch (Exception exception) { this.exception = exception; } finally { this.manualResetEvent.Set(); } } /// <summary> /// Background "thread" which waits for the specified asynchronous operation to complete. /// </summary> /// <param name="task"> /// The task. /// </param> private async void WaitFor(ValueTask<TResult> task) { try { this.result = await task.ConfigureAwait(false); } catch (Exception exception) { this.exception = exception; } finally { this.manualResetEvent.Set(); } } } /// <summary> /// Internal class for waiting for asynchronous operations that have no result. /// </summary> public class SynchronousAwaiter { /// <summary> /// The manual reset event signaling completion. /// </summary> private readonly ManualResetEvent manualResetEvent = new ManualResetEvent(false); /// <summary> /// The exception thrown by the asynchronous operation. /// </summary> private Exception exception; /// <summary> /// Initializes a new instance of the <see cref="SynchronousAwaiter{TResult}"/> class. /// </summary> /// <param name="task"> /// The task representing an asynchronous operation. /// </param> /// <param name="ignoreCancellation"> /// Indicates whether to ignore cancellation. Default is false. /// </param> public SynchronousAwaiter(Task task, bool ignoreCancellation = false) { this.manualResetEvent = new ManualResetEvent(false); this.WaitFor(task, ignoreCancellation); } /// <summary> /// Initializes a new instance of the <see cref="SynchronousAwaiter{TResult}"/> class. /// </summary> /// <param name="task"> /// The task representing an asynchronous operation. /// </param> /// <param name="ignoreCancellation"> /// Indicates whether to ignore cancellation. Default is false. /// </param> public SynchronousAwaiter(ValueTask task, bool ignoreCancellation = false) { this.manualResetEvent = new ManualResetEvent(false); this.WaitFor(task, ignoreCancellation); } /// <summary> /// Gets a value indicating whether the operation is complete. /// </summary> public bool IsComplete => this.manualResetEvent.WaitOne(0); /// <summary> /// Synchronously get the result of an asynchronous operation. /// </summary> public void GetResult() { this.manualResetEvent.WaitOne(); if (this.exception != null) { throw this.exception; } } /// <summary> /// Background "thread" which waits for the specified asynchronous operation to complete. /// </summary> /// <param name="task"> /// The task. /// </param> /// <param name="ignoreCancellation"> /// Indicates whether to ignore cancellation. Default is false. /// </param> private async void WaitFor(Task task, bool ignoreCancellation) { try { await task.ConfigureAwait(false); } catch (OperationCanceledException) { } catch (Exception exception) { this.exception = exception; } finally { this.manualResetEvent.Set(); } } /// <summary> /// Background "thread" which waits for the specified asynchronous operation to complete. /// </summary> /// <param name="task"> /// The task. /// </param> /// <param name="ignoreCancellation"> /// Indicates whether to ignore cancellation. Default is false. /// </param> private async void WaitFor(ValueTask task, bool ignoreCancellation) { try { await task.ConfigureAwait(false); } catch (OperationCanceledException) { } catch (Exception exception) { this.exception = exception; } finally { this.manualResetEvent.Set(); } } } } 

EDIT:

Task has Wait method, Task.Wait(), which waits for the "promise" to resolve and then continues, thus rendering it synchronous. example:

 async Task<String> MyAsyncMethod() { ... } String mySyncMethod() { return MyAsyncMethod().Wait(); }