ConfigureAwait(false) 导致错误而不是死锁的情况

Question

假设我编写了一个依赖于async 方法的库：

namespace MyLibrary1
{
    public class ClassFromMyLibrary1
    {
        public async Task<string> MethodFromMyLibrary1(string key, Func<string, Task<string>> actionToProcessNewValue)
        {
            var remoteValue = await GetValueByKey(key).ConfigureAwait(false);

            //do some transformations of the value
            var newValue = string.Format("Remote-{0}", remoteValue);

            var processedValue = await actionToProcessNewValue(newValue).ConfigureAwait(false);

            return string.Format("Processed-{0}", processedValue);
        }

        private async Task<string> GetValueByKey(string key)
        {
            //simulate time-consuming operation
            await Task.Delay(500).ConfigureAwait(false);

            return string.Format("ValueFromRemoteLocationBy{0}", key);
        }
    }
}

我遵循了在我的图书馆中各处使用ConfigureAwait(false)（如this 帖子）的建议。然后我从我的测试应用中以 同步 方式使用它并失败：

namespace WpfApplication1
{
    /// <summary>
    /// Interaction logic for MainWindow.xaml
    /// </summary>
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }

        private void Button1_OnClick(object sender, RoutedEventArgs e)
        {
            try
            {
                var c = new ClassFromMyLibrary1();

                var v1 = c.MethodFromMyLibrary1("test1", ActionToProcessNewValue).Result;

                Label2.Content = v1;
            }
            catch (Exception ex)
            {
                System.Diagnostics.Trace.TraceError("{0}", ex);
                throw;
            }
        }

        private Task<string> ActionToProcessNewValue(string s)
        {
            Label1.Content = s;
            return Task.FromResult(string.Format("test2{0}", s));
        }
    }
}

失败是：

