如何异步初始化静态类

Question

我有一个 Singleton（好吧，它可以是一个静态类，没关系），它是我的 WPF 应用程序的一些数据的外观。我想通过 WCF 异步加载这些数据。这是我的实现：

public class Storage
{
    private static readonly Lazy<Storage> _lazyInstance = new Lazy<Storage>(()=>new Storage());

    public static Storage Instance
    {
        get { return _lazyInstance.Value; }
    }

    private Storage()
    {
        Data = new Datastorage(SettingsHelper.LocalDbConnectionString);
        InitialLoad().Wait();
    }

    public Datastorage Data { get; private set; }

    private async Task InitialLoad()
    {
        var tasks = new List<Task>
        {
            InfoServiceWrapper.GetSomeData()
            .ContinueWith(task => Data.StoreItem(task.Result)),
            InfoServiceWrapper.GetAnotherData()
            .ContinueWith(task => Data.StoreItem(task.Result)),
            InfoServiceWrapper.GetSomeMoreData()
            .ContinueWith(task => Data.StoreItem(task.Result)),
        };
        await Task.WhenAll(tasks.ToArray());
    }
}

我像这样从我的 ViewModel 访问这个类：

public class MainWindowViewModel:ViewModelBase
{
    public  SensorDTO RootSensor { get; set; }
    public  MainWindowViewModel()
    {
        var data = Storage.Instance.Data.GetItem<SensorDTO>(t=>t.Parent==t);
        RootSensor = data;
    }
}

在我看来，我有一个 RootSensor 的绑定。一切都很好，但我有一个问题：我所有的异步代码都执行了，然后我在 InitialLoad().Wait(); 上遇到了死锁。我知道它以某种方式涉及 WPF UI 线程，但不明白如何解决这个问题。

如有任何帮助，我将不胜感激！

Answer 1

解决方案 1 - 如果您根本不等待怎么办？

如果您在构造函数中等待某个任务，那么您的应用在获取数据之前不会启动。因此应用程序的启动时间增加了，用户体验会不太令人满意。

但是，如果您只是设置一些虚拟默认数据并完全异步启动数据检索，无需等待或等待，您将无需Wait 并改善整体用户体验。为了防止用户进行任何不必要的操作，您可以禁用相关控件或使用Null object pattern：

public class Waiter : INotifyPropertyChanged
{
    public async Task<String> Get1()
    {
        await Task.Delay(2000);            
        return "Got value 1";
    }

    public async Task<String> Get2()
    {
        await Task.Delay(3000);
        return "Got value 2";
    }

    private void FailFast(Task task)
    {
        MessageBox.Show(task.Exception.Message);
        Environment.FailFast("Unexpected failure");
    }

    public async Task InitialLoad()
    {          
        this.Value = "Loading started";

        var task1 = Get1();
        var task2 = Get2();

        // You can also add ContinueWith OnFaulted for task1 and task2 if you do not use the Result property or check for Exception
        var tasks = new Task[]
        {
            task1.ContinueWith(
                (prev) => 
                    this.Value1 = prev.Result),
            task2.ContinueWith(
                (prev) => 
                    this.Value2 = prev.Result)
        };

        await Task.WhenAll(tasks);

        this.Value = "Loaded";
    }

    public Waiter()
    {
        InitialLoad().ContinueWith(FailFast, TaskContinuationOptions.OnlyOnFaulted);
    }

    private String _Value,
        _Value1,
        _Value2;

    public String Value
    {
        get
        {
            return this._Value;
        }
        set
        {
            if (value == this._Value)
                return;
            this._Value = value;
            this.OnPropertyChanged();
        }
    }


    public String Value1
    {
        get { return this._Value1; }
        set
        {
            if (value == this._Value1)
                return;
            this._Value1 = value;
            this.OnPropertyChanged();
        }
    }


    public String Value2
    {
        get { return this._Value2; }
        set
        {
            if (value == this._Value2)
                return;
            this._Value2 = value;
            this.OnPropertyChanged();
        }
    }

    public void OnPropertyChanged([CallerMemberName]String propertyName = null)
    {
        var propChanged = this.PropertyChanged;

        if (propChanged == null)
            return;

        propChanged(this, new PropertyChangedEventArgs(propertyName));
    }

