Was ist in MVVM asynchron? Das Modell oder ViewModel. Beste Übung?

Question

Ich suche nach der besten Methode, um asynchron zwischen den Schichten zu kommunizieren. Ich verwende die mvvm light toolkit

zur Zeit ich einen Background imModell verwenden, da ich dies in dem automatisch generierten Code sah. Nicht mit dem Hintergrundarbeiter, sondern der Async-Aufruf.

public void GetConfig(Action<Config, Exception> callback) 
{ 
    BackgroundWorker backgroundWorker = new BackgroundWorker(); 
    backgroundWorker.DoWork += (backgroundWorkerSender, backgroundWorkerArgs) => 
    { 
     try 
     { 
      backgroundWorkerArgs.Result = AppEnvironment.Instance.Config; 
     } 
     catch (Exception exception) 
     { 
      backgroundWorkerArgs.Result = null; 
     } 
    }; 

    backgroundWorker.RunWorkerCompleted += (backgroundWorkerSender, backgroundWorkerArgs) => 
    { 
     if (backgroundWorkerArgs.Result != null) 
     { 
      callback((Config) backgroundWorkerArgs.Result, null); 
     } 
     else 
     { 
      /* ToDo: exceptionhandling */ 
     } 
    }; 

    backgroundWorker.RunWorkerAsync(); 
} 

Nun fand ich die AsyncDelegateCommand, die den asynchronen Teil im Ansichtsmodell implementiert.

private ICommand _refreshObjectDefinitionCommand; 
public ICommand RefreshObjectDefinitionCommand 
{ 
    get 
    { 
     return _refreshObjectDefinitionCommand 
      ?? (_refreshObjectDefinitionCommand = new AsyncDelegateCommand(delegate 
       { 
        IsBusy = true; 
        _dataService.GetObjectDefinition(
        (xmlObjectDef, errorConfig) => 
        { 
         if (errorConfig != null) 
         { 
          /* ToDo Lenz: exceptionhandling */ 
          return; 
         } 

         ObjectDefinition = xmlObjectDef; 
        }); 

        _dataService.GetObjectDefinitionTreeView(
         (treenodes, errorConfig) => 
         { 
          if (errorConfig != null) 
          { 
           /* ToDo Lenz: exceptionhandling */ 
           return; 
          } 

          TreeNodes = treenodes; 
         }); 
       }, 
           () => _isConnected, o => IsBusy = false, exception => IsBusy = false)); 
    } 
} 

Ich bin ein wenig verwirrt über die beste Praxis? Ich habe viele Artikel gelesen. Aber irgendwie sind sie immer unterschiedliche Meinungen. Gibt es irgendwelche Vorkehrungen, um die beste Kompatibilität bei normalem Aufwand zu erhalten?

Einige Denkanstösse

Modell:

http://csharperimage.jeremylikness.com/2009/12/simplifying-asynchronous-calls-in.html

http://www.dzone.com/articles/mvvmlight-and-async

Ansichtsmodell

http://www.codeproject.com/Articles/123183/Asynchronus-MVVM-Stop-the-Dreaded-Dead-GUI-Problem

http://www.codeproject.com/Articles/441752/Async-MVVM-Modern-UI

Answer 1

Nun, würde ich das fecthing des Modells sagen und async es in Ansicht Modell ist zu verwandeln. Wer dies tut, hängt von der Architektur ab, es kann auf dem Ansichtsmodell selbst ausgeführt werden oder es kann Controller-Ebene für solche Synchronisierungsladevorgänge und die Zuordnung der initialisierten VM zum Anzeigen verwenden. Auch die Hintergrundarbeiter sind die Vergangenheit, die Sie Task-Klasse für parallele Operationen verwenden sollten. Vergessen Sie natürlich nicht, den Dispatcher aufzurufen, wenn Sie die Ansicht über Änderungen von der VM mitteilen.

Codebeispiel:

Task<string>.Factory.StartNew(() => 
{ 
    string text = GetArticleText(); 
    Application.Current.Dispatcher.BeginInvoke(new Action(()=>MyTextProperty = text)); 
}); 

Answer 2

Ich würde vorschlagen, den asynchronen Code in Ihrem Ansichtsmodell setzen und lassen Sie Ihr Modell die Daten zu speichern. Als ich mit MVVM angefangen habe, war eines der ersten Dinge, die ich gelernt habe, Logik aus meinen Modellen zu entfernen und stattdessen in meinen ViewModels zu behalten. Obwohl ich sagen würde, dass, wo Sie Ihren Code setzen, keine Rolle spielt, solange alle Leute, die den Code lesen, ihn verstehen können.