MVVM: liaison au Model tout en gardant le Model synchronisé avec une version de serveur

je suggère d'ajouter des contrôleurs au mix MVVM (MVCVM? pour simplifier le schéma de mise à jour.

le contrôleur écoute les changements à un niveau supérieur et propage les changements entre le Modèle et le modèle de vue.

les règles de base pour garder les choses propres sont:

• les Modèles de vue sont des conteneurs muets qui contiennent une certaine forme de données. ils ne savent pas d'où viennent les données ni où elles se trouvent. afficher.
Les vues
• affichent une certaine forme de données (via des fixations à un modèle de vue). ils ne savent pas d'où viennent les données, seulement comment les afficher.
Les modèles
• fournissent des données réelles. Ils ne savent pas où il est consommé.
Les contrôleurs
• implémentent la logique. Des choses comme fournir le code pour ICommands dans VMs, écouter les changements de données, etc. Ils peuplent VMs à partir de Modèles. Il est logique qu'ils écoutent les changements de VM et mettent à jour le modèle.

comme mentionné dans une autre réponse votre DataContext devrait être la VM (ou la propriété de celle-ci), pas le modèle. Pointer sur un DataModel rend difficile la séparation des préoccupations (par exemple pour un développement piloté par des tests).

la plupart des autres solutions mettent de la logique dans les Modèles de vue ce qui n'est" pas juste", mais je vois les avantages des contrôleurs négligés tout le temps. Darn cet acronyme MVVM! :)

modèle de liaison pour voir directement ne fonctionne que si le modèle implémente INotifyPropertyChanged interface. (eg. votre modèle généré par Entity Framework)

modèle implémenter INotifyPropertyChanged

vous pouvez le faire.

public interface IModel : INotifyPropertyChanged //just sample model
{
    public string Title { get; set; }
}

public class ViewModel : NotificationObject //prism's ViewModel
{
    private IModel model;

    //construct
    public ViewModel(IModel model)
    {
        this.model = model;
        this.model.PropertyChanged += new PropertyChangedEventHandler(model_PropertyChanged);
    }

    private void model_PropertyChanged(object sender, PropertyChangedEventArgs e)
    {
        if (e.PropertyName == "Title")
        {
            //Do something if model has changed by external service.
            RaisePropertyChanged(e.PropertyName);
        }
    }
    //....more properties
}

ViewModel as DTO

si Model implémente INotifyPropertyChanged(cela dépend) Vous pouvez l'utiliser comme Data-texte dans la plupart des cas. mais en DDD, la plupart des modèles MVVM seront considéré comme EntityObject pas un vrai modèle de domaine.

le moyen le plus efficace est d'utiliser ViewModel comme DTO

//Option 1.ViewModel act as DTO / expose some Model's property and responsible for UI logic.
public string Title
{
    get 
    {
        // some getter logic
        return string.Format("{0}", this.model.Title); 
    }
    set
    {
        // if(Validate(value)) add some setter logic
        this.model.Title = value;
        RaisePropertyChanged(() => Title);
    }
}

//Option 2.expose the Model (have self validation and implement INotifyPropertyChanged).
public IModel Model
{
    get { return this.model; }
    set
    {
        this.model = value;
        RaisePropertyChanged(() => Model);
    }
}

les deux propriétés de ViewModel ci-dessus peuvent être utilisées pour lier tout en ne cassant pas le motif MVVM (pattern != règle) cela dépend vraiment.

encore une chose.. ViewModel a dépendance sur le Modèle. si le modèle peut être modifié par un service ou un environnement externe. c'est" Global state " qui complique les choses.

si votre seul problème est que les modifications du serveur sont immédiatement sauvegardées, pourquoi ne pas faire quelque chose comme ceci:

//WARNING: typed in SO window
public class ViewModel
{
    private string _title;
    public string Title
    {
        get { return _title; }
        set
        {
            if (value != _title) 
            {
                _title = value;
                this.OnPropertyChanged("Title");
                this.BeginSaveToServer();
            }
        }
    }

    public void UpdateTitleFromServer(string newTitle)
    {
        _title = newTitle;
        this.OnPropertyChanged("Title"); //alert the view of the change
    }
}

ce code alerte manuellement la vue du changement de propriété depuis le serveur sans passer par le setter de propriété et donc sans invoquer le code" save to server".

la raison pour laquelle vous avez ce problème est que votre modèle ne sait pas s'il est sale ou non.

string Title {
  set {
    this._title = value;
    this._isDirty = true; // ??!!
  }
}}

la solution est de copier les modifications du serveur via une méthode séparée:

public void CopyFromServer(Model serverCopy)
{
  this._title = serverCopy.Title;
}