您的问题类似于创建文件对象并打开文件。事实上，有很多类在实际使用对象之前必须执行两个步骤:create + Initialize(通常称为类似于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);
}

由于不可能创建异步构造函数，所以我使用一个静态异步方法，该方法返回一个由私有构造函数创建的类实例。这不是很优雅，但它可以工作。

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

你可以在构造函数中使用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;
        }
    }

其中一些答案涉及创造一种新的公共方法。不这样做，使用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。

如果你让构造函数是异步的，在创建对象之后，你可能会遇到像空值而不是实例对象这样的问题。例如;

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

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

在构造函数中调用async可能会导致死锁，请参考 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