MVVM: Enlace al Modelo mientras mantiene el Modelo sincronizado con una versión de servidor

Sugeriría agregar Controladores a la mezcla MVVM (MVCVM?) para simplificar el patrón de actualización.

El controlador escucha los cambios en un nivel superior y propaga los cambios entre el Modelo y ViewModel.

Las reglas básicas para mantener las cosas limpias son:

• Los ViewModels son contenedores tontos que contienen cierta forma de datos. No saben de dónde vienen los datos ni dónde se muestran.
• Las vistas muestran una cierta forma de datos (a través de enlaces a un modelo de vista). No saben de dónde vienen los datos, solo cómo mostrarlos.
• Los modelos proporcionan datos reales. No saben dónde se consume.
• Los controladores implementan la lógica. Cosas como suministrar el código para ICommands en máquinas virtuales, escuchar cambios en los datos, etc. Rellenan las máquinas virtuales a partir de Modelos. Tiene sentido que escuchen los cambios de VM y actualicen el Modelo.

Como se mencionó en otra respuesta, su DataContext debe ser el VM (o propiedad de la misma), no el modelo. Apuntar a un modelo de datos hace que sea difícil separar las preocupaciones (por ejemplo, para el Desarrollo Impulsado por Pruebas).

La mayoría de las otras soluciones ponen lógica en ViewModels lo cual "no es correcto", pero veo los beneficios de los controladores pasados por alto todo el tiempo. Maldito acrónimo MVVM! :)

El enlace del modelo a ver directamente solo funciona si el modelo implementa la interfaz INotifyPropertyChanged. (eg. su modelo generado por Entity Framework)

Modelo implementar INotifyPropertyChanged

Puedes hacer esto.

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 como DTO

Si el modelo implementa INotifyPropertyChanged(depende), puede usarlo como DataContext en la mayoría de los casos. pero en DDD la mayoría del modelo MVVM será considerado como EntityObject no como un Modelo de Dominio real.

La forma más eficiente es para usar ViewModel como 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);
    }
}

Ambas propiedades de ViewModel anteriores se pueden usar para enlazar sin romper el patrón MVVM (pattern != regla) realmente depende.

Una cosa más.. ViewModel tiene dependencia del Modelo. si el modelo puede ser cambiado por el servicio/entorno externo. es el "estado global" lo que complica las cosas.

Si su único problema es que los cambios del servidor se vuelven a guardar inmediatamente, ¿por qué no hacer algo como lo siguiente:

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

Este código alerta manualmente la vista del cambio de propiedad desde el servidor sin pasar por el configurador de propiedades y, por lo tanto, sin invocar el código "guardar en el servidor".

La razón por la que tiene este problema es porque su modelo no sabe si está sucio o no.

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

La solución es copiar los cambios del servidor a través de un método separado:

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