C#中如何从同步方法调用异步方法？

Question

我有一个 public async Task Foo() 方法，我想从同步方法调用它。到目前为止，我从 MSDN 文档中看到的都是通过 async 方法调用 async 方法，但我的整个程序并不是使用 async 方法构建的。

这可能吗？

以下是从异步方法调用这些方法的一个示例：
演练：访问使用 Async 和 Await 进行 Web（C# 和 Visual Basic）

现在，我正在考虑从同步方法调用这些async 方法。

Answer 1

异步编程确实通过代码库“增长”。它已经与僵尸病毒相比。最好的解决办法是让它继续生长，但有时这是不可能的。

我在 Nito.AsyncEx 库中编写了一些类型，用于处理部分异步代码库。不过，没有一种解决方案适用于所有情况。

解决方案 A

如果您有一个简单的异步方法，不需要同步回其上下文，那么您可以使用 Task.WaitAndUnwrapException：

var task = MyAsyncMethod();
var result = task.WaitAndUnwrapException();

您不< /em> 希望使用 Task.Wait 或 Task.Result 因为它们将异常包装在 AggregateException 中。

仅当 MyAsyncMethod 未同步回其上下文时，此解决方案才适用。换句话说，MyAsyncMethod 中的每个 await 都应以 ConfigureAwait(false) 结尾。这意味着它无法更新任何 UI 元素或访问 ASP.NET 请求上下文。

解决方案 B

如果 MyAsyncMethod 确实需要同步回其上下文，那么您可以使用 AsyncContext.RunTask 来提供嵌套上下文：

var result = AsyncContext.RunTask(MyAsyncMethod).Result;

---

*更新 4/14/2014：在该库的最新版本中，API 如下：（

var result = AsyncContext.Run(MyAsyncMethod);

---

在此示例中使用 Task.Result 是可以的，因为 RunTask 将传播任务例外）。

您可能需要 AsyncContext.RunTask 而不是 Task.WaitAndUnwrapException 的原因是 WinForms/WPF/SL/ASP.NET 上发生相当微妙的死锁可能性

1. ：方法调用异步方法，获取Task。
2. 同步方法对 Task 执行阻塞等待。
3. async 方法使用 await，而不使用 ConfigureAwait。
4. 在这种情况下，Task 无法完成，因为它仅在 async 方法完成时完成； async 方法无法完成，因为它正在尝试将其延续安排到 SynchronizationContext，并且 WinForms/WPF/SL/ASP.NET 将不允许延续运行，因为同步方法已经在该上下文中运行。

这就是为什么在每个 async 方法中尽可能使用 ConfigureAwait(false) 是个好主意的原因之一。

解决方案 C

AsyncContext.RunTask 并不适用于所有场景。例如，如果 async 方法等待需要 UI 事件才能完成的操作，那么即使使用嵌套上下文，也会出现死锁。在这种情况下，您可以在线程池上启动 async 方法：

var task = Task.Run(async () => await MyAsyncMethod());
var result = task.WaitAndUnwrapException();

但是，此解决方案需要一个可在线程池上下文中工作的 MyAsyncMethod。因此它无法更新 UI 元素或访问 ASP.NET 请求上下文。在这种情况下，您也可以将 ConfigureAwait(false) 添加到其 await 语句中，并使用解决方案 A。

更新： 2015 MSDN 文章'异步编程 - Brownfield 异步开发'，作者：Stephen Cleary。

Answer 2

添加最终解决我的问题的解决方案，希望可以节省某人的时间。

首先阅读 Stephen Cleary 的几篇文章：

• 异步和等待
• 不要阻止异步代码

来自“两个“最佳实践”中的“不要阻止异步代码”，第一个对我不起作用，第二个也不适用（基本上，如果我可以使用 await，我就这样做！） 。

所以这是我的解决方法：将调用包装在 Task.Run<>(async () =>await FunctionAsync()); 中，希望不再出现死锁。

这是我的代码：

public class LogReader
{
    ILogger _logger;

