Przypisywanie wyniku asynchronicznego do właściwości powiązania danych

Question

Poniżej znajduje się przykładowa implementacja, która korzysta z interfejsu API Metro i powiązania danych (przy użyciu MVVM) w celu zapełnienia listy folderów z rozwijanej listy.

Konstruktor modelu View korzysta z metody SetFolders (asynchroniczny prywatny), która wywołuje godną zaufania metodę fileService.GetFoldersAsync() w celu pobrania listy folderów. Lista folderów zostanie następnie przypisana do właściwości o nazwie "FoldersList". XAML używa tej właściwości do wypełnienia listy rozwijanej przy użyciu powiązania danych.

Zastanawiam się, czy istnieje lepszy sposób ustawiania właściwości FoldersList bez konieczności ustawiania go w konstruktorze, jak poniżej. Wolałbym wywołać metodę GetFilesAsync i ustawić wartość właściwości FilesList, gdy nastąpi faktyczne powiązanie danych (nie podczas init klasy). Ponieważ właściwości nie obsługują modyfikatorów async/await (o ile mi wiadomo) staram się zaimplementować właściwe rozwiązanie. Wszelkie pomysły bardzo doceniane.

Kod znajduje się poniżej.

ViewModel

public class FileViewModel : INotifyPropertyChanged 
{ 
    public event PropertyChangedEventHandler PropertyChanged; 
    private readonly IFileService fileService; 

    public FileDataViewModel(IFileService fileService) 
    { 
     this.fileService = fileService; 
     SetFolders(); 
    } 

    private async void SetFolders() 
    { 
     FoldersList = await fileService.GetFoldersAsync(); 
    } 

    private IEnumerable<IStorageFolder> foldersList; 
    public IEnumerable<StorageFolder> FoldersList 
    { 
     get { return foldersList; } 
     private set 
     { 
      foldersList = value; 
      if (PropertyChanged != null) 
      { 
       PropertyChanged(this, new PropertyChangedEventArgs("FoldersList")); 
      } 
     } 
    } 
} 

IFileService i realizacja

public interface IFileService { 
    Task<IEnumerable<IStorageFolder>> GetFilesAsync(); 
    } 

public class FileService : IFileService 
{ 
    public async Task<IEnumerable<IStorageFolder>> GetFoldersAsync() 
    { 
     var folder = KnownFolders.DocumentsLibrary; 
     return await folder.GetFoldersAsync(); 
    } 
} 

Answer 1

chciałbym wdrożyć go jako właściwość leniwy i używać ObservableCollection<T> zamiast IEnumerable<T>. Robimy to w kilku projektach i działa dobrze. W ten sposób możesz zagwarantować, że ładujesz dane tylko w razie potrzeby. Ponadto, jeśli chcesz go wstępnie pobrać, zawsze możesz wywołać metodę load w konstruktorze lub w innym miejscu.

Na marginesie, ja osobiście nie ujawniłbym IStorageFolder bezpośrednio z moich ViewModels.

private async Task LoadData() 
{ 
    if(!IsLoading) 
    { 
    IsLoading = true; 
    Folders = new ObservableCollection<Folder>(await fileService.GetFolderAsync()); 

    } 
    IsLoading = false; 
} 

private ObservableCollection<Folder> _folders; 

public ObservableCollection<Folder> Folders 
{ 
    get 
    { 
    if(_folders == null) 
    { 
     LoadData();//Don't await... 
    } 
    return _folders; 

    } 
    private set 
    { 
    SetProperty(ref _folders,value); 
    } 

} 
private bool _isLoading; 
public bool IsLoading 
{ 
    get 
    { 
    return _isLoading; 
    } 
    private set 
    { 
    SetProperty(ref _isLoading,value); 
    } 
} 

Pamiętaj, że możesz użyć właściwości IsLoading, aby wyświetlić na przykład pierścień postępu. po tym, jak załadowana zostanie obserwowalna kolekcja, będziesz mógł ją odświeżyć, nie odtwarzając jej. (_folders.Add, _folders.Remove, _folders.Clear ...)