    public event PropertyChangedEventHandler PropertyChanged;
}

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();

        this.DataContext = new Waiter();          
    }
}

XAML：

    <StackPanel>
        <TextBox Text="{Binding Value}"/>
        <TextBox Text="{Binding Value1}"/>
        <TextBox Text="{Binding Value2}"/>
    </StackPanel>

重要警告：正如@YuvalItzchakov 所指出的，最初发布的解决方案会默默地错过异步方法中可能发生的任何异常，因此您必须尝试包装您的异步方法主体-catch 逻辑调用Environment.FailFast 快速而响亮地失败或使用适当的ContinueWith 和TaskContinuationOptions.OnlyOnFaulted。

错误的解决方案 2（！实际上可能会失败！） - ConfigureAwait(false)

所有异步调用上的Configure await false 将阻止（在大多数情况下）任何使用原始同步上下文的操作，让您等待：

   public async Task<String> Get1()
    {
        await Task.Delay(2000).ConfigureAwait(false);            
        return "Got value 1";
    }

    public async Task<String> Get2()
    {
        await Task.Delay(3000).ConfigureAwait(false);
        return "Got value 2";
    }

    public async Task InitialLoad()
    {          
        this.Value = "Loading started";

        var tasks = new Task[]
        {
            Get1().ContinueWith(
                (prev) => 
                    this.Value1 = prev.Result),
            Get2().ContinueWith(
                (prev) => 
                    this.Value2 = prev.Result)
        };

        await Task.WhenAll(tasks).ConfigureAwait(false);

        this.Value = "Loaded";
    }

    public Waiter()
    {
        InitialLoad().Wait();
    }

它在大多数情况下都可以工作，但实际上并不能保证它不会使用相同的线程来等待导致相同的死锁问题。

错误的解决方案 3 - 使用 Task.Run 确保避免任何死锁。

您可以使用一种不太好的异步做法，并使用 Task.Run 将整个操作包装到新的线程池任务中：

private void SyncInitialize()
{
    Task.Run(() => 
                 InitialLoad().Wait())
        .Wait();
}

它会在等待时从线程池中浪​​费一个线程，但它肯定会工作，而解决方案 2 可能会失败。

Answer 2

您基本上遇到了 async/await 的限制：构造函数不能被标记为异步。解决这个问题的正确方法不是从构造函数中调用Wait。那是作弊——它会阻塞，使你所有的异步都变得毫无意义，更糟糕的是它会在你发现时引发死锁。

正确的做法是重构您的Storage 类，以确保其所有异步工作都通过异步方法而不是构造函数完成。我建议通过用 GetInstanceAsync() 方法替换您的 Instance 属性来做到这一点。由于这是获取单例实例的唯一公共接口，因此您将确保始终调用 InitialLoad（我将其重命名为 InitialLoadAsync）。

public class Storage
{
    private static Storage _instance;

    public static async Task<Storage> GetInstanceAsync()
    {
        if (_instance == null)
        {
            // warning: see comments about possible thread conflict here
            _instance = new Storage();
            await _instance.InitialLoadAsync();
        }
        return _instance;
    }

    private Storage() 
    {
        Data = new Datastorage(SettingsHelper.LocalDbConnectionString);
    }

    // etc

 }

现在，如何在不阻塞的情况下从MainWindowViewModel 的构造函数调用Storage.GetInstanceAsync()？正如您可能已经猜到的那样，您不能，因此您需要类似地重构它。比如：

public class MainWindowViewModel : ViewModelBase
{
    public  SensorDTO RootSensor { get; set; }

    public async Task InitializeAsync()
    {
        var storage = await Storage.GetInstanceAsync()
        RootSensor.Data.GetItem<SensorDTO>(t=>t.Parent==t);
    }
}

当然，任何调用await MainWindowViewModel.InitializeAsync() 都需要标记为async。据说 async/await 会像僵尸病毒一样通过您的代码传播，这是很自然的。如果您在调用堆栈中的任何地方使用.Wait() 或.Result 打破了该循环，那么您已经招来了麻烦。