    public LogReader(ILogger logger)
    {
        _logger = logger;
    }

    public LogEntity GetLog()
    {
        Task<LogEntity> task = Task.Run<LogEntity>(async () => await GetLogAsync());
        return task.Result;
    }

    public async Task<LogEntity> GetLogAsync()
    {
        var result = await _logger.GetAsync();
        // more code here...
        return result as LogEntity;
    }
}

Answer 3

Microsoft 构建了一个 AsyncHelper（内部）类来将异步作为同步运行。源代码如下所示：

internal static class AsyncHelper
{
    private static readonly TaskFactory _myTaskFactory = new 
      TaskFactory(CancellationToken.None, 
                  TaskCreationOptions.None, 
                  TaskContinuationOptions.None, 
                  TaskScheduler.Default);

    public static TResult RunSync<TResult>(Func<Task<TResult>> func)
    {
        return AsyncHelper._myTaskFactory
          .StartNew<Task<TResult>>(func)
          .Unwrap<TResult>()
          .GetAwaiter()
          .GetResult();
    }

    public static void RunSync(Func<Task> func)
    {
        AsyncHelper._myTaskFactory
          .StartNew<Task>(func)
          .Unwrap()
          .GetAwaiter()
          .GetResult();
    }
}

Microsoft.AspNet.Identity 基类仅具有异步方法，为了将它们称为同步，有一些带有扩展方法的类，如下所示（示例用法）：

public static TUser FindById<TUser, TKey>(this UserManager<TUser, TKey> manager, TKey userId) where TUser : class, IUser<TKey> where TKey : IEquatable<TKey>
{
    if (manager == null)
    {
        throw new ArgumentNullException("manager");
    }
    return AsyncHelper.RunSync<TUser>(() => manager.FindByIdAsync(userId));
}

public static bool IsInRole<TUser, TKey>(this UserManager<TUser, TKey> manager, TKey userId, string role) where TUser : class, IUser<TKey> where TKey : IEquatable<TKey>
{
    if (manager == null)
    {
        throw new ArgumentNullException("manager");
    }
    return AsyncHelper.RunSync<bool>(() => manager.IsInRoleAsync(userId, role));
}

对于那些关心代码许可条款的人，请参见此处是一个指向非常相似代码的链接（只是添加了对线程文化的支持），其中有注释表明它是由 Microsoft 授权的 MIT。 https://github.com/aspnet /AspNetIdentity/blob/master/src/Microsoft.AspNet.Identity.Core/AsyncHelper.cs

这不是和调用 Task.Run(async ()=>await AsyncFunc()).Result 一样吗？ AFAIK，微软现在不鼓励调用 TaskFactory.StartNew，因为它们都是等效的，并且一个比另一个更具可读性。

绝对不是。

简单的答案是，

.Unwrap().GetAwaiter().GetResult() != .Result

首先

Task.Result 是否与 . GetAwaiter.GetResult()?

其次.Unwrap() 导致任务的设置不会阻止包装的任务。

这应该会导致任何人问

这不是和调用 Task.Run(async ()=>await AsyncFunc()).GetAwaiter().GetResult() 一样吗

然后这将是一个It Depends。

关于 Task.Start() 、 Task.Run() 和 Task.Factory.StartNew() 的使用

摘录：

Task.Run 使用 TaskCreationOptions.DenyChildAttach，这意味着子任务不能附加到父任务，并且它使用 TaskScheduler.Default，这意味着在线程池上运行任务的任务将始终用于运行任务。

Task.Factory.StartNew 使用 TaskScheduler.Current 表示当前线程的调度程序，它可能是 TaskScheduler.Default 但不总是。

附加阅读：

指定同步上下文

ASP.NET Core SynchronizationContext

为了更加安全，像这样调用它不是更好吗 AsyncHelper.RunSync(async () => wait AsyncMethod().ConfigureAwait(false));这样我们就告诉“内部”方法“请不要尝试同步到上层上下文并解除锁定”

