构造函数可以异步吗？

Question

我有一个项目，我试图在构造函数中填充一些数据：

public class ViewModel
{
    public ObservableCollection<TData> Data { get; set; }

    async public ViewModel()
    {
        Data = await GetDataTask();
    }

    public Task<ObservableCollection<TData>> GetDataTask()
    {
        Task<ObservableCollection<TData>> task;

        //Create a task which represents getting the data
        return task;
    }
}

很遗憾，我遇到了一个错误：

修饰符async对该项目无效

当然，如果我封装一个标准方法并从构造函数中调用它：

public async void Foo()
{
    Data = await GetDataTask();
}

它工作正常。同样，如果我使用旧的由内而外的方式

GetData().ContinueWith(t => Data = t.Result);

这也有效。我只是想知道为什么我们不能直接从构造函数中调用await。可能有很多（甚至是明显的）边缘案例和反对它的原因，我只是想不出。我也四处寻找解释，但似乎找不到任何解释。

Answer 1

由于无法创建异步构造函数，我使用静态异步方法返回由私有构造函数创建的类实例。这并不优雅，但可以正常工作。

public class ViewModel       
{       
    public ObservableCollection<TData> Data { get; set; }       

    //static async method that behave like a constructor       
    async public static Task<ViewModel> BuildViewModelAsync()  
    {       
        ObservableCollection<TData> tmpData = await GetDataTask();  
        return new ViewModel(tmpData);
    }       

    // private constructor called by the async method
    private ViewModel(ObservableCollection<TData> Data)
    {
        this.Data = Data;   
    }
}  

Answer 2

构造函数的行为与返回构造类型的方法非常相似。而async 方法不能只返回任何类型，它必须是“一劳永逸”void 或Task。

如果T 类型的构造函数实际上返回了Task<T>，我想那会很混乱。

如果异步构造函数的行为方式与async void 方法相同，那么就会破坏构造函数的本意。构造函数返回后，你应该得到一个完全初始化的对象。不是将来会在某个未定义的点实际正确初始化的对象。也就是说，如果你很幸运并且异步初始化没有失败。

这一切都只是猜测。但在我看来，拥有异步构造函数的可能性带来的麻烦多于其价值。

如果您真的想要 async void 方法的“即发即弃”语义（如果可能，应该避免这种情况），您可以轻松地将所有代码封装在 async void 方法中并从您的构造函数中调用它，如你在问题中提到。

Answer 3

您的问题类似于创建文件对象并打开文件。事实上，在很多类中，您必须执行两个步骤才能真正使用该对象：创建 + 初始化（通常称为类似于 Open）。

这样做的好处是构造函数可以是轻量级的。如果需要，您可以在实际初始化对象之前更改一些属性。当所有属性都设置好后，调用Initialize/Open函数来准备要使用的对象。这个Initialize 函数可以是异步的。

缺点是你必须相信你班级的用户在他使用你班级的任何其他功能之前会调用Initialize()。事实上，如果你想让你的类完全证明（傻瓜证明？），你必须检查每个调用 Initialize() 的函数。

使这更容易的模式是将构造函数声明为私有并创建一个公共静态函数，该函数将构造对象并在返回构造对象之前调用Initialize()。这样您就知道有权访问该对象的每个人都使用了Initialize 函数。

这个例子展示了一个模仿你想要的异步构造函数的类

public MyClass
{
    public static async Task<MyClass> CreateAsync(...)
    {
        MyClass x = new MyClass();
        await x.InitializeAsync(...)
        return x;
    }

    // make sure no one but the Create function can call the constructor:
    private MyClass(){}

    private async Task InitializeAsync(...)
    {
        // do the async things you wanted to do in your async constructor
    }

    public async Task<int> OtherFunctionAsync(int a, int b)
    {
        return await ... // return something useful
    }

用法如下：

public async Task<int> SomethingAsync()
{
    // Create and initialize a MyClass object
    MyClass myObject = await MyClass.CreateAsync(...);

    // use the created object:
    return await myObject.OtherFunctionAsync(4, 7);
}

Answer 4

在这种特殊情况下，需要一个 viewModel 来启动任务并在完成后通知视图。 “异步属性”，而不是“异步构造函数”，是有序的。

我刚刚发布了AsyncMVVM，它正好解决了这个问题（以及其他问题）。如果你使用它，你的 ViewModel 会变成：

public class ViewModel : AsyncBindableBase
{
    public ObservableCollection<TData> Data
    {
        get { return Property.Get(GetDataAsync); }
    }

    private Task<ObservableCollection<TData>> GetDataAsync()
    {
        //Get the data asynchronously
    }
}

奇怪的是，Silverlight 是受支持的。 :)