WpfApplication1.vshost.exe 错误：0： System.InvalidOperationException：调用线程无法访问 这个对象，因为不同的线程拥有它。在 System.Windows.Threading.Dispatcher.VerifyAccess() 在 System.Windows.DependencyObject.SetValue（DependencyProperty dp，对象 值）在 System.Windows.Controls.ContentControl.set_Content（对象 值）在 WpfApplication1.MainWindow.ActionToProcessNewValue（字符串 s) 在 C:\dev\tests\4\WpfApplication1\WpfApplication1\MainWindow.xaml.cs:line 56 在 MyLibrary1.ClassFromMyLibrary1.d__0.MoveNext() 在 C:\dev\tests\4\WpfApplication1\WpfApplication1\MainWindow.xaml.cs:line 77 --- 从先前抛出异常的位置结束堆栈跟踪 --- 在 System.Runtime.CompilerServices.TaskAwaiter.ThrowForNonSuccess（任务 任务）在 System.Runtime.CompilerServices.TaskAwaiter.HandleNonSuccessAndDebuggerNotification（任务 任务）在 System.Runtime.CompilerServices.TaskAwaiter`1.GetResult() 在 WpfApplication1.MainWindow.d__1.MoveNext() 中 C:\dev\tests\4\WpfApplication1\WpfApplication1\MainWindow.xaml.cs:line 39 抛出异常：“System.InvalidOperationException”在 WpfApplication1.exe

很明显，错误发生是因为我的库中的等待者丢弃了当前的 WPF 上下文。

另一方面，在库中的所有位置删除 ConfigureAwait(false) 后，我显然会陷入死锁。

There is more detailed example of code 解释了我必须处理的一些限制。

那么我该如何解决这个问题呢？这里最好的方法是什么？我还需要遵循有关ConfigureAwait 的最佳做法吗？

PS，在实际场景中，我有很多类和方法，因此我的库中有大量此类异步调用。几乎不可能找出某个特定的异步调用是否需要上下文（参见 cmets 对 @Alisson 的响应）来修复它。不过，至少在这一点上，我并不关心性能。我正在寻找一些通用的方法来解决这个问题。

Answer 1

通常一个库会记录回调是否保证在调用它的同一线程上，如果没有记录，最安全的选择是假设它没有。您的代码示例（以及我从您的 cmets 得知的与您合作的第 3 方）属于“不保证”类别。在这种情况下，您只需要检查是否需要从回调方法内部执行Invoke 并执行此操作，您可以调用Dispatcher.CheckAccess()，如果您需要在使用控件之前调用，它将返回false。

private async Task<string> ActionToProcessNewValue(string s)
{
    //I like to put the work in a delegate so you don't need to type 
    // the same code for both if checks
    Action work = () => Label1.Content = s;
    if(Label1.Dispatcher.CheckAccess())
    {
        work();
    }
    else
    {
        var operation = Label1.Dispatcher.InvokeAsync(work, DispatcherPriority.Send);

        //We likely don't need .ConfigureAwait(false) because we just proved
        // we are not on the UI thread in the if check.
        await operation.Task.ConfigureAwait(false);
    }

    return string.Format("test2{0}", s);
}

这是一个使用同步回调而不是异步回调的替代版本。

private string ActionToProcessNewValue(string s)
{
    Action work = () => Label1.Content = s;
    if(Label1.Dispatcher.CheckAccess())
    {
        work();
    }
    else
    {
        Label1.Dispatcher.Invoke(work, DispatcherPriority.Send);
    }

    return string.Format("test2{0}", s);
}

如果你想从 Label1.Content 获取值而不是分配它，这里是另一个版本，这也不需要在回调中使用 async/await。

private Task<string> ActionToProcessNewValue(string s)
{
    Func<string> work = () => Label1.Content.ToString();
    if(Label1.Dispatcher.CheckAccess())
    {
        return Task.FromResult(work());
    }
    else
    {
        return Label1.Dispatcher.InvokeAsync(work, DispatcherPriority.Send).Task;
    }
}

重要提示：如果您不删除按钮单击处理程序中的.Result、Dispatcher.Invoke 或Dispatcher.InvokeAsync，所有这些方法都会导致您的程序死锁回调函数在等待.Result 返回时永远不会启动，.Result 在等待回调函数返回时永远不会返回。您必须将点击处理程序更改为 async void 并执行 await 而不是 .Result。

Answer 2

实际上，您在ClassFromMyLibrary1 中收到了回调，您无法假设它会做什么（例如更新标签）。你的类库中不需要ConfigureAwait(false)，因为你提供的同一个链接给了我们这样的解释：

随着异步 GUI 应用程序变得越来越大，您可能会发现很多 一小部分异步方法都使用 GUI 线程作为它们的 语境。这可能会导致反应迟缓，因为响应能力会受到影响 “成千上万的剪纸”。

要缓解这种情况，请尽可能等待 ConfigureAwait 的结果。

通过使用 ConfigureAwait，您可以启用少量并行性： 一些异步代码可以与 GUI 线程并行运行 不断纠缠于它的一些工作要做。

现在在这里阅读：

当你在等待之后有代码时，你不应该使用 ConfigureAwait 在需要上下文的方法中。对于 GUI 应用程序，这包括任何 操作 GUI 元素、编写数据绑定属性或 取决于特定于 GUI 的类型，例如 Dispatcher/CoreDispatcher。

你做的恰恰相反。您正在尝试在两点更新 GUI，一个在您的回调方法中，另一个在此处：

var c = new ClassFromMyLibrary1();

var v1 = c.MethodFromMyLibrary1("test1", ActionToProcessNewValue).Result;

Label2.Content = v1; // updating GUI...

这就是为什么删除 ConfigureAwait(false) 可以解决您的问题。此外，您可以使您的按钮单击处理程序异步并等待您的 ClassFromMyLibrary1 方法调用。

Answer 3

在我看来，您应该重新设计您的库 API，以免将基于回调的 API 与基于任务的 API 混为一谈。至少在您的示例代码中，没有令人信服的理由可以这样做，并且您已经找到了不这样做的一个原因 - 很难控制回调运行的上下文。

我会将您的库 API 更改为：

namespace MyLibrary1
{
    public class ClassFromMyLibrary1
    {
        public async Task<string> MethodFromMyLibrary1(string key)
        {
            var remoteValue = await GetValueByKey(key).ConfigureAwait(false);
            return remoteValue;
        }

        public string TransformProcessedValue(string processedValue)
        {
            return string.Format("Processed-{0}", processedValue);
        }

        private async Task<string> GetValueByKey(string key)
        {
            //simulate time-consuming operation
            await Task.Delay(500).ConfigureAwait(false);

            return string.Format("ValueFromRemoteLocationBy{0}", key);
        }
    }
}

然后这样称呼它：

   private async void Button1_OnClick(object sender, RoutedEventArgs e)
    {
        try
        {
            var c = new ClassFromMyLibrary1();

            var v1 = await c.MethodFromMyLibrary1("test1");
            var v2 = await ActionToProcessNewValue(v1);
            var v3 = c.TransformProcessedValue(v2);

            Label2.Content = v3;
        }
        catch (Exception ex)
        {
            System.Diagnostics.Trace.TraceError("{0}", ex);
            throw;
        }
    }

    private Task<string> ActionToProcessNewValue(string s)
    {
        Label1.Content = s;
        return Task.FromResult(string.Format("test2{0}", s));
    }