alex-from-jitbit<的观点非常好/a> 和大多数对象架构问题一样，这取决于。

作为扩展方法，您是否希望绝对每次调用都强制执行此操作，还是让使用该函数的程序员在自己的异步调用上配置该操作？我可以看到调用三个场景的用例；它很可能不是您在 WPF 中想要的东西，在大多数情况下当然有意义，但考虑到没有 ASP.Net Core 中的上下文 如果您可以保证它是 ASP.Net Core 的内部内容，那么这并不重要。

Answer 4

async Main() 现在是 C# 7.2 的一部分，可以在项目高级构建设置中启用。

对于 C# < 7.2，正确的做法是：

static void Main(string[] args)
{
   MainAsync().GetAwaiter().GetResult();
}

static async Task MainAsync()
{
   /*await stuff here*/
}

你会在很多微软文档中看到这个用法，例如：
获取从 Azure 服务总线主题和订阅开始。

Answer 5

我不是 100% 确定，但我相信 此博客应该适用于多种情况：

如果您想直接调用此传播逻辑，则可以使用 task.GetAwaiter().GetResult()。

Answer 6

public async Task<string> StartMyTask()
{
    await Foo()
    // code to execute once foo is done
}

static void Main()
{
     var myTask = StartMyTask(); // call your method which will return control once it hits await
     // now you can continue executing code here
     string result = myTask.Result; // wait for the task to complete to continue
     // use result

}

您将“await”关键字理解为“启动此长时间运行的任务，然后将控制权返回给调用方法”。一旦长时间运行的任务完成，它就会执行其后的代码。 wait 之后的代码与以前的 CallBack 方法类似。最大的区别是逻辑流程不会被中断，这使得写入和读取变得更加容易。

Answer 7

然而，有一个适用于（几乎：参见评论）每种情况的良好解决方案：即席消息泵（SynchronizationContext）。

调用线程将按预期被阻塞，同时仍然确保从异步函数调用的所有延续不会死锁，因为它们将被编组到在调用线程上运行的临时 SynchronizationContext（消息泵）。

ad-hoc 消息泵助手的代码：

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

namespace Microsoft.Threading
{
    /// <summary>Provides a pump that supports running asynchronous methods on the current thread.</summary>
    public static class AsyncPump
    {
        /// <summary>Runs the specified asynchronous method.</summary>
        /// <param name="asyncMethod">The asynchronous method to execute.</param>
        public static void Run(Action asyncMethod)
        {
            if (asyncMethod == null) throw new ArgumentNullException("asyncMethod");

            var prevCtx = SynchronizationContext.Current;
            try
            {
                // Establish the new context
                var syncCtx = new SingleThreadSynchronizationContext(true);
                SynchronizationContext.SetSynchronizationContext(syncCtx);

                // Invoke the function
                syncCtx.OperationStarted();
                asyncMethod();
                syncCtx.OperationCompleted();

                // Pump continuations and propagate any exceptions
                syncCtx.RunOnCurrentThread();
            }
            finally { SynchronizationContext.SetSynchronizationContext(prevCtx); }
        }

        /// <summary>Runs the specified asynchronous method.</summary>
        /// <param name="asyncMethod">The asynchronous method to execute.</param>
        public static void Run(Func<Task> asyncMethod)
        {
            if (asyncMethod == null) throw new ArgumentNullException("asyncMethod");

            var prevCtx = SynchronizationContext.Current;
            try
            {
                // Establish the new context
                var syncCtx = new SingleThreadSynchronizationContext(false);
                SynchronizationContext.SetSynchronizationContext(syncCtx);

                // Invoke the function and alert the context to when it completes
                var t = asyncMethod();
                if (t == null) throw new InvalidOperationException("No task provided.");
                t.ContinueWith(delegate { syncCtx.Complete(); }, TaskScheduler.Default);

                // Pump continuations and propagate any exceptions
                syncCtx.RunOnCurrentThread();
                t.GetAwaiter().GetResult();
            }
            finally { SynchronizationContext.SetSynchronizationContext(prevCtx); }
        }

