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

Question

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

这甚至可能吗？

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

现在我正在研究从同步方法中调用这些异步方法。

score 945 · Accepted Answer

异步编程确实通过代码库“增长”。它被比作僵尸病毒。最好的解决方案是让它成长，但有时这是不可能的。

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

解决方案 A

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

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

您不想使用Task.Wait或Task.Result因为它们将异常包装在AggregateException.

此解决方案仅在MyAsyncMethod不同步回其上下文时才适用。换句话说，每个awaitinMyAsyncMethod都应该以ConfigureAwait(false). 这意味着它不能更新任何 UI 元素或访问 ASP.NET 请求上下文。

解决方案 B

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

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

*2014 年 4 月 14 日更新：在更新版本的库中，API 如下：

var result = AsyncContext.Run(MyAsyncMethod);

（Task.Result在这个例子中使用是可以的，因为RunTask会传播Task异常）。

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

同步方法调用异步方法，获取Task.
同步方法在Task.
该async方法使用await不带ConfigureAwait.
在这种Task情况下无法完成，因为它仅在async方法完成时完成；该async方法无法完成，因为它正在尝试将其继续调度到SynchronizationContext，并且 WinForms/WPF/SL/ASP.NET 将不允许继续运行，因为同步方法已经在该上下文中运行。

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

解决方案 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。

2019 年 5 月 1 日更新：当前的“最坏做法”在此处的 MSDN 文章中。

score 377 · Accepted Answer

添加一个最终解决我的问题的解决方案，希望能节省一些人的时间。

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

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

所以这是我的解决方法：将调用包装在 a 中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;
    }
}

score 260 · Accepted Answer

Microsoft 构建了一个 AsyncHelper（内部）类来将 Async 作为 Sync 运行。源代码如下：

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 基类只有 Async 方法，为了将它们称为 Sync，有一些类的扩展方法看起来像（示例用法）：

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

对于那些关心代码许可条款的人，这里有一个非常相似的代码的链接（只是在线程上添加了对文化的支持），其中有注释表明它是由微软授权的 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 的设置不阻止包装的任务。

这应该导致任何人问

这与调用 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 () => await AsyncMethod().ConfigureAwait(false)); 吗？这样我们告诉“内部”方法“请不要尝试同步到上层上下文并解除锁定”

真的很重要，因为大多数对象架构问题都取决于它。

作为一种扩展方法，您是想对每个调用都强制使用它，还是让使用该函数的程序员在他们自己的异步调用上配置它？我可以看到调用三个场景的用例；它很可能不是您在 WPF 中想要的东西，在大多数情况下当然是有道理的，但是考虑到 ASP.Net Core 中没有上下文，如果您可以保证它是 ASP.Net Core 的内部，那么这没关系.

score 231 · Accepted Answer

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

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

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


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

您会在很多 Microsoft 文档中看到这一点，例如： https ://docs.microsoft.com/en-us/azure/service-bus-messaging/service-bus-dotnet-how-to-use-主题订阅

score 65 · Accepted Answer

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 之后的代码类似于以前的 CallBack 方法。最大的区别是逻辑流程没有中断，这使得编写和阅读变得更加容易。

score 61 · Accepted Answer

我不是 100% 肯定，但我相信这个博客中描述的技术应该适用于许多情况：

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

score 28 · Accepted Answer

然而，有一个很好的解决方案（几乎：见评论）在每一种情况下都有效：即席消息泵（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(...));

有关异步泵的更详细说明，请参见此处。

score 21 · Accepted Answer

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

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

它在内部调用task.GetAwaiter().GetResult()这非常简单，但是它在任何async返回的方法上都超载Task，Task<T>或者Task<HttpResponseMessage>...语法糖，宝贝...爸爸爱吃甜食。

它看起来像是...GetAwaiter().GetResult()在阻塞上下文中执行异步代码的 MS 官方方式。对我的用例来说似乎工作得很好。

score 12 · Accepted Answer

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

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

或者使用这个：

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

score 11 · Accepted Answer

您可以从同步代码中调用任何异步方法，也就是说，直到您需要await它们，在这种情况下，它们也必须被标记为async。

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

如果您真的无法创建您的方法async并且您不想锁定同步方法，那么您将不得不使用回调方法，将其作为参数传递给ContinueWith()任务上的方法。

score 8 · Accepted Answer

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

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

请注意，原始问题中的签名public async void Foo()不正确。public async Task Foo()对于不返回值的异步方法，应该返回 Task not void （是的，有一些罕见的例外）。

score 5 · Accepted Answer

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

    void Synchronous Function()
    {
        Task.Run(Foo).Wait();
    }

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

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

score 2 · Accepted Answer

经过几个小时尝试不同的方法，或多或少的成功，这就是我的结局。它在获取结果时不会以死锁结束，它还会获取并抛出原始异常，而不是包装的异常。

private ReturnType RunSync()
{
  var task = Task.Run(async () => await myMethodAsync(agency));
  if (task.IsFaulted && task.Exception != null)
  {
    throw task.Exception;
  }

  return task.Result;
}

score -3 · Accepted Answer

这些 Windows 异步方法有一个漂亮的小方法，称为 AsTask()。您可以使用它让方法将自身作为任务返回，以便您可以手动调用 Wait() 。

例如，在 Windows Phone 8 Silverlight 应用程序上，您可以执行以下操作：

private void DeleteSynchronous(string path)
{
    StorageFolder localFolder = Windows.Storage.ApplicationData.Current.LocalFolder;
    Task t = localFolder.DeleteAsync(StorageDeleteOption.PermanentDelete).AsTask();
    t.Wait();
}

private void FunctionThatNeedsToBeSynchronous()
{
    // Do some work here
    // ....

    // Delete something in storage synchronously
    DeleteSynchronous("pathGoesHere");

    // Do other work here 
    // .....
}

希望这可以帮助！

score -5 · Accepted Answer

-5

如果你想运行它同步

MethodAsync().RunSynchronously()

于 2019-04-29T11:48:07.643 回答

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

15 回答 15

Related

Reference