WinRT ViewModel DataBind to async method

Question

I am deserializing a list of objects from an XML file, and would like to bind to the actual content of those objects in my View, passing over a ViewModel. The problem is that file operations are async and this bubbles all the way up to the ViewModel, where Property getters cannot be marked as such...

Problem

• I deserialize all XML files in a folder to Profile objects and store them in a List<Profile>. This method (has to be) marked async.

      public static async Task<List<Profile>> GetAllProfiles()
      {
          DataContractSerializer ser = new DataContractSerializer(typeof(Profile));
          StorageFolder folder = await ApplicationData.Current.RoamingFolder.CreateFolderAsync("Profiles", CreationCollisionOption.OpenIfExists);
  
          List<Profile> profiles = new List<Profile>();
          foreach (var f in await folder.GetFilesAsync())
          {
              var fs = await f.OpenStreamForReadAsync();
              profiles.Add((Profile)ser.ReadObject(fs));
             fs.Dispose();
          }
  
          return profiles;
      }
  

Ideal solution 1

• The binding property in my ViewModel would then ideally call that static method like this

  public async Task<ObservableCollection<string>> Lists
  {
      get 
      {
          return new ObservableCollection<string>(GetAllProfiles().Select(p => p.Name));
      }
  }
  

• BUT Properties cannot be marked async

Ideal solution 2

    public ObservableCollection<string> Lists
    {
        get 
        {
            return new ObservableCollection<string>((GetAllProfiles().Result).Select(p => p.Name));
        }
    }

• BUT this never executes (it blocks in the await folder.GetFilesAsync() call for some reason)

Current solution

Calls an async Initialize() method that loads the result of the GetProfiles() function in a variable, and then makes a NotifyPropertyChanged("Lists") call:

    public ViewModel()
    {
        Initialize();
    }

    public async void Initialize()
    {
        _profiles = await Profile.GetAllProfiles();
        NotifyPropertyChanged("Lists");
    }

    private List<Profile> _profiles;
    public ObservableCollection<string> Lists
    {
        get
        {
            if (_profiles != null)
                return new ObservableCollection<string>(_profiles.Select(p => p.Name));
            else
                return null;
        }
    }

Question

Is there a better way? Is there a pattern/method that I haven't yet discovered?

Edit

The root of the problem appears when doing non-UI code, and you cannot rely on the NotifyPropertyChanged to do some thread-synchronization stuff. -- The method Initialize has to be awaited and ctors cannot be async, so essentialy this is pattern is useless.

    public MyClass()
    {
        Initialize();
    }

    public async void Initialize()
    {
        _profiles = await Profile.GetAllProfiles();
    }

    private ObservableCollection<Profile> _profiles;
    public ObservableCollection<string> Lists
    {
        get
        {
            return _profiles; // this will always be null
        }
    }

Answer 1

Properties can't be async so this solution will not work as you mentioned. Task.Result waits for the task to complete, but this is blocking your UI thread where the I/O operation's async callback returns, so you are deadlocking your application, since the callback is never called. Your solution really is the best way. It could be improved though.

• You should make the _profiles field an ObservableCollection, so you would not need to convert the List to the OC every time the list is accessed.
• Since you are performing an I/O operation that can take arbitrary amount of time - you should enable some sort of a progress indicator while it is in progress.
• In some cases you might want the Lists property to be lazier and only call the Init method the first time it is accessed.