        /// <summary>Runs the specified asynchronous method.</summary>
        /// <param name="asyncMethod">The asynchronous method to execute.</param>
        public static T Run<T>(Func<Task<T>> asyncMethod)
        {
            if (asyncMethod == null) throw new ArgumentNullException("asyncMethod");

            var prevCtx = SynchronizationContext.Current;
            try
            {
                // Establish the new context
                var syncCtx = new SingleThreadSynchronizationContext(false);
                SynchronizationContext.SetSynchronizationContext(syncCtx);

                // Invoke the function and alert the context to when it completes
                var t = asyncMethod();
                if (t == null) throw new InvalidOperationException("No task provided.");
                t.ContinueWith(delegate { syncCtx.Complete(); }, TaskScheduler.Default);

                // Pump continuations and propagate any exceptions
                syncCtx.RunOnCurrentThread();
                return t.GetAwaiter().GetResult();
            }
            finally { SynchronizationContext.SetSynchronizationContext(prevCtx); }
        }

        /// <summary>Provides a SynchronizationContext that's single-threaded.</summary>
        private sealed class SingleThreadSynchronizationContext : SynchronizationContext
        {
            /// <summary>The queue of work items.</summary>
            private readonly BlockingCollection<KeyValuePair<SendOrPostCallback, object>> m_queue =
                new BlockingCollection<KeyValuePair<SendOrPostCallback, object>>();
            /// <summary>The processing thread.</summary>
            private readonly Thread m_thread = Thread.CurrentThread;
            /// <summary>The number of outstanding operations.</summary>
            private int m_operationCount = 0;
            /// <summary>Whether to track operations m_operationCount.</summary>
            private readonly bool m_trackOperations;

            /// <summary>Initializes the context.</summary>
            /// <param name="trackOperations">Whether to track operation count.</param>
            internal SingleThreadSynchronizationContext(bool trackOperations)
            {
                m_trackOperations = trackOperations;
            }

            /// <summary>Dispatches an asynchronous message to the synchronization context.</summary>
            /// <param name="d">The System.Threading.SendOrPostCallback delegate to call.</param>
            /// <param name="state">The object passed to the delegate.</param>
            public override void Post(SendOrPostCallback d, object state)
            {
                if (d == null) throw new ArgumentNullException("d");
                m_queue.Add(new KeyValuePair<SendOrPostCallback, object>(d, state));
            }

            /// <summary>Not supported.</summary>
            public override void Send(SendOrPostCallback d, object state)
            {
                throw new NotSupportedException("Synchronously sending is not supported.");
            }

            /// <summary>Runs an loop to process all queued work items.</summary>
            public void RunOnCurrentThread()
            {
                foreach (var workItem in m_queue.GetConsumingEnumerable())
                    workItem.Key(workItem.Value);
            }

            /// <summary>Notifies the context that no more work will arrive.</summary>
            public void Complete() { m_queue.CompleteAdding(); }

            /// <summary>Invoked when an async operation is started.</summary>
            public override void OperationStarted()
            {
                if (m_trackOperations)
                    Interlocked.Increment(ref m_operationCount);
            }

            /// <summary>Invoked when an async operation is completed.</summary>
            public override void OperationCompleted()
            {
                if (m_trackOperations &&
                    Interlocked.Decrement(ref m_operationCount) == 0)
                    Complete();
            }
        }
    }
}

用法：

AsyncPump.Run(() => FooAsync(...));

异步泵的更详细说明可参见 此处。

Answer 8

对于任何再关注这个问题的人...

如果您查看 Microsoft.VisualStudio.Services.WebApi ，就会发现有一个名为 TaskExtensions 的类。在该类中，您将看到静态扩展方法 Task.SyncResult()，它完全会阻塞线程直到任务返回。

它在内部调用 task.GetAwaiter().GetResult() ，这非常简单，但是它会重载以处理任何返回 Task 的 async 方法。 、 Task 或 Task...语法糖，宝贝...爸爸爱吃甜食。

看起来 ...GetAwaiter().GetResult() 是在阻塞上下文中执行异步代码的 MS 官方方法。似乎非常适合我的用例。

Answer 9

var result = Task.Run(async () => await configManager.GetConfigurationAsync()).ConfigureAwait(false);

OpenIdConnectConfiguration config = result.GetAwaiter().GetResult();

或者使用这个：

var result=result.GetAwaiter().GetResult().AccessToken

Answer 10

您可以从同步代码调用任何异步方法，也就是说，直到您需要 await 时，它们也必须标记为 async。

正如很多人在这里建议的那样，您可以在同步方法中对生成的任务调用 Wait() 或 Result，但最终会在该方法中遇到阻塞调用，这有点失败异步的目的。

如果您确实无法使您的方法异步并且您不想锁定同步方法，那么您将不得不使用回调方法，将其作为参数传递给<任务的 code>ContinueWith() 方法。

Answer 11

这是最简单的解决方案。我在互联网上的某个地方看到过，我不记得在哪里了，但我一直在成功地使用它。它不会使调用线程死锁。

    void SynchronousFunction()
    {
        Task.Run(Foo).Wait();
    }

    string SynchronousFunctionReturnsString()
    {
        return Task.Run(Foo).Result;
    }

    string SynchronousFunctionReturnsStringWithParam(int id)
    {
        return Task.Run(() => Foo(id)).Result;
    }

Answer 12

斯蒂芬·克利里的回答；

这种方法不应该导致死锁（假设
ProblemMethodAsync 不会将更新发送到 UI 线程或任何其他内容
像这样）。它确实假设 ProblemMethodAsync 可以在
线程池线程，但情况并非总是如此。

https://blog.stephencleary.com/2012/07 /dont-block-on-async-code.html

这是方法；

线程池黑客与阻塞黑客类似的方法是
将异步工作卸载到线程池，然后阻塞
由此产生的任务。使用此 hack 的代码看起来像代码
如图7所示。

图 7 线程池黑客代码

C#

public sealed class WebDataService : IDataService
{
  public string Get(int id)
  {
    return Task.Run(() => GetAsync(id)).GetAwaiter().GetResult();
  }
  public async Task<string> GetAsync(int id)
  {
    using (var client = new WebClient())
      return await client.DownloadStringTaskAsync(
      "https://www.example.com/api/values/" + id);
  }
}

代码

调用 Task.Run 在线程池上执行异步方法
线。这里它将在没有上下文的情况下运行，从而避免
僵局。这种方法的问题之一是异步
方法不能依赖于在特定上下文中执行。所以，它
无法使用 UI 元素或 ASP.NET HttpContext.Current。

Answer 13

受到其他一些答案的启发，我创建了以下简单的辅助方法：

public static TResult RunSync<TResult>(Func<Task<TResult>> method)
{
    var task = method();
    return task.GetAwaiter().GetResult();
}

public static void RunSync(Func<Task> method)
{
    var task = method();
    task.GetAwaiter().GetResult();
}

可以按如下方式调用它们（取决于您是否返回值）：

RunSync(() => Foo());
var result = RunSync(() => FooWithResult());

Answer 14

我多年来一直使用这种方法，它还处理和传播底层异步任务的异常。效果完美。

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

    return task.Result;
}

但自从微软创建了这个异步助手： https://github.com/aspnet/AspNetIdentity/blob/main/src/Microsoft.AspNet.Identity.Core/AsyncHelper.cs

这也是他们的来源：

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();
        }

Answer 15

现在，您可以使用源生成器通过 同步方法生成器 创建方法的同步版本库（nuget）。

按如下方式使用它：

[Zomp.SyncMethodGenerator.CreateSyncVersion]
public async Task FooAsync()

这将生成您可以同步调用的 Foo 方法。

Answer 16

每个人似乎都预设需要等待结果。
我经常需要从同步方法更新数据，而我并不关心结果。我只是使用丢弃：

_ = UpdateAsync();