Answer 5

如果你让构造函数异步，在创建一个对象之后，你可能会陷入空值而不是实例对象的问题。比如；

MyClass instance = new MyClass();
instance.Foo(); // null exception here

这就是我猜他们不允许这样做的原因。

Answer 6

我只是想知道为什么我们不能直接从构造函数中调用await。

我相信简短的回答很简单：因为 .Net 团队尚未编写此功能。

我相信通过正确的语法可以实现这一点，并且不应该太混乱或容易出错。我认为 Stephen Cleary 的blog post 和这里的其他几个答案已经含蓄地指出，没有根本的理由反对它，而且更重要的是 - 通过变通方法解决了这种缺乏。这些相对简单的解决方法的存在可能是该功能尚未（尚未）实现的原因之一。

Answer 7

在构造函数中调用异步可能会导致死锁，请参考 http://social.msdn.microsoft.com/Forums/en/winappswithcsharp/thread/0d24419e-36ad-4157-abb5-3d9e6c5dacf1

http://blogs.msdn.com/b/pfxteam/archive/2011/01/13/10115163.aspx

Answer 8

一些答案​​涉及创建一个新的public 方法。不这样做，使用Lazy<T> 类：

public class ViewModel
{
    private Lazy<ObservableCollection<TData>> Data;

    async public ViewModel()
    {
        Data = new Lazy<ObservableCollection<TData>>(GetDataTask);
    }

    public ObservableCollection<TData> GetDataTask()
    {
        Task<ObservableCollection<TData>> task;

        //Create a task which represents getting the data
        return task.GetAwaiter().GetResult();
    }
}

要使用Data，请使用Data.Value。

Answer 9

你可以在构造函数中使用 Action

 public class ViewModel
    {
        public ObservableCollection<TData> Data { get; set; }
       public ViewModel()
        {              
            new Action(async () =>
            {
                  Data = await GetDataTask();
            }).Invoke();
        }

        public Task<ObservableCollection<TData>> GetDataTask()
        {
            Task<ObservableCollection<TData>> task;
            //Create a task which represents getting the data
            return task;
        }
    }

Answer 10

我会使用这样的东西。

 public class MyViewModel
    {
            public MyDataTable Data { get; set; }
            public MyViewModel()
               {
                   loadData(() => GetData());
               }
               private async void loadData(Func<DataTable> load)
               {
                  try
                  {
                      MyDataTable = await Task.Run(load);
                  }
                  catch (Exception ex)
                  {
                       //log
                  }
               }
               private DataTable GetData()
               {
                    DataTable data;
                    // get data and return
                    return data;
               }
    }

这是我可以为构造函数得到的最接近的结果。

Answer 11

我使用这个简单的技巧。

public sealed partial class NamePage
{
  private readonly Task _initializingTask;

  public NamePage()
  {
    _initializingTask = Init();
  }

  private async Task Init()
  {
    /*
    Initialization that you need with await/async stuff allowed
    */
  }
}

Answer 12

我不熟悉 async 关键字（这是 Silverlight 特有的还是 Visual Studio 测试版中的新功能？），但我想我可以告诉您为什么不能这样做。

如果我这样做：

var o = new MyObject();
MessageBox(o.SomeProperty.ToString());

o 在下一行代码运行之前可能没有完成初始化。在构造函数完成之前无法分配对象的实例化，并且使构造函数异步不会改变这一点，那么重点是什么？但是，您可以从构造函数调用异步方法，然后您的构造函数可以完成，您将获得实例化，同时异步方法仍在执行设置对象所需的